Introduction
This project started as a way to remember how to construct a decent installer using Wix. The syntax of Wix is just bizarre enough that every 6 months or so when I need to create one I had to learn it all over again. So WixApp was constructed to provide a simple method for construction a Wix input file. That is then compiled using Visual Studio in the normal way and an installer is created.
Wix is a very complex product, WixApp is very simple. There are only a few things that it can do:
- Accept files that need to be installed in Progarm Files (x86)
- Create Shortcuts (when requested) on the start menu and the desktop
- Create one or more directories as needed into which files are placed in Program Files
- It can create up to two levels of directories in Program Files and the Start Menu
- If requested it will append a path to the system path
- When WixApp is installed, SetEnv will also be installed
- The version number may be retrieved from an executable for the installer to use during installation
- It will create an uninstaller that will remove all of the files and directories that it creates
How Does WixApp Work
WixApp on starup presents an empty dialog box with a few menu items (one of which is Help that displays this text). The Files Menu allows one to create a new WixApp data file (i.e. "xxx.wxd") and Wix input file Product.wxs. It also allows one to open an existing data file. The dialog box is populated from a data file or is left blank for the user to supply new data. When one is satisfied with the input the Create button saves both the data file and a new Product.wxs file. Up to 10 previous Product.wxs files are kept as backup (e.g. Product.wxs.23). The the Wix compilation can take place, errors noted and changes made to the WixApp dialog box.
Wix File Structure
Wix has roughly four main sections:
- Product Section
- Features Section
- Directory Section
- Components Section
WixApp takes a different approach. There is one main dialog box (and a couple of minor ones). It has four edit boxes and one button to enter the necessary data for the Product Section. It has a drop down combo box and two buttons for managing a Feature (a Feature is a list of Components). There is a drop down combo box and two buttons that allow the user to manage components. The attributes for a component may be entered/modifed in five edit boxes, four check boxes and a couple of browse buttons.
The user supplies the information about all the Features and Components for each feature and WixApp rearranges the information for Wix.
Directory Paths
A path in Windows is the text description of the location of a directory in a tree of directories. It is typically composed of a hard drive letter followed by colon and back slash followed by one or more names separated from each other by back slashes. WixApp may construct the Product.wxs using a fully qualified path or to use the location of the Visual Studio solution file as the starting point for a path (i.e. $SolutionDir)..\Release\xxx.exe).
When New is selected in the File Menu a dialog box describes this step and next takes one to an open file dialog box to select the xxx.sln file for the project. If something happens (like a reorganization of the directories) the solution path may be adjusted by the selecting the Solution Menu item. The solution need only be input once usually so it does not appear in the Main Dialog Box. The Solution Dialog Box allows the user to use either addresses relative to the Solution directory or absolute addresses.


×
Modal Header
Some text in the Modal Body
Some other text...

Belgian White Chocolate
Vanilla
Nutmeg
Cinnamon
Marshmallows
Dark Chocolate
Chestnut
Pistachio
Salted Caramel
Mulled Spices
Cardamom
Clementine
Rooibos
RETURN
NEW CHRISTMAS SANDWICHES
ClICK ON TWO INGREDIENTS YOU LIKE, AND LEAVE THE REST TO US.
Gruyere
mozzarella
Cheddar
Brie
Turkey
Chicken
Pork
Salami
Prosciutto
Bacon
Dijonaisse
Wholegrain Mustard
Mayonaisse
Cranberry Sauce
Spiced Apple & Cranberry Chutney
Pork and Sage Stuffing
Horseradish Mayo
Honey Roasted Pulled Ham
Smoked Cheddar
RESTART
RESULTS
MMM, WE THINK YOU'LL LIKE THE SOUND OF THIS!
PRODUCT TITLE
PRODUCT DESCRIPTION
£0.00
RESTART
FIND A BENUGO
We are located in some of London's most iconic locations, you can find us at the following locations to get your new Benugo Christmas fix


The inaugural SRQ Am Series and Music Festival is an event to showcase the unique blend of sports and music culture we love so much here on Florida’s best coast.
Participant Early Registration - $12
Spectator Entry Fee - $4
Ages 10 and under get in Free with accompanying adult!
Participant Registration - $15
Spectator Entry Fee - $5
Ages 10 and under still get in Free with accompanying adult!
PLEASE NOTE: All General Admission purchases are final and can only be refunded within 15 days of the event.
Participants: If for any reason you cannot attend, please make sure to give full notice within 15 days to receive a refund and so we can try to fill your slot with another participant.
Use the hashtag #SRQAm so we can check out your posts from the event.
Like, share, and follow the event on acebook and stay tuned to the SRQ Am Fest page for updates.
Check out the SRQ Am Lineup and let us know if your band should be on the list!
We will try to stay on schedule as much as possible, but of course these times are all approximate. Start times can vary based on the number of participants, so make sure to arrive early for your group.


These are contained in app.js and should be edited before prod. Probably also refactored.
{{f.value}}


Abstract: 自己记录一下每天Master项目的Log
Train the model with transfer tech. does not work (Orange: real data tuning, Blue: synthetic data pretrain)
By looking at the board, we can see that the model is not learning properly, as if it is well pretrained, the starting point for the tuning (orange) line should be closer to the blue one, as we assume two domains should share some features in higher dimension, like this:
We are expecting the model to at least learn the intersection part of the knowledge from the synLiDAR, but in practice this is not the case, as shown by training progress.
The width of the canvas set in the SqueezeSegv2 is 2048, which may be a bit too big for SynLiDAR. -> Going to change the size to 1024 and train again
Going to use the pre-trained synLiDAR model to infer on the SemanticKitti directly, and test the performance:
A more detailed setting:
| train | FineTune? | Infer |
|---|---|---|
| Synthetic | Synthetic | Real |
| Synthetic | Real | Real |
| Real | Real | Real |
Going to evaluate above settings step by step.
Schedule:
The biggest problem for choosing a good baseline model is that you do not know which trick they actually played to achieve a better scoring for the accuracy, and it is often the case that such technique is not applicable for other dataset, that is, they cannot be transplanted to other tasks at all..


I came upon py.test a while ago, via Jarno Virtanen (though py was named std back then). I've always disliked unittest. I created an alternate test runner based on unittest -- DataTest - but never felt great about it. OK, but not great.
Anyway, py.test has a philosophy that appeals to me: the best API is
no API. And for the most part that's it. You can read some more
about the hooks and functions in the
documentation, but you don't need them to do your work. All you need to do is
create a module test_*.py
, and define a function that
starts with test_
. py.test will automatically run it,
and any other test-looking functions it finds, and report on any
errors. This isn't complicated, but I still have no idea how to do
it with unittest, and it's not for lack of trying. (OK, I knew how
to do it, but it never felt right and now I've forgotten, which
means it never made sense to me either.) So a test might look like:
import roman def test_sanity(): for i in range(1, 4000): assert roman.fromRoman(roman.toRoman(i)) == i
You can structure your tests as classes as well, and do startup and
teardown methods and functions, but you don't have to. And you can
just use assert
, as it has fancy tracebacks; when an
assert fails it (re) evaluates every subexpression and displays them
all, so you'll see all the values you are interested in.
It has a number of other features as well. Probably the one I'm most interested in is it's still under development. Unittest was a port of a Java project (which was a port of a Smalltalk project), and it just kind of appeared. It's never fit into Python well. For something so important, there needs to be a real feedback cycle, and continued development in response to people's needs. Testing should be easy, and this is the first testing framework that's really as easy as I think it should be. Well, doctest is also very easy and cool; py.test makes all unit testing feel like doctest.
In other doctest news, Phillip writes about doctest, and I notice there's some features in doctest in 2.4 that I had wanted.


Sahi - Web Automation and Test Tool
Documentation in this directory is not current.
Please visit http://sahipro.com/ for the latest documentation.
Introduction
Sahi is an automation and testing tool for web applications, with the facility to record and playback scripts.Developed in java and javascript, this tool uses simple javascript to execute events on the browser.
Features include, in-browser controls, text based scripts, ant support for playback of suites of tests,
and multi threaded playback. It supports HTTP and HTTPS.
Sahi runs as a proxy server and the browser needs to use the sahi server as its proxy.
Sahi then injects javascript so that it can access elements in the webpage.
This makes the tool independent of the website/ web application.
Features
- Recording of browser actions.
- Playback of recorded/scripted actions.
- Accessor Viewer for identifying html elements for scripting
- Easily editable scripts (text files)
- Simple APIs
- Integrates with ant builds
- Logging/reports
- Script is in javascript hence supports concepts and constructs that javascript supports
- Support for global variables stored across pages in a test and across tests in a suite.
- Script refactorable into functions and files.
- Scripts runnable through url.
- Bugs can be recorded by testers and
the sahi script can be published on a web server.
This url can be included in bug reports.
Developers can reproduce the bug by pointing to that url in the bug report.
- Scripts automatically available to others through HTTP
- Very lightweight
- Tests do not need the browser window to be in focus.
- Suites can run in multiple threads thus reducing the test execution time.
- Supports external proxy and HTTPS.


Hello World! My name is Jocelyn and I am a Computer Science graduate from California State University, Long Beach
A little about me: In 2015 I was an admitted college freshman majoring in Fashion Design who then changed my major to Computer Science after being introduced to Java programming my first semester.
I was amazed by the fact that I have been around code and software ever since I was young and I never noticed. Back in the day when MySpace and tumblr were popular, I learned how to play around with CSS and html to add cool effects to my wall. I also love the fact that I can see my ideas and creativity come to life with different tech stacks and code. I recently began my career as a back-end web developer at a telecommunications company.
Besides work, currently NOTHING. I am taking the time to enjoy myself free from the shackles of college. It's a nice feeling to have after-hours and weekends without any homework or studying for upcoming exams haha. I plan on developing some cybersecurity projects later on this year.
As part of the eCommerce team, developed and maintained services on the My Business B2B Wireless Portal. Helped with the eCommerce site transformation project, converting from classic legacy flow to a modern flow to match the consumer Verizon Wireless site.
Deployed and implemented an internal dashboard in an Agile environment that dynamically refines and displays features available for AMEX credit cards in different markets depending on app version, build, device, card, and credit risk type. Improved the feature search by developing four additional filters, more than doubling the previous filters available. Refactored the feature search code to reduce the complexity of the creation of future filter implementation.
Assisted the leadership team with development of script documentation and reports. Worked on troubleshooting and resolving application-related incidents. Ensured a successful domain migration of merging a client’s network drives, directories, and software onto Jacobs network.
This was our year long senior group project. Our group wanted to throw it back to our nostalgic childhoods and re-create the popular social media site, MySpace. We wanted to have first hand experience with creating a website from scratch, so this was our chance to do so. We all got to be full-stack developers and were able to set up the database, signup/login page, home page, and a profile page. Tech stack used: C#, ASP.NET, .NET Framework, Razor Pages, and Azure
Your basal metabolic rate (BMR) is the amount of energy your body exerts when resting. To calculate your BMR, I used the revised Harris-Benedict equation. This equation uses your height, age, weight, sex, and amount of weekly exercise you do. The result provides you with how many calories your body needs and varies based on your activity level. Tech stack used: React.js, material-ui, JavaScript, CSS
This project was created to help computer science peers prepare for their technical interview. This android app is modeled after Quizlet, in the form that JavaTechies sends daily code challenges in java or related to java programming. Tech stack used: Google sign-in API, Android Studio, Java
TECHNOLOchicas is a national initiative of the National Center for Women & Information Technology (NCWIT) and Televisa Foundation designed to raise awareness among young Latinas and their families about opportunities and careers in technology. By being a role model to younger women of color, this allows early engagement with subjects in technology and advancement of diversity in technology.
This year-long program runs from August to August every year and is designed to complement a student's academics offering opportunities for educational programming, industry exploration, networking, peer coaching, mentoring with industry leaders, and the potential for a summer internship or full-time job with one of Rewriting the Code’s growing list of partner companies.
With ACM at the Beach we are determined to advance the science and application of information technology by providing students with real world information through guest speakers, workshops, seminars, projects, and other activities.
The Society of Hispanic Professional Engineers (SHPE) at California State University, Long Beach student chapter, provides professional, educational and cultural support in the community. SHPE promotes academic development for the advancement of its members. Membership consists of being part of one of the largest Hispanic technical organizations.
Grace Hopper Celebration is the world's largest gathering of women technologists. It is produced by AnitaB.org and presented in partnership with ACM.
STEM Advantage utilizes a collective impact model to address gaps between the talent pool and talent acquisition, focusing on women and under-represented talent.
One thing about me is that I look forward to Thursdays, Fridays and Saturdays! Oh and Sunday Mornings because #BRUNCH! My favorite hobbies and interests are music, fitness, and fashion. Outside of this coding world, I enjoy listening and "creating" music. I am a novice "sound engineer" who prides herself with a great and well-rounded taste in music genres. I am currently learning the art behind DJ software and mixing. (Could be my backup career plan if all goes well 🤫)


Work Experience
Intern
Start.NG
March, 2020 - May, 2020
Project
Built an employee tracker application with team using C#, ASP.NET, MVC, HTML, CSS, JavaScript, and MSSQL
Intern
Rosenics Technologies
April, 2018 - September, 2018
Project
Built a Destop application for simulating flowrate measurement experiment using C# and WPF
Education
University of Uyo, 2014 - 2019
B.Eng Chemical Engineering


--- layout: page title: PII Viewer for Google Analytics date: 2014-04-08 12:00:43.000000000 +01:00 type: page published: true status: publish categories: [] tags: [] meta: _edit_last: '1' _yoast_wpseo_focuskw: personally identifiable information _yoast_wpseo_linkdex: '61' _wp_page_template: default _thumbnail_id: '2973' author: David Simpson excerpt_separator: ---
PII Viewer for Google Analytics is a Google Chrome extension which allows you to map the user ID stored in Google Analytics to locally stored personally identifiable information (PII) such as name and email address.
Sending personally identifiable information (PII) to Google Analytics is strictly prohibited, but sending a unique user ID is in a custom dimension is permitted. This extension allows you to map the user ID stored in Google Analytics to locally stored PII such as name and email address.
Rather than building your own custom integration to map this data together, you can simply reference a locally stored CSV file (or use the in-built Mailchimp integration) and let this Chrome extension do the hard work. This means that you full comply with the Google Analytics privacy policy, but get to understand your visitor data.
Update
PII Viewer for Google Analytics now supports identifying users in Behaviour Flow and Mailchimp integration.
This extension uses PII which is locally stored only, therefore this extension is fully compliant with the Google Analytics Terms of Service.
Contacts at Google have confirmed that the extension is compliant with the terms of service.
If you found this Chrome extension useful, why not say thanks by buying me a pot of tea to contribute to its maintenance. I don't do coffee.


Regular HTSQL queries
/school
A list of schools
/department{code,name}?school.code='art'
Departments in the selected school
/department{name,max(course.credits)}
Maximum number of credits per departmetn
HTSQL queries using
.htsql
/all-schools.htsql
A list of schools
/departments-by-school.htsql?school=art
Departments in the selected school


Toggle navigation
Xu, Jenna
@ NYU ITP
How New York are you?
Life Support
Speak, (Random Access) Memory
A Cognitive Behavioral Therapy App
Data Mining Myself
A Mindwandering Study
Good Vibrations
Photo Jukebox
DATA VISUALIZATION
Speak, (Random Access) Memory
CPH Air Pollution Data: July 28, 2016
Deaths by Firearms, 2014
U.S. Mass Shootings, 1982-2016
Leading Causes of Death in NYC, 2011
Chicago Gun Traces
@ AMBASSADORS FOR SUSTAINED HEALTH
Donut Dash 2017
ASH Rebrand
ASH Website Redesign
@ NEW YORK MAGAZINE
Spring/Summer Weddings 2016
Winter Weddings 2016
@ ESSENTIAL HOMME MAGAZINE
Redesign (April/May 2015)
@ CONDÉ NAST EDG/SIP
A-List: Best Performances of 2014
Epicurious: America's Best Recipes
A-List (Prototype)
Domino Color (Prototype)
Epicurious: Dinner Rush
ET CETERA
Berning Questions Mobile App
A Wedding
A Tattoo


There are a lot of things that I want to do with my life -- career related
| College | Pros | Cons |
|---|---|---|
| University of Utah | closer to home + instate tuition (cheaper) | don't know much about biology program |
| University of California - Los Angeles | Really good programs | expensive tuition and cost of living |
| University of Wasington | Not super expensive tuition and good program | far from home and out of state tuition |
| University of Portland | great program | out of state tuition and far away |
| Harvard | great opportunities and amazing education | Likelyhood of getting in is low and expensive |


Cochise Linux Guy
Home
About Linux
Services
More about Linux.
Linux is is developed with a different mindset than Windows.
Windows has a pay to use model while Linux is free and open source.

Why Choose Linux?
Well the first (and most obvious choice) is the fact Linux is free.


Admiral: {{character.admiralInheritance}}
President: {{character.presidentInheritance}}
CAG: {{character.cagInheritance}}
Cylon leader can never become admiral, president or CAG.
{{draw.amount}} {{draw.sphere}}
Expansion: {{character.set}}
{{character.oncePerTurnTitle}} - {{character.oncePerTurnText}}
{{character.oncePerGameTitle}} - {{character.oncePerGameText}}
{{character.weaknessTitle}} - {{character.weaknessText}}
Setup: {{character.startLocation}}


Texture Compression and Decompression¶
For more details see Bibliography Reference (1)
BC1 Block (S3TC/DXT1)¶
BC1 block consists of two base colors c0 and c1 and an index table (bitmap).
The index table, however, has a two-bit entry, since BC1 allows for 2 additional colors, c2 and c3 obtained by blending of the base colors. All together c0, c1, c2 and c3 could be treated as a local palette for a compressed block. The base colors are stored in RGB565 format, i.e. 5 bits for red and blue channels and 6 bit for green channel, resulting in 4bpp compression level.
There are two types of BC1 blocks: the first one that does not support transparency and the second one, that does.
BC2 Block (DXT2/DXT3)¶
The BC1 format can manage 24-bit RGB textures, but is unsuitable for 32-bit RGBA8888 textures. The BC2 block occupies 128 bit, twice the BC1 size. Therefore, compression level is 8bpp. One half of the BC2 is reserved for alpha values with 4-bit precision, the other one is just a BC1 for storing RGB data
BC3 Block (DXT4/DXT5)¶
The BC3 block, likewise BC2, consists of two 64-bit parts: one for the alpha data and one for the color data. Color part repeats the BC1 layout as well, but the alpha part is stored in the compressed form. Alpha compression is very similar to the DXT1 except for the number of the channels; there are two endpoints with 8-bit precision and the table of 3-bit indexes allowing to choose one of the eight values of a local palette.
BC4 Block (ATI1/3Dc+)¶
The BC4 block (Figure 9) is just an alpha part of the BC3 block. It is used for 1-channel textures, for example a height map or a specular map. Decoded values are associated with the red channel.
BC5 Block (ATI2/3Dc)¶
The 3Dc format was originally developed by ATI specially for the normal map compression, as the DXT1 format did not provide the required quality for such data. Normal map contains information about the direction of normal vector for every texel, which allows one to compute lighting with high level of detail and without increasing the geometry complexity.
BC6H¶
The BC6H format is designed to compress textures with high dynamic range (HDR). Only RGB images without alpha are supported. The format uses 128-bit blocks, resulting in 8bpp compression level. Depending on the block type, a compressed block has a different set of fields and a different size of each field. This allows choosing the best encoding on the per block basis. This flexibility greatly reduces compression artifacts, but strongly complicates the compression procedure. The number of block types has increased to 14 for BC6H and to 8 for BC7. Unlike BC1, block type is set explicitly in the first bits of compressed block. Block type is also referred to as the block mode.
BC7¶
Improves quality be adding new formats that improve the endpoint precision and storing up to three pairs of endpoints. The format uses 128-bit blocks, resulting in 8bpp compression level.


Petts Wood Road, Petts Wood, Orpington
Attractive three bedroom semi-detached family home situated within 0.5 miles of Petts Wood station with fast trains to London and within easy walking distance of local shops, schools, bus routes and National Trust woodland. The property comprises; two receptions, fitted 18'9 x 10'1 kitchen/breakfast room and conservatory. The property also benefits from having a utility room and cloakroom. To the first floor there are three bedrooms and a family bathroom with separate WC. Additional features include double glazing, gas central heating and a well presented interior
From the outside this house looks cozy. It has been built with white stones and has mahogany wooden decorations. Tall, rounded windows brighten up the house and have been added to the house in a very symmetric way.
The house is equipped with a modern kitchen and three bathrooms, it also has a large living room, four bedrooms, a snug dining room, a bar and a grand garage.
The building is rectangular shaped. The house is half surrounded by overgrown wooden overhanging panels.
The second floor is the same size as the first, but part of it hangs over the edge of the floor below, creating an overhang on one side and a balcony on the other. This floor has roughly the same style as the floor below.
The roof is low and rounded and is covered with brown roof tiles. Two large chimneys sit at the side of the house. Several small windows let in just enough light to the rooms below the roof.
The house itself is surrounded by paved ground, with various party spots, like a fancy barbeque and a firepit.


|
DEMO: The Chords Extension
|
The methods provided in the Chords extension allow music-savvy Web developers to apply their knowledge of music in a manner that is familiar to them, proving invaluable as an aid in the development of Web-based music instruction applications and intelligent musical "jam along" applications.
| Taste Some Chords |
In the table below, each row contains a button that will play a musical chord when clicked. To the right of each button is the source code of the playChord method call for each button. Each chord in the table is being played on a different instrument from the Beatnik soundbank. Combining different instruments and chords demonstrates very clearly the vast array of sound textures that can be achieved using just the built-in Beatnik soundbank.

The interface below is designed to resemble a call to the playChord method and lets you edit all of the method's parameters. An entry box is provided for each of the method's parameters, with the exception of the MidiChannel1to16 parameter which has a fixed value of 1 in this interface. To the left of each parameter entry box is the name of the parameter and, wherever reference information is available for a parameter, the parameter name is linked to the reference information.
So, go ahead and tweak the parameters in the interface below. When you have a set of values that you like and you'd like to preview the chord that would result from those settings, just hit the "Preview" button...
You can also "seed" the interface with values by returning to the previous Taste Some Chords section and clicking on any of the buttons to play a chord. When you scroll back down again to this section, then the parameters in the playChord Method Editor's interface will be seeded with the values needed to play the chord you just played. You can then edit the parameters from there to derive new chords from those listed in the previous section.
Don't be thrown off by the fact that each parameter is on its own new line. This layout was chosen so that it wouldn't be necessary to scroll horizontally all the time to edit different parameters. It is also perfectly acceptable in the JavaScript language to break up a method or function call over several lines, provided that you don't end a line on an unterminated string literal (ie. start a string parameter with an opening quote but don't close the string on the same line). For example, the following method call is perfectly valid in JavaScript...
myMusicObject.playChord ( 1, 1, 8, 'Emaj7#11', 4, 'E', 127, 1300 ); |
| Strum It! |
Thanks to the Chord extension's Music.getChordNotes static method, the interface below lets you strum the individual notes that make up the last chord you played using the previous Taste Some Chords and Try Your Hand sections.
Run your mouse across the green blocks below to strum the chord...
Above each green block is a textbox containing the name of the note that corresponds to that block. If you go back up to one of the previous sections and play a different chord, then when you scroll back down to this section you will notice that the notes will have changed.
NOTE : Because the Music.getChordNotes method returns an array containing the MIDI note numbers of the notes in the chord, using the Music.getNoteName method on the individual notes that make up the chord will not always generate the note names one might expect. This is because the Music.getNoteName always uses a sharp accidental ("#") in place of a flat accidental ("b") for notes that require an accidental. So, you may see sharp note names making up some chords in places where you'd otherwise expect to see flat notes, based on your musical understanding of the chords.


Preload every visible link:
Lazyload images:
Blacklist sites:
Note, has to be in the format: www.example.com, example2.com
Save


Letter:
Encrypted code: ${code}
Cache thread: ${cacheThreadName}
Database I/O thread: ${databaseThreadName}


Description
Memory based game which consists of 4 Blinking LED Lights. The game challenges participants memory, as they attempt to memorize the sequence that is displayed and repeat the same. They will be given a time limit of 2 seconds after the last LED output to input the sequence, failure to which the game resets. 5 points will be awarded for each level cleared.
Pre requisite
Focus, Common Sense, Memory
Team size:
Max. Team of 5 and Min. of 2 members
Event location:
B Block, Second Floor, Room - 308
Contact : Manoviraj Singh :<PHONE_NUMBER> & Riya Desai:<PHONE_NUMBER>


All JDBI exceptions extend RuntimeException, so you can skip catching them. The methods declare which ones they throw, despite them being runtime, so autocompletion in various IDEs should be able to pick up on them.
RuntimeException


@import play.api.Play.current @import play.api.i18n.Messages.Implicits._ @import app.Config @import models.HttpRequestModel.ClassifyResult @import controllers.EvaluationRequest @(viewData: ViewData)(implicit defaultValues: Config.Defaults.type) @main(viewData.routePath) {
"It is said that if you know your enemies and know yourself, you will not be imperiled in a hundred battles; if you do not know your enemies but do know yourself, you will win one and lose one; if you do not know your enemies nor yourself, you will be imperiled in every single battle." -- Sun Tzu --
Suggestions
| Algorithm | Democrat (%) | Republican (%) |
|---|


Temporal Flux
A subtle acceleration of time around the player allows them to move more quickly, anticipate attacks, and negate the slowing effects of enemy skills.
${value}% Chance to Avoid Projectiles
3 5 8 10 12 15 18 21 23 25
${value}% Slow Resistance
8 12 16 20 24 28 32 36 40 45
+${value}% Total Speed
2 4 6 8 10 12 14 15 16 18
MaxLevel
6
UltimateLevel
10


This document describes how to build a high-availability (HA) Kubernetes cluster. This is a fairly advanced topic. Users who merely want to experiment with Kubernetes are encouraged to use configurations that are simpler to set up such as the simple Docker based single node cluster instructions, or try Google Container Engine for hosted Kubernetes.
Also, at this time high availability support for Kubernetes is not continuously tested in our end-to-end (e2e) testing. We will be working to add this continuous testing, but for now the single-node master installations are more heavily tested.
Setting up a truly reliable, highly available distributed system requires a number of steps, it is akin to wearing underwear, pants, a belt, suspenders, another pair of underwear, and another pair of pants. We go into each of these steps in detail, but a summary is given here to help guide and orient the user.
The steps involved are as follows:
Here’s what the system should look like when it’s finished:
Ready? Let’s get started.
The remainder of this guide assumes that you are setting up a 3-node clustered master, where each machine is running some flavor of Linux. Examples in the guide are given for Debian distributions, but they should be easily adaptable to other distributions. Likewise, this set up should work whether you are running in a public or private cloud provider, or if you are running on bare metal.
The easiest way to implement an HA Kubernetes cluster is to start with an existing single-master cluster. The instructions at https://get.k8s.io describe easy installation for single-master clusters on a variety of platforms.
On each master node, we are going to run a number of processes that implement the Kubernetes API. The first step in making these reliable is
to make sure that each automatically restarts when it fails. To achieve this, we need to install a process watcher. We choose to use
the kubelet
that we run on each of the worker nodes. This is convenient, since we can use containers to distribute our binaries, we can
establish resource limits, and introspect the resource usage of each daemon. Of course, we also need something to monitor the kubelet
itself (insert who watches the watcher jokes here). For Debian systems, we choose monit, but there are a number of alternate
choices. For example, on systemd-based systems (e.g. RHEL, CentOS), you can run ‘systemctl enable kubelet’.
If you are extending from a standard Kubernetes installation, the kubelet
binary should already be present on your system. You can run
which kubelet
to determine if the binary is in fact installed. If it is not installed,
you should install the kubelet binary, the
kubelet init file and high-availability/default-kubelet
scripts.
If you are using monit, you should also install the monit daemon (apt-get install monit
) and the high-availability/monit-kubelet and
high-availability/monit-docker configs.
On systemd systems you systemctl enable kubelet
and systemctl enable docker
.
The central foundation of a highly available solution is a redundant, reliable storage layer. The number one rule of high-availability is to protect the data. Whatever else happens, whatever catches on fire, if you have the data, you can rebuild. If you lose the data, you’re done.
 This means that to lose data, all three nodes would need to have their physical (or virtual) disks fail at the same time. The probability that this occurs is relatively low, so for many people running a replicated etcd cluster is likely reliable enough. You can add additional reliability by increasing the size of the cluster from three to five nodes. If that is still insufficient, you can add even more redundancy to your storage layer.
The full details of clustering etcd are beyond the scope of this document, lots of details are given on the etcd clustering page. This example walks through a simple cluster set up, using etcd’s built in discovery to build our cluster.
First, hit the etcd discovery service to create a new token:
curl https://discovery.etcd.io/new?size=3
On each node, copy the etcd.yaml file into /etc/kubernetes/manifests/etcd.yaml
The kubelet on each node actively monitors the contents of that directory, and it will create an instance of the etcd
server from the definition of the pod specified in etcd.yaml
.
Note that in etcd.yaml
you should substitute the token URL you got above for ${DISCOVERY_TOKEN}
on all three machines,
and you should substitute a different name (e.g. node-1
) for ${NODE_NAME} and the correct IP address
for ${NODE_IP}
on each machine.
Once you copy this into all three nodes, you should have a clustered etcd set up. You can validate with
etcdctl member list
and
etcdctl cluster-health
You can also validate that this is working with etcdctl set foo bar
on one node, and etcd get foo
on a different node.
Of course, if you are interested in increased data reliability, there are further options which makes the place where etcd installs it’s data even more reliable than regular disks (belts and suspenders, ftw!).
If you use a cloud provider, then they usually provide this for you, for example Persistent Disk on the Google Cloud Platform. These are block-device persistent storage that can be mounted onto your virtual machine. Other cloud providers provide similar solutions.
If you are running on physical machines, you can also use network attached redundant storage using an iSCSI or NFS interface. Alternatively, you can run a clustered file system like Gluster or Ceph. Finally, you can also run a RAID array on each physical machine.
Regardless of how you choose to implement it, if you chose to use one of these options, you should make sure that your storage is mounted
to each machine. If your storage is shared between the three masters in your cluster, you should create a different directory on the storage
for each node. Throughout these instructions, we assume that this storage is mounted to your machine in /var/etcd/data
Once you have replicated etcd set up correctly, we will also install the apiserver using the kubelet.
First you need to create the initial log file, so that Docker mounts a file instead of a directory:
touch /var/log/kube-apiserver.log
Next, you need to create a /srv/kubernetes/
directory on each node. This directory includes:
The easiest way to create this directory, may be to copy it from the master node of a working cluster, or you can manually generate these files yourself.
Once these files exist, copy the kube-apiserver.yaml into /etc/kubernetes/manifests/
on each master node.
The kubelet monitors this directory, and will automatically create an instance of the kube-apiserver
container using the pod definition specified
in the file.
At this point, you should have 3 apiservers all working correctly. If you set up a network load balancer, you should be able to access your cluster via that load balancer, and see traffic balancing between the apiserver instances. Setting up a load balancer will depend on the specifics of your platform, for example instructions for the Google Cloud Platform can be found here
Note, if you are using authentication, you may need to regenerate your certificate to include the IP address of the balancer, in addition to the IP addresses of the individual nodes.
For pods that you deploy into the cluster, the kubernetes
service/dns name should provide a load balanced endpoint for the master automatically.
For external users of the API (e.g. the kubectl
command line interface, continuous build pipelines, or other clients) you will want to configure
them to talk to the external load balancer’s IP address.
So far we have set up state storage, and we have set up the API server, but we haven’t run anything that actually modifies
cluster state, such as the controller manager and scheduler. To achieve this reliably, we only want to have one actor modifying state at a time, but we want replicated
instances of these actors, in case a machine dies. To achieve this, we are going to use a lease-lock in etcd to perform
master election. On each of the three apiserver nodes, we run a small utility application named podmaster
. It’s job is to implement a master
election protocol using etcd “compare and swap”. If the apiserver node wins the election, it starts the master component it is managing (e.g. the scheduler), if it
loses the election, it ensures that any master components running on the node (e.g. the scheduler) are stopped.
In the future, we expect to more tightly integrate this lease-locking into the scheduler and controller-manager binaries directly, as described in the high availability design proposal
First, create empty log files on each node, so that Docker will mount the files not make new directories:
touch /var/log/kube-scheduler.log
touch /var/log/kube-controller-manager.log
Next, set up the descriptions of the scheduler and controller manager pods on each node.
by copying kube-scheduler.yaml and kube-controller-manager.yaml into the /srv/kubernetes/
directory.
Now that the configuration files are in place, copy the podmaster.yaml config file into /etc/kubernetes/manifests/
As before, the kubelet on the node monitors this directory, and will start an instance of the podmaster using the pod specification provided in podmaster.yaml
.
Now you will have one instance of the scheduler process running on a single master node, and likewise one controller-manager process running on a single (possibly different) master node. If either of these processes fail, the kubelet will restart them. If any of these nodes fail, the process will move to a different instance of a master node.
At this point, you are done (yeah!) with the master components, but you still need to add worker nodes (boo!).
If you have an existing cluster, this is as simple as reconfiguring your kubelets to talk to the load-balanced endpoint, and restarting the kubelets on each node.
If you are turning up a fresh cluster, you will need to install the kubelet and kube-proxy on each worker node, and
set the --apiserver
flag to your replicated endpoint.
We indeed have an initial proof of concept tester for this, which is available here.
It implements the major concepts (with a few minor reductions for simplicity), of the podmaster HA implementation alongside a quick smoke test using k8petstore.


Santa heard about the General Data Protection Regulation (GDPR) ages ago, but he didn’t think that it affected him! After all, he’s been getting Christmas so right for all these years what’s different now? Well, with the GDPR a lot’s changed, and nearly every organisation will be affected, including the Grotto…
Santa just didn’t realise how important the GDPR is, but it’s the most ambitious data protection legislation passed in the EU so far! It can all sound a bit bland, but almost every business will have to change its practices when it comes to acquiring, storing and using personal data. It even applies in the UK regardless of Brexit.
What do we mean by personal data? Names, birthdays, addresses, even genetic information! The GDPR extends the rights an individual – customer, employee or elf – has over how you control their personal data. Santa stores lots of personal data at the Grotto: he sees you when you’re sleeping, he knows when you’re awake, he knows if you’ve been bad or good… So of course the GDPR affects him!


Payload Launcher
Launching a payload causes WabbitWeb to stop until the payload finishes (indicated by a slow-flashing blue LED on the Bunny).
Be aware that some payloads may force WabbitWeb to shut down, meaning after the payload is finished you have to reboot the Bunny to come back to this point.


~Scoots
Rent Your Ride
☰
Home
Rentals
Reservations
Tours
Contact
Remember
You can find all our available services at this
page
.
You can make your reservations right away at this other
page
.
Find us at one of our rental locations
Near the "Terminal Puerta Maya" further south along the coast which caters to the cruise lines and patrons.
Near to Cozumel Ferry dock, "Playa del Carmen", near "El Centro de Cozumel".
Contact Us
Full Name*
Email


Contents:
The io module provides the Python interfaces to stream handling. The builtin open function is defined in this module.
At the top of the I/O hierarchy is the abstract base class IOBase. It defines the basic interface to a stream. Note, however, that there is no separation between reading and writing to streams; implementations are allowed to raise an IOError if they do not support a given operation.
Extending IOBase is RawIOBase which deals simply with the reading and writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide an interface to OS files.
BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer streams that are readable, writable, and both respectively. BufferedRandom provides a buffered interface to random access streams. BytesIO is a simple stream of in-memory bytes.
Another IOBase subclass, TextIOBase, deals with the encoding and decoding of streams into text. TextIOWrapper, which extends it, is a buffered text interface to a buffered raw stream (BufferedIOBase). Finally, StringIO is a in-memory stream for text.
Argument names are not part of the specification, and only the arguments of open() are intended to be used as keyword arguments.
data:
DEFAULT_BUFFER_SIZE
An int containing the default buffer size used by the module’s buffered I/O classes. open() uses the file’s blksize (as obtained by os.stat) if possible.
Exception raised when I/O would block on a non-blocking I/O stream
Open file and return a stream. Raise IOError upon failure.
file is either a text or byte string giving the name (and the path if the file isn’t in the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed, unless closefd is set to False.)
mode is an optional string that specifies the mode in which the file is opened. It defaults to ‘r’ which means open for reading in text mode. Other common values are ‘w’ for writing (truncating the file if it already exists), and ‘a’ for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform dependent. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:
| Character | Meaning |
| ‘r’ | open for reading (default) |
| ‘w’ | open for writing, truncating the file first |
| ‘a’ | open for writing, appending to the end of the file if it exists |
| ‘b’ | binary mode |
| ‘t’ | text mode (default) |
| ‘+’ | open a disk file for updating (reading and writing) |
| ‘U’ | universal newline mode (for backwards compatibility; unneeded for new code) |
The default mode is ‘rt’ (open for reading text). For binary random access, the mode ‘w+b’ opens and truncates the file to 0 bytes, while ‘r+b’ opens the file without truncation.
Python distinguishes between files opened in binary and text modes, even when the underlying operating system doesn’t. Files opened in binary mode (appending ‘b’ to the mode argument) return contents as bytes objects without any decoding. In text mode (the default, or when ‘t’ is appended to the mode argument), the contents of the file are returned as strings, the bytes having been first decoded using a platform-dependent encoding or using the specified encoding if given.
buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:
encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent, but any encoding supported by Python can be passed. See the codecs module for the list of supported encodings.
errors is an optional string that specifies how encoding errors are to be handled—this argument should not be used in binary mode. Pass ‘strict’ to raise a ValueError exception if there is an encoding error (the default of None has the same effect), or pass ‘ignore’ to ignore errors. (Note that ignoring encoding errors can lead to data loss.) See the documentation for codecs.register for a list of the permitted encoding error strings.
newline controls how universal newlines works (it only applies to text mode). It can be None, ‘’, ‘n’, ‘r’, and ‘rn’. It works as follows:
If closefd is False, the underlying file descriptor will be kept open when the file is closed. This does not work when a file name is given and must be True in that case.
open() returns a file object whose type depends on the mode, and through which the standard file operations such as reading and writing are performed. When open() is used to open a file in a text mode (‘w’, ‘r’, ‘wt’, ‘rt’, etc.), it returns a TextIOWrapper. When used to open a file in a binary mode, the returned class varies: in read binary mode, it returns a BufferedReader; in write binary and append binary modes, it returns a BufferedWriter, and in read/write mode, it returns a BufferedRandom.
It is also possible to use a string or bytearray as a file for both reading and writing. For strings StringIO can be used like a file opened in a text mode, and for bytes a BytesIO can be used like a file opened in a binary mode.
file(name: str[, mode: str]) -> file IO object
Open a file. The mode can be ‘r’, ‘w’ or ‘a’ for reading (default), writing or appending. The file will be created if it doesn’t exist when opened for writing or appending; it will be truncated when opened for writing. Add a ‘+’ to the mode to allow simultaneous reading and writing.
A closed file cannot be used for further I/O operations. close() may be called more than once without error. Changes the fileno to -1.
True if the file is closed
True if the file descriptor will be closed
This is needed for lower-level file interfaces, such the fcntl module.
String giving the file mode
Only makes one system call, so less data may be returned than requested In non-blocking mode, returns None if no data is available. On end-of-file, returns ‘’.
In non-blocking mode, returns as much as is immediately available, or None if no data is available. On end-of-file, returns ‘’.
Argument offset is a byte count. Optional argument whence defaults to 0 (offset from start of file, offset should be >= 0); other values are 1 (move relative to current position, positive or negative), and 2 (move relative to end of file, usually negative, although many platforms allow seeking beyond the end of a file). Note that not all file objects are seekable.
Size defaults to the current file position, as returned by tell().The current file position is changed to the value of size.
Only makes one system call, so not all of the data may be written. The number of bytes actually written is returned.
BytesIO([buffer]) -> object
Create a buffered I/O implementation using an in-memory bytes buffer, ready for reading and writing.
True if the file is closed.
Retrieve the entire contents of the BytesIO object.
Always returns False since BytesIO objects are not connected to a tty-like device.
x.next() -> the next value, or raise StopIteration
If the size argument is negative, read until EOF is reached. Return an empty string at EOF.
If the size argument is negative or omitted, read until EOF is reached. Return an empty string at EOF.
Returns number of bytes read (0 for EOF), or None if the object is set not to block as has no data to read.
Retain newline. A non-negative size argument limits the maximum number of bytes to return (an incomplete line may be returned then). Return an empty string at EOF.
Call readline() repeatedly and return a list of the lines so read. The optional size argument, if given, is an approximate bound on the total number of bytes in the lines returned.
Returns the new absolute position.
Size defaults to the current file position, as returned by tell(). The current file position is unchanged. Returns the new size.
Return the number of bytes written.
Note that newlines are not added. The sequence can be any iterable object producing strings. This is equivalent to calling write() for each string.
Text I/O implementation using an in-memory buffer.
The initial_value argument sets the value of object. The newline argument is like the one of TextIOWrapper’s constructor.
Close the IO object. Attempting any further operation after the object is closed will raise a ValueError.
This method has no effect if the file is already closed.
Retrieve the entire contents of the object.
x.next() -> the next value, or raise StopIteration
Read at most n characters, returned as a string.
If the argument is negative or omitted, read until EOF is reached. Return an empty string at EOF.
Read until newline or EOF.
Returns an empty string if EOF is hit immediately.
Change stream position.
Returns the new absolute position.
Tell the current file position.
Truncate size to pos.
The pos argument defaults to the current file position, as returned by tell(). The current file position is unchanged. Returns the new absolute position.
Write string to file.
Returns the number of characters written, which is always equal to the length of the string.
Create a new buffered reader using the given readable raw IO object.
x.next() -> the next value, or raise StopIteration
A buffer for a writeable sequential RawIO object.
The constructor creates a BufferedWriter for the given writeable raw stream. If the buffer_size is not given, it defaults to DEFAULT_BUFFER_SIZE. max_buffer_size isn’t used anymore.
A buffered reader and writer object together.
A buffered reader object and buffered writer object put together to form a sequential IO object that can read and write. This is typically used with a socket or two-way pipe.
reader and writer are RawIOBase objects that are readable and writeable respectively. If the buffer_size is omitted it defaults to DEFAULT_BUFFER_SIZE.
A buffered interface to random access streams.
The constructor creates a reader and writer for a seekable stream, raw, given in the first argument. If the buffer_size is omitted it defaults to DEFAULT_BUFFER_SIZE. max_buffer_size isn’t used anymore.
x.next() -> the next value, or raise StopIteration
Character and line based layer over a BufferedIOBase object, buffer.
encoding gives the name of the encoding that the stream will be decoded or encoded with. It defaults to locale.getpreferredencoding.
errors determines the strictness of encoding and decoding (see the codecs.register) and defaults to “strict”.
newline controls how line endings are handled. It can be None, ‘’, ‘n’, ‘r’, and ‘rn’. It works as follows:
If line_buffering is True, a call to flush is implied when a call to write contains a newline character.
x.next() -> the next value, or raise StopIteration


Sampling Algorithms
For univariate distributions which extend protocols implementing cdf and icdf, generating independent draws can be achieved using the inverse-cdf method. For those extending only the protocol implementing cdf, icdf can fall back onto its default root finding algorithm, and the inverse-cdf method can still be used.
For other more exotic distributions of interest other sampling algorithms may be needed.
To illustrate these algorithms lets assume a trivial distribution that has a density propotional to x^2 on the unit interval
λ> (defn target-density [x]
(cond
(> x 1) 0
(< x 0) 0
:else (/ (* x x) 3)))
Metropolis-Hastings
(metropolis-hastings target proposal seed)
(metropolis-hastings target proposal seed log-target)
The metropolis-hastings
function has multiple arities. The function taing 3 arguments assumes that the target (a function) passed in the first argument is not computed on the log-scale. The function accepting 4 arguments accepts an additional boolean value, allowing the user to specify whether the target function passed in the first argument is specified on the log scale. The second argument, proposal, should be a function that maps a value in the domain to distribution, as to form the proposal distribution. Seed is a value in the domain at which the algorithm is started.
Like other samples on this page, metropolis-hastings
returns a lazy list of draws.
λ> (def mh-draws (metropolis-hastings target-density #(normal % 0.3) 0.5))
#'λ/mh-draws
λ> (sample mh-draws 5)
(0.5 0.5278844732151602 0.48958614718093274 0.48958614718093274 0.5880599159218269)
Here #(normal % 0.3)
is an anonymous function that maps a parameter x to a normal distribution centered around x.
The sample
function dispatches on the lazy list in order to maintain continuity of the API. As a lazy list, however, using take
also works just fine.
λ> (take 5 mh-draws)
(0.5 0.5278844732151602 0.48958614718093274 0.48958614718093274 0.5880599159218269)
The advantage of using take
, as the draws are no longer independent,
is that one can thin the draws to reduce dependence.
λ> (take 5 (take-nth 10 mh-draws))
(0.5 0.4425665105907383 0.5393113732753869 0.3961248334462656 0.890723381756662)
Slice Sampling
(slice-sampler target width seed)
(slice-sampler target width seed log-target?)
Usage same as metropolis-hastings
except width is a tuning parameter
corresponding to the width in the stepping out procedure.
Accept Reject
(accept-reject target proposal c)
c is a constant such that target < c*proposal.
λ> (take 5 (accept-reject target-density (uniform 0 1) 1))
(0.8297629001889286 0.778066797774964 0.28981042074043706 0.8582759266577196 0.8942679865725314)
λ> (sample (accept-reject target-density (uniform 0 1) 1) 5)
(0.8841717452838114 0.9360229665247679 0.923946004811828 0.9770042699079926 0.5548516755781405)


FEWD @ STC 11 August - 22 September
CSS Basics
Materials
- Finish the About Me Page. Extra points for the Resume page!
The Basics
History + General Understanding
Homework
Useful Links
Reference
- CSS Tricks - Everything from cool snippets to core concepts broken down in great tutorials
Software
- Atom - Text editor actively being developed by Github's Dev Team
Tools
Cheat Sheets
Videos
Atom Packages
- linter
- linter-json
- linter-jshint
- linter-csslint
- linter-scss-lint
- pretty-json
- project-manager
- minimap
- color-picker
- emmet
- highlight-line
- autoprefixer
- atom-beautify
- file-icons


We assure you the best price and quality, the price above includes delivery fees and a bonus!!
An experienced and proffisinoal team from our side will be at your door with all of your products
within two working days after the purchase process is done to install it for you!


--- layout: post title: It is generally agreed that the art of carving is in sad decline. date: '2008-01-13T19:16:27+00:00' tags: [] tumblr_url: http://backlog.robbevan.com/post/23673237/it-is-generally-agreed-that-the-art-of-carving-is ---
It is generally agreed that the art of carving is in sad decline.—Butcher’s Method Takes Carving Off the Table - New York Times


For my first piece in the Local Music and Local Politics series, I decided to start by reaching out to some Austin musicians. I was fortunate enough to know three people who work in Austin’s music industry as musicians, singers, and producers. In addition, they work as high school educators. I figured that it would be interesting to hear their perspective on what works and what doesn’t in Austin’s music scene, so I sat down with them individually, recorded interviews, and assembled the insights I found to be most striking into this piece. This originally aired on October 6, 2017.
For my second piece in the Local Music and Local Politics series, I continued with Austin to comment on data from the Austin Music Census, a large survey conducted by the City of Austin. This survey asked those who work in Austin’s music economy in many professions, both full and part-time, some qualitative and quantitative questions. In my piece, I summarized the survey and gave description and commentary on the data points that I regarded as particularly interesting, surprising, or notable. This originally aired on November 3, 2017.


At Nalukai, Aaron creates and implements curriculum, hustles to find mentors, and teaches digital storytelling. Outside of Nalukai he is focused on creating student-centered systems to authentically tell the story of learning communities. At Hawai'i Preparatory Academy (HPA) he teaches Digital Journalism and Social Entrepreneurship courses that are centered around Product-Based Learning, the Lean Startup methodology, project management, and building digital brands. The class is supported by mentors across industries working directly with students on their products. Aaron's professional background is in international business, digital storytelling, operations/management, UX/UI, and content creation.
Mudit is a graduate of uc Berkeley, is a published machine learning researcher, startup advisor, and data person. He's passionate about helping teams of people reach an inflection point with initiatives and has a lot of experience mentoring startup teams all over the world. Teams he has mentored have gone to raise money, get into startup incubators, and win competitions as well. he has worked at many startups nut currently works at Mixbook.
Engage with students by inviting industry professionals to the classroom create a collaborative networking experience. Create a movement of inspired students who will discover an endless amount of possibilities.
Engage with students by inviting industry professionals to the classroom create a collaborative networking experience. Create a movement of inspired students who will discover an endless amount of possibilities.
Engage with students by inviting industry professionals to the classroom create a collaborative networking experience. Create a movement of inspired students who will discover an endless amount of possibilities.
Engage with students by inviting industry professionals to the classroom create a collaborative networking experience. Create a movement of inspired students who will discover an endless amount of possibilities.
Engage with students by inviting industry professionals to the classroom create a collaborative networking experience. Create a movement of inspired students who will discover an endless amount of possibilities.
Engage with students by inviting industry professionals to the classroom create a collaborative networking experience. Create a movement of inspired students who will discover an endless amount of possibilities.


In 1895 Austria, a princess named Aurora is born to a Duke, who rules over a kingdom of five hills, and his beautiful, yet mysterious wife. After Aurora's mother apparently died, her father eventually remarried. On Easter Eve, Aurora falls mysteriously ill, her body freezes, and she seemingly dies in her sleep. Aurora is the main character of CoL.


Module: Transit::Extension
- Defined in:
- lib/transit/extension.rb,
lib/transit/extensions/publishing.rb,
lib/transit/extensions/attachments.rb,
lib/transit/extensions/translations.rb,
lib/transit/extensions/content_blocks.rb
Overview
Adds support for defining extensions to be utilized by deliverables. These are useful for providing global methods or functionality that can easily be used within any deliverable resource. Sure.. you could just write modules and include them, but this way is so much more Railsesque ;)
Defined Under Namespace
Modules: Attachments, ContentBlocks, Loader, Publishing, Translations Classes: MissingExtensionError
Class Method Summary (collapse)
-
+ (Object) add(name, path = nil)
Extensions can be included from other gems or libraries.
Class Method Details
+ (Object) add(name, path = nil)
Extensions can be included from other gems or libraries. To enable autoloading of these extensions, add them with the .add method.
20 21 22 23 |
# File 'lib/transit/extension.rb', line 20 def add(name, path = nil) path ||= "transit/extensions/#{name.to_s.underscore}" self.send(:autoload, name.to_sym, path) end |


This is the core API library for Taskcamp, by In the Loft Studios. It should be used by clients wishing to work with this application.
At the heart, it defines a new serialzation format which is a combination of HTML, YAML, and markdown to represent complicated data relationships, which look like the following. See this page for more info.
The corresponding MIME type is: application/prs.taskcamp.entity
.
<type property="123"/>
---
attribute: value
---
# title
body
composer require aklump/taskcamp_api
This is what a JSON representation of an \AKlump\Taskcamp\API\Entity
looks like:
{
"type": "bug",
"properties": {
"projectName": "My Project",
"projectId": 123
},
"data": {
"device": "mac",
"os": {
"name": "macosx",
"version": "10.13.6"
}
},
"title": "The title has too much top margin",
"body": ""
}
Here is how you would deserialize a JSON string, like the one above.
use AKlump\Taskcamp\API\Entity;
use AKlump\Taskcamp\API\EntityEncoder;
use AKlump\Taskcamp\API\EntitySerializer;
$serializer = new EntitySerializer();
$entity = $serializer->deserialize($json, Entity::class, 'json');
If the data was encoded in another format you would use either of these:
$entity = $serializer->deserialize($entity_markup, Entity::class, EntityEncoder::TYPE);
$entity = $serializer->deserialize($xml, Entity::class, 'xml');
Here's how you would serialize an object into EntityEncoder::TYPE
format.
$entity = new Entity();
$entity
->setType('feature')
->setTitle('Augment the footer with another section')
->setBody('In order to fit in the about section in the footer, we need to create a fourth column that can take a custom block. The block needs to be added to the region so the client can edit it.')
->setProperties(['projectId' => 123])
->setData(['prioritye' => 'high']);
$markup = $serializer->serialize($entity, EntityEncoder::TYPE);
And this is how that format looks:
<feature projectId="123"/>
---
priority: high
---
# Augment the footer with another section
In order to fit in the about section in the footer, we need to create a fourth column that can take a custom block. The block needs to be added to the region so the client can edit it.
@todo
yarn add @aklump/taskcamp_api
Or if not using yarn:
npm install @aklump/taskcamp_api


class RubyProf::Profile
Public Instance Methods
exclude_common_methods!()
click to toggle source
Hides methods that, when represented as a call graph, have extremely large in and out degrees and make navigation impossible.
# File lib/ruby-prof/profile.rb 22 def exclude_common_methods! 23 ExcludeCommonMethods.apply!(self) 24 end
exclude_methods!(mod, *method_or_methods)
click to toggle source
# File lib/ruby-prof/profile.rb 26 def exclude_methods!(mod, *method_or_methods) 27 [method_or_methods].flatten.each do |name| 28 exclude_method!(mod, name) 29 end 30 end
exclude_singleton_methods!(mod, *method_or_methods)
click to toggle source
# File lib/ruby-prof/profile.rb 32 def exclude_singleton_methods!(mod, *method_or_methods) 33 exclude_methods!(mod.singleton_class, *method_or_methods) 34 end
measure_mode_string()
click to toggle source
# File lib/ruby-prof/profile.rb 7 def measure_mode_string 8 case self.measure_mode 9 when WALL_TIME 10 "wall_time" 11 when PROCESS_TIME 12 "process_time" 13 when ALLOCATIONS 14 "allocations" 15 when MEMORY 16 "memory" 17 end 18 end
merge! → self
click to toggle source
Merges RubyProf
threads whose root call_trees reference the same target method. This is useful when profiling code that uses a main thread/fiber to distribute work to multiple workers. If there are tens or hundreds of workers, viewing results per worker thread/fiber can be overwhelming. Using merge!
will combine the worker times together into one result.
Note the reported time will be much greater than the actual wall time. For example, if there are 10 workers that each run for 5 seconds, merged results will show one thread that ran for 50 seconds.
# File lib/ruby-prof/profile.rb 48 def merge! 49 # First group threads by their root call tree target (method). If the methods are 50 # different than there is nothing to merge 51 grouped = threads.group_by do |thread| 52 thread.call_tree.target 53 end 54 55 # For each target, get the first thread. Then loop over the remaining threads, 56 # and merge them into the first one and ten delete them. So we will be left with 57 # one thread per target. 58 grouped.each do |target, threads| 59 thread = threads.shift 60 threads.each do |other_thread| 61 thread.merge!(other_thread) 62 remove_thread(other_thread) 63 end 64 thread 65 end 66 67 self 68 end


Our home-made and hand crafted cakes makes any occassion feel more Joyful ♥
While ordering cakes online, you will get to know that there are more than 100 designs and sizes of the cake and you can chose the one you like to have. While if you go to a retail shop and try to order from there, you will get only a limited number of cakes and designs, and if you will go with us you will get a large variety of cake designs You can chose cake for birthdays, anniversaries, promotions, marriage and every small and big celebrations.
Cooking require confident guesswork and improvisation---Experimentation and substituition. Dealing with failure and uncertainty in a creative way.See our new creative menu creatively Baked
Food will be delivered to your door steps by our riders please login to your facebook account to Order now


{% extends 'bootstrap/base.html'%} {% import 'macros.html' as macro%} {% import 'bootstrap/wtf.html' as wtf %} {% block content%}


16.4 Description of Shortest
Paths
Finding the shortest path, or minimum-weight path, from one vertex to another in a graph
is an important distillation of many routing problems.
Formally stated, given a directed, weighted graph G = (V, E
), the shortest path from vertex s to t
in V is the set S of edges in E that connect s to t
at a minimum cost.
When we find S, we are solving the single-pair shortest-path problem. To do this,
in actuality we solve the more general single-source shortest-paths
problem , which solves the single-pair
shortest-path problem in the process. In the single-source
shortest-paths problem, we compute the shortest paths from a
start vertex s to all other
vertices reachable from it. We solve this problem because no
algorithm is known to solve the single-pair shortest-path
problem any faster.
16.4.1 Dijkstra's Algorithm
One approach to solving the
single-source shortest-paths problem is Dijkstra's algorithm (pronounced
"Dikestra"). Dijkstra's algorithm grows a shortest-paths tree, whose root is
the start vertex s and whose
branches are the shortest paths from s to all other vertices in G. The algorithm requires that all
weights in the graph be nonnegative. Like Prim's algorithm,
Dijkstra's algorithm is another example of a greedy algorithm
that happens to produce an optimal result. The algorithm is
greedy because it adds edges to the shortest-paths tree based
on which looks best at the moment.
Fundamentally, Dijkstra's algorithm works by
repeatedly selecting a vertex and exploring the edges incident
from it to determine whether the shortest path to each vertex
can be improved. The algorithm resembles a breadth-first
search because it explores all edges incident from a vertex
before moving deeper in the graph. To compute the shortest
paths between s and all other
vertices, Dijkstra's algorithm requires that a color and
shortest-path estimate be maintained with every vertex.
Typically, shortest-path estimates are represented by the
variable d.
Initially, we set all colors to white, and we
set all shortest-path estimates to , which represents an
arbitrarily large value greater than the weight of any edge in
the graph. We set the shortest-path estimate of the start
vertex to 0. As the algorithm progresses, we assign to all
vertices except the start vertex a parent in the
shortest-paths tree. The parent of a vertex may change several
times before the algorithm terminates.
Dijkstra's algorithm proceeds as follows.
First, from among all white vertices in the graph, we select
the vertex u with the smallest
shortest-path estimate. Initially, this will be the start
vertex since its shortest-path estimate is 0. After we select
the vertex, we color it black. Next, for each white vertex
v adjacent to u, we relax the
edge (u, v). When we relax an edge, we
determine whether going through u improves the shortest path computed
thus far to v. To make this
decision, we add the weight of (u, v)
to the shortest-path estimate for u. If this value is less than or
equal to the shortest-path estimate for v, we assign the value to v as its new shortest-path estimate,
and we set the parent of v to
u. We then repeat this process
until all vertices have been colored black. Once we have
computed the shortest-paths tree, the shortest path from s to another vertex t can be determined by starting at
t in the tree and following
successive parents until we reach s. The path in reverse is the
shortest path from s to t.
Figure
16.3 illustrates the computation of the shortest paths
between a and all other
vertices in the graph. The shortest path from a to b, for example, is 〈a, c,
f, b〉, which has a total weight of 7.
The shortest-path estimate and parent of each vertex are
displayed beside the vertex. The shortest-path estimate is to
the left of the slash, and the parent is to the right. The
edges shaded in light gray are the edges in the shortest-paths
tree as it changes.
|


This operation was good
x
x
AND
AND
- Remove
-
Conditions for :
X
Text format of the rule will appear here....
Clear
Show editable version
If
All
Any
of the following conditions are met:
+ Add condition
Using labvalue
Using previously defined condition
(+) Add group condition
(-) Remove group
Check Your Symptoms !
Check Symptoms
Click on any rule below
Comorbidity Name:
Does "
" have subcategories?
(Check the box if subcategories are present)
+
Lab Dictionary
(Shows the preselected lab values used to build the rule)
Type within the box to search and preselect lab values for the rule
Add another subcategory
Save
Reset
Delete
Export All Rules
Step 1: Select rules to test
Select All
Step 2: Fill out lab values
Step 3:
Execute rules


BTS's "Boy With Luv" becomes the 2nd most liked video of 2019.
by greenbaypackersBTS has been breaking record after record in 2019 and here is a new one. BTS's Boy With Luv, which was released on April 12th, has reached 13 million likes on Youtube. The boys are just barely second to Shawn Mendes and Camilla Cabello's Senorita who currently hold the title of Number 1 .
This is also BTS's first video to hit 13 million likes. Congratulations to BTS!


Week 7 - SQL Injection
SQL Injection can be described as an attempt to execute SQL commands via a web application that may display, alter or even delete back-end database information. This is accomplished by carefully crafted user submissions fooling the web application to run unexpected queries. OWASP has ranked SQL Injection as the number one most common form of web application vulnerability as of their 2013 report.
As mentioned above, a malicious user of your site could craft special entries to present to your web application in an attempt to compromise your security. Imagine you weren't just housing your vast movie collection in your database, but the credit card information for your 1000+ users. For an up and coming business, having to explain to the people keeping your lights on that you've just handed over their banking information to criminals won't do much for your image.
Its important to adopt certain practices in order to prevent such attacks on your precious data. User submissions should be inspected and validated prior to being handed off to the database. One should keep a tight grip on user access - those with access to the data should have the least amount of privilege with said data. Even though stored procedures are generally considered to be safe, they can be injectable. It would be best to remove those stored procedures that are not currently in use as means of preventing their misuse.


A drop in replacement for tidyr::pivot_longer which optionally takes a message and headlien to store in the history graph
# S3 method for trackr_df
pivot_longer(
data,
cols,
names_to = "name",
names_prefix = NULL,
names_sep = NULL,
names_pattern = NULL,
names_ptypes = list(),
names_transform = list(),
names_repair = "check_unique",
values_to = "value",
values_drop_na = FALSE,
values_ptypes = list(),
values_transform = list(),
...,
.messages = "",
.headline = ""
)
Arguments
| data |
A data frame to pivot. |
| cols |
<tidy-select > Columns to pivot into
longer format. |
| names_to |
A string specifying the name of the column to create
from the data stored in the column names of data .
Can be a character vector, creating multiple columns, if names_sep
or names_pattern is provided. In this case, there are two special
values you can take advantage of:
NA will discard that component of the name.
.value indicates that component of the name defines the name of the
column containing the cell values, overriding values_to .
|
| names_prefix |
A regular expression used to remove matching text
from the start of each variable name. |
| names_sep |
If names_to contains multiple values,
these arguments control how the column name is broken up.
names_sep takes the same specification as separate() , and can either
be a numeric vector (specifying positions to break on), or a single string
(specifying a regular expression to split on).
names_pattern takes the same specification as extract() , a regular
expression containing matching groups (() ).
If these arguments do not give you enough control, use
pivot_longer_spec() to create a spec object and process manually as
needed. |
| names_pattern |
If names_to contains multiple values,
these arguments control how the column name is broken up.
names_sep takes the same specification as separate() , and can either
be a numeric vector (specifying positions to break on), or a single string
(specifying a regular expression to split on).
names_pattern takes the same specification as extract() , a regular
expression containing matching groups (() ).
If these arguments do not give you enough control, use
pivot_longer_spec() to create a spec object and process manually as
needed. |
| names_ptypes |
A list of column name-prototype pairs.
A prototype (or ptype for short) is a zero-length vector (like integer()
or numeric() ) that defines the type, class, and attributes of a vector.
Use these arguments to confirm that the created columns are the types that
you expect.
If not specified, the type of the columns generated from names_to will
be character, and the type of the variables generated from values_to
will be the common type of the input columns used to generate them. |
| names_transform |
A list of column name-function pairs.
Use these arguments if you need to change the type of specific columns.
For example, names_transform = list(week = as.integer) would convert
a character week variable to an integer. |
| names_repair |
What happens if the output has invalid column names?
The default, "check_unique" is to error if the columns are duplicated.
Use "minimal" to allow duplicates in the output, or "unique" to
de-duplicated by adding numeric suffixes. See vctrs::vec_as_names()
for more options. |
| values_to |
A string specifying the name of the column to create
from the data stored in cell values. If names_to is a character
containing the special .value sentinel, this value will be ignored,
and the name of the value column will be derived from part of the
existing column names. |
| values_drop_na |
If TRUE , will drop rows that contain only NA s
in the value_to column. This effectively converts explicit missing values
to implicit missing values, and should generally be used only when missing
values in data were created by its structure. |
| values_ptypes |
A list of column name-prototype pairs.
A prototype (or ptype for short) is a zero-length vector (like integer()
or numeric() ) that defines the type, class, and attributes of a vector.
Use these arguments to confirm that the created columns are the types that
you expect.
If not specified, the type of the columns generated from names_to will
be character, and the type of the variables generated from values_to
will be the common type of the input columns used to generate them. |
| values_transform |
A list of column name-function pairs.
Use these arguments if you need to change the type of specific columns.
For example, names_transform = list(week = as.integer) would convert
a character week variable to an integer. |
| ... |
Additional arguments passed on to methods. |
| .messages |
- a set of glue specs. The glue code can use any global variable, grouping variable, or .strata. Defaults to nothing. |
| .headline |
- a headline glue spec. The glue code can use any global variable, grouping variable, or .strata. Defaults to nothing. |
Value
the result of the pivot_wider but with a history graph.


Hello <%= @teacher.name %>,
Given the fact that <%= @student.name %> has already been accepted in another project his request for <%= @diploma.name %> have been canceled.
Have a great day,
Thesis Application Manager


pat-autosubmit demo
Some content will appear here if you change anything in the form below…
pat-autosubmit on form with default options
Take your pick
Item A
Item B
We like options
Cream
Syrup
Upload a file
Choose your flavour
Strawberry
Banana
Raspberry
Free text field triggers with default delay
Select a item
date picker with depending input
Start
End after start, automatically updated.
example with pat-clone and pat-sortable
x
Add clone item
pat-autosubmit on individual inputs with options
Text field triggers when field loses focus
Text field triggers with 3000 ms delay
Text area triggers with 3000 ms delay


|
DEMO: The playNoteSlide Method
|
The playNoteSlide method, offered as part of the Note Effects extension, provides a convenient way to generate musical note "slides", often referred to by musicians as glissandos. By customizing the rich set of parameters offered by this method, you can instantly and easily achieve a wide variety of complex sound textures and outrageous effects. Many of these effects will be ideal for the sonification of user interface elements, or even as sound effects for Web-based games implemented using DHTML or Flash (for more information on sonifying Flash movies using Beatnik, see the section Using Beatnik and Flash Together).
In this demo you will be able to preview some cool ready-made note slide examples, and then you can go on to tweak the parameters of the playNoteSlide method to achieve your own personalized note slide effects.
| Some Tasty Note Slides |
In the table below, each row contains a unique note slide effect. For each note slide effect, there is a descriptive name, a speaker icon to trigger the note slide to play, and a source code listing for the playNoteSlide method call that produces the effect.
Go ahead and take some note slides for a test drive. Be warned, though: you may want to step slowly through the note slides so you don't create too much of a note buildup and so that you can hear each individual note slide effect clearly, without too much of the tail of a previous note slide effect drowning things out.
Let the sliding begin...
| Tweak It! |
Now that you have seen what a couple of note slide effects look like when expressed in the syntax required by the playNoteSlide method, why not experiment with some settings of your own.
The interface below is designed to resemble a call to the playNoteSlide method and lets you edit all of the method's parameters. An entry box is provided for each of the method's parameters, with the exception of the MidiChannel1to16 parameter which has a fixed value of 1 in this interface. To the left of each parameter entry box is the name of the parameter and, wherever reference information is available for a parameter, the parameter name is linked to the reference information.
So, go ahead and tweak the parameters in the interface below. When you have a set of values that you like and you'd like to preview the note slide effect that would result from those settings, just hit the "Preview" button...
You can also "seed" the interface with values by returning to the previous Some Tasty Note Slides section and clicking on any of the buttons to play a note slide. When you scroll back down again to this section, then the parameters in the playNoteSlide Method Editor's interface will be seeded with the values needed to play the note slide you just played. You can then edit the parameters from there to derive new note slides from those listed in the previous section.
Don't be thrown off by the fact that each parameter is on its own new line. This layout was chosen so that it wouldn't be necessary to scroll horizontally all the time to edit different parameters. It is also perfectly acceptable in the JavaScript language to break up a method or function call over several lines, provided that you don't end a line on an unterminated string literal (ie. start a string parameter with an opening quote but don't close the string on the same line). For example, the following method call is perfectly valid in JavaScript...
myMusicObject.playNoteSlide ( 1, 1, 197, 20, 120, 127, 60, 1000, -1, 1000, 25 ); |
| Sliding in Stereo |
Now, let's take a look at some more intricate techniques using the playNoteSlide method. In all of the examples below, there are two note slide effects being played: one that is panned full left and one that is panned full right. By playing two panned note slides in this way, one can achieve some pretty radical spatialized effects.
In all of the source code listings for the examples, the calls to the playNoteSlide method have been highlighted. The other lines of code preceding the playNoteSlide method calls set up the MIDI channels 1 and 2 so that they are panned full left and full right, respectively, and so that there is no reverb send for the channels. Setting the reverb send level to 0 is important, since reverb would tend to "muddy" the effects and detract from the extreme stereo spatialization that is achieved by the effects.
In this example, the "Fairy Godmother" instrument (bank 1, program 108) is being used for both the left-panned note slide and the right-panned note slide. Both of the note slides play for the same duration, have the same starting and ending note velocities, and the same start and end note durations. In fact, the two note slides are identical but for one small detail: wherease the left-panned note slide starts from note pitch 50 and ascends to note pitch 80, the right-panned note slide starts from note pitch 80 and descends to note pitch 50. So, the note pitches for the two slides are going in the exact opposite directions, and crossing paths somewhere in the middle. This produces a pretty cool stereo pitch effect that resembles a Doppler effect.
/*** set channels' reverb send level to 0 ***/
myMusicObject.setController (1,91,0);
myMusicObject.setController (2,91,0);
/*** pan the channels full left and full right ***/
myMusicObject.setController (1,10,0);
myMusicObject.setController (2,10,127);
/*** play the two note slides ***/
myMusicObject.playNoteSlide (1,1,108,50,80,80,-1,1500,-1,1000);
myMusicObject.playNoteSlide (2,1,108,80,50,80,-1,1500,-1,1000);
|
In this example, the "50's Sci-Fi" instrument (bank 1, program 91) is being used for both the left-panned note slide and the right-panned note slide. Both of the note slides play for the same duration, have the same starting and ending note velocities, the same start and end note durations, and even the same ending note pitch. The only difference is that the two note slides start from different note pitches: wherease the left-panned note slide starts from note pitch 90 and descends to note pitch 70, the right-panned note slide starts from note pitch 50 and ascends to note pitch 70. So, the note pitches for the two slides move from opposite sides to end up in the middle, at note pitch 50. This produces a converging effect.
/*** set channels' reverb send level to 0 ***/
myMusicObject.setController (1,91,0);
myMusicObject.setController (2,91,0);
/*** pan the channels full left and full right ***/
myMusicObject.setController (1,10,0);
myMusicObject.setController (2,10,127);
/*** play the two note slides ***/
myMusicObject.playNoteSlide (1,1,91,90,70,50,100,500,2000,4000);
myMusicObject.playNoteSlide (2,1,91,50,70,50,100,500,2000,4000);
|
In this example, the "Soundtrack 2" instrument (bank 1, program 97) is being used for both the left-panned note slide and the right-panned note slide. Because the duration for each note slide is exactly the same and because no value is specified for the NoteIntervalMsINT parameter for each note slide (so the default value will be used), the notes for both note slides will be exactly synchronized to each other. And because the values for the StartNoteNumber0to127 and EndNoteNumber0to127 parameters for the right-panned note slide are exactly 7 greater than these parameters' values for the left-panned note slide, the two note slides will be perfectly harmonized by a musical 5th in the stereo field.
Finally, to add a stereo panning effect, the right-panned slide starts with a note velocity of 110 and ends with a note velocity of 10, whereas the left-panned note slide starts with a velocity of 10 and ends with a note velocity of 110. To further emphasize this panning effect, the right-panned note slide starts with a note duration of 1000 and ends with a note duration of 500, whereas the left-panned note slide starts with a note duration of 500 and ends with a note duration of 1000. The result of this is that the notes with a higher velocity also have a longer duration, making them appear even stronger.
/*** set channels' reverb send level to 0 ***/
myMusicObject.setController (1,91,0);
myMusicObject.setController (2,91,0);
/*** pan the channels full left and full right ***/
myMusicObject.setController (1,10,0);
myMusicObject.setController (2,10,127);
/*** play the two note slides ***/
myMusicObject.playNoteSlide (1,1,97,80,50,10,110,500,1000,3000);
myMusicObject.playNoteSlide (2,1,97,87,57,110,10,1000,500,3000);
|
In this example, all aspects of the left-panned and right-panned note slides are exactly the same, except for the instruments used for each. While the left-panned note slide is playing the "Bucket Hit" percussion sound (bank 1, program 197), the right-panned note slide is playing the "Thuddy Kick" percussion sound (bank 1, program 203). So, while the timing, pitch, velocity, and duration of every note is exactly the same for both note slides, the use of different instruments for left and right still creates a unique stereo effect.
/*** set channels' reverb send level to 0 ***/
myMusicObject.setController (1,91,0);
myMusicObject.setController (2,91,0);
/*** pan the channels full left and full right ***/
myMusicObject.setController (1,10,0);
myMusicObject.setController (2,10,127);
/*** play the two note slides ***/
myMusicObject.playNoteSlide (1,1,197,20,120,127,60,1000,-1,1000,25);
myMusicObject.playNoteSlide (2,1,203,20,120,127,60,1000,-1,1000,25);
|
In this example, a unique stereo "widening" effect is achieved. As you will notice, the parameter values for the left-panned and right-panned note slides are almost identical. The only subtle difference is in the values set for the SlideTimeMsINT and NoteIntervalMsINT parameters. Even despite these differences, both note slides play exactly the same number of notes: 41. While the left-panned note slide has a time of 1200 milliseconds, the note interval of 30 milliseconds yields exactly 41 notes to be played (as calculated by the expression
So, given that both note slides play exactly the same instrument and exactly the same number of exactly the same notes (same pitch, velocity, and duration), the only difference is in the timing. And because both note slides start out at the same time but have slightly different durations, the notes in each note slide will tend to drift further apart in timing towards the end of the note slides. This produces the stereo widening effect. What starts out sounding like a mono, center-panned note slide effect progressively spreads out to become much more stereo sounding.
/*** set channels' reverb send level to 0 ***/
myMusicObject.setController (1,91,0);
myMusicObject.setController (2,91,0);
/*** pan the channels full left and full right ***/
myMusicObject.setController (1,10,0);
myMusicObject.setController (2,10,127);
/*** play the two note slides ***/
myMusicObject.playNoteSlide (1,0,193,80,40,60,127,1000,-1,1200,30);
myMusicObject.playNoteSlide (2,0,193,80,40,60,127,1000,-1,1000,25);
|


Functions Coverage Report
| Functions | Covered Lines | Uncovered Lines | Ratio |
|---|---|---|---|
| Elixir.PcmSampler.__info__/1 | 0 | 4 | 0.0 |
| Elixir.PcmSampler.sample/2 | 0 | 5 | 0.0 |
| Elixir.SineWave.__info__/1 | 0 | 4 | 0.0 |
| Elixir.SineWave.__struct__/0 | 0 | 1 | 0.0 |
| Elixir.SineWave.value_at/2 | 0 | 2 | 0.0 |


This documentation is for Magento 1.x. For Magento 2.x, see here.
At the time of writing, Cloud Functions only supports three runtimes: Node.js 6, Node.js 8, and Python 3.7.
Example: Clean Visitor Logs
Requirements
- Active Google account
- GCP project with Cloud Functions API enabled
- Cloud SQL database instance
gcloud
command-line tool (Recommended)
Downloads
To use the Python runtime, two files are required: main.py
and requirements.txt
. You can download them here:
mkdir -pv visitor_log_clean && \
curl -fsL \
https://docs.auroraextensions.com/magento/extensions/1.x/magecroncloudfunctions/latest/python/src/visitor_log_clean/main.py
> ./visitor_log_clean/main.py && \
curl -fsL \
https://docs.auroraextensions.com/magento/extensions/1.x/magecroncloudfunctions/latest/python/src/visitor_log_clean/requirements.txt
> ./visitor_log_clean/requirements.txt
Objective
Clean the database of visitor log entries using Cloud Functions.
Steps
-
Create
visitor_log_clean
cloud functionThe following environment variables are required for Cloud Functions to access Cloud SQL:
DB_NAME
: The name of the Magento database.DB_USER
: The name of the database user.DB_PASS
: The database user's password.PROJECT_ID
: The Google Cloud Platform project ID.REGION_ID
: The region where the Cloud SQL instance exists (e.g. us-central1, us-east4).INSTANCE_NAME
: The name of Cloud SQL instance.
Using
gcloud
, run the following:gcloud functions deploy visitor_log_clean --entry-point="log_clean" \ --runtime=python37 \ --set-env-vars=DB_NAME=<YOUR_DB_NAME>,DB_USER=<YOUR_DB_USER>,DB_PASS=<YOUR_DB_PASS>,PROJECT_ID=<GCP_PROJECT_ID>,REGION_ID=<CLOUD_SQL_REGION_ID>,INSTANCE_NAME=<CLOUD_SQL_INSTANCE_NAME> \ --source="./visitor_log_clean" \ --trigger-http
Alternatively, you can use the Cloud Functions interface. Click Create Function from the list overview, and specify the following:
- Name: visitor_log_clean
- Memory: 256MB
- Trigger: HTTP
- Source code: Inline editor
- Runtime: Python 3.7
- main.py: Contents of
main.py
from above - requirements.txt: Contents of
requirements.txt
from above - Function to execute:
log_clean
Next, click More and set each of the environment variables listed above. Then click Create.
-
Add entry to
<crontab>
To make use of
visitor_log_clean
from within Magento, you will need to add the following to your moduleconfig.xml
file:<crontab> <jobs> <visitor_log_clean> <schedule> <cron_expr>30 2 * * *</cron_expr> </schedule> <run> <model>magecroncloudfunctions/observer::run</model> </run> </visitor_log_clean> </jobs> </crontab>
Alternatively, you can use Aoe_Scheduler to create and schedule cron jobs. It's a substantially nicer solution and it provides a ton of additional benefits.


Start VIDEO track
Log whole SDP messages
Force sendonly/recvonly in SDP
Start
Disable AUDIO track
Disable VIDEO track
Replace AUDIO track
Replace VIDEO track
Remove AUDIO track
Remove VIDEO track