Speech and debate, for me, is an extracurricular activity that my school (and many others) provide. Speech refers to non-debate events such as Dramatic and Humorous Interpretation, Prose and Poetry reading, Extemporaneous Speaking, Congress, and many others. Debate, on the other hand, involves a pair of teams arguing about a given topic. Which you choose to do (or if you choose to do both) pretty much just depends on personal preference, and personal interests.
Contention 2
How did I get started?
I got started last year. I was in a Public Speaking class at my high school, and ironically wasn't very spoken out in it. One of our earliest assignments was to do a 3-to-5-minute prose reading in front of the class. For this, I opted on an Edgar Allan Poe piece - specifically, The Tell-Tale Heart. I later learned that as far as speech and debate goes, that's a piece that's extremely overdone - but regardless, I went in and performed it, and discovered pretty quickly that it was actually something I was good at.
Contention 3
"Furthermore..."
Before long, I joined the actual Speech and Debate club at the school. At my first competition, I performed the same piece, still as a prose reading piece. However, in following competitions I performed it instead as a Dramatic Interpretation (which is slightly longer, and allows for more movement of your body, but also needs to be completely memorized), while choosing an additional piece to do as a Prose piece. I went on like this for several competitions, placing relatively well most of the time. And later on, I also began doing the Debate side of things with a partner. In the end, Speech and Debate was an extremely rewarding activity for me, and I'm happy I did it.


About
What is this?
Scheduling Gauntlet is a site for practicing process scheduling questions. Users are presented
with scheduling problems which can be solved for points. Users with the most points are displayed
on a global leaderboard.
Pog. Why?
For fun.
Scheduling Gauntlet was also initially created as tool to
generate personal practice problems for a course I was taking.
How does the game work?
You can join and compete against other users by signing up for an account.
Once logged in, you can get a new scheduling problem by pressing the "Challenge" button.
Solving the problem correctly will earn you 1 point.
There is no penalty for solving a problem incorrectly (blank answers
effectively skip the question).
How do I solve a scheduling problem?
A scheuling problem is comprised of two main parameters: the scheduling method and
the process arrival and execution times.
Scheduling Method
The scheduling method describes the strategy for determining which process gets to be executed
at given points in time. Below are a list of strategies that can be encountered in Scheduling Gauntlet:
-
First-come, first-served (FCFS):
Processes are executed in the order that they arrive. Processes enter a queue
on arrival. When an executing process finishes, the next process to be executed is the next process in
line in the queue.
-
Shortest job first (SJF):
Processes are executed based on shortest execution time. When an executing process finishes, the next
process to be executed is the process with the shortest execution time among the processes that have
already arrived.
-
Shortest remaining time first (SRTF):
Processes are executed based on shortest execution time left. When the executing process finishes or
another process arrives, the next process to be executed is the process with the shortest execution time
left among the arrived processes. This method has the potential to pause and resume process execution.
-
Round robin (RR):
Processes are executed and rotated based on a short period of time (quantum).
Processes are placed in a queue as they arrive. If the quantum for the currently executing process
expires
before the process finishes, that process is paused, moved to the back of queue, and the next process in
the queue
is picked up and started/resumed.
Process Times
Problems also specify a list of processes, each with an arrival and execution time. A scheduling problem
is successfully solved if the the correct finish and wait times for each process are submitted.
Below are brief descriptions for each type of time:
-
Arrival: The time at which a process arrives and is available to be executed.
-
Execution: The amount of time a process needs to execute before finishing.
-
Finish: The time at which a process finishes execution.
-
Wait: The amount of time a process spends not executing after arriving.
⚠ NOTE:
Sometimes problems generate with ties for which process should be executed next (ex. process arrives with
same remaining time as current executing process when using SRTF). Ties are broken in Scheduling Gauntlet by
giving precedence to processes with the lowest process number.
Do I get candy for making it onto the leaderboard?
No.


Deploying Octopress
Deploying with Rsync via SSH
Add your server configurations to the Rakefile
under Rsync deploy config. To deploy with Rsync, be sure your public key is listed in your server’s ~/.ssh/authorized_keys
file.
1 2 3 |
|
Now if you run
1 2 |
|
in your terminal, your public
directory will be synced to your server’s document root.
Deploying to Github Pages
To setup deployment, you’ll want to clone your target repository into the _deploy
directory in your Octopress project.
If you’re using Github user or organization pages, clone the repository git@github.com:username/username.github.com.git
.
With Github User/Organization pages
1 2 |
|
With Github Project pages (gh-pages)
1 2 |
|
The config_deploy
rake task takes a branch name as an argument and creates a new empty branch, and adds an initial commit.
This also sets deploy_default = "push"
in your _config.yml
and prepares your branch for easy deployment. The rake deploy
task copies the generated blog from the public
directory to the _deploy
directory, adds new files, removes old files, sets a commit message, and pushes to Github.
Github will queue your site for publishing (which usually occurs instantly or within minutes if it’s your first commit).
Now you should be set up to deploy, just run
1 2 |
|
Deploying to a Subdirectory (Github Project Pages does this)
If you’re deploying to a subdirectory on your site, or if you’re using Github’s project pages, make sure you set up your urls correctly in your configs. You can do this almost automatically:
1 2 3 4 |
|
Then update your _config.yml
and Rakefile
as follows:
1 2 3 4 5 |
|
To manually configure deployment to a subdirectory, you’ll change _config.yml
, config.rb
and Rakefile
.
Here’s an example for deploying the Octopress website to Github Project Pages:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
|


Antonios Boules
About
Experience
Education
Skills
Languages
Projects
Contacts
Antonios
Boules
Software Developer
Download CV
Experience
Information Technology Institute (ITI)
Front End Web Development
120 hrs
06 August 2017 - 13 September 2017
Military Technical College
Technical Support (IT help Desk)
01 December 2019 – 25 November 2020
Education
Egyptian E_Learning University (EELU)
Bachelor of Information Technology
GPA: 3.36
Graduation Project: -A
September 2015 - july 2019
Technical Skills
Java
90%
HTML5
95%
CSS3
70%
JavaScript
90%
Responsive Web & Bootstrap
85%
Angular
85%
Unity
80%
PhotoShop
20%
Android Developer
30%
Social Skills
Team Leader
The ability to learns new tools
Best Search for My Information Need
Can work under pressure
I have excellent communication skills , work in team, making good Presentation of my ideas, and work for long time with high efficiency
Languages
Arabic: Mother Tongue
English: Fluent
French: Little Bit
Projects
My Contacts
Cairo - Egypt
01010238245
<EMAIL_ADDRESS>+201010238245


Real talk - this is one of the hardest times our industry has seen. Unlike last time we shut down (prohibition) this time we're all on the same side.
Your support isn't just an amount of money, it's a commitment to a small business. So, like, we love you?!


The speech is so fast and ill-translated that it's impossible to understand. Ask it to say it again slowly.


12 instantiations of ObjectStream
System.Management.Automation (12)
engine\hostifaces\pipelinebase.cs (3)
40
InputStream = new
ObjectStream
();
41
OutputStream = new
ObjectStream
();
42
ErrorStream = new
ObjectStream
();
engine\hostifaces\PowerShell.cs (3)
2036
ObjectStreamBase inputStream = new
ObjectStream
();
4884
inputStream = new
ObjectStream
();
5069
inputStream = new
ObjectStream
();
engine\remoting\client\remotepipeline.cs (1)
92
MethodExecutorStream = new
ObjectStream
();
engine\remoting\commands\ConnectPSSession.cs (1)
1109
private readonly ObjectStream _stream = new
ObjectStream
();
engine\remoting\commands\DisconnectPSSession.cs (1)
560
private readonly ObjectStream _stream = new
ObjectStream
();
engine\remoting\commands\getrunspacecommand.cs (1)
543
private readonly ObjectStream _stream = new
ObjectStream
();
engine\remoting\commands\newrunspacecommand.cs (1)
1261
private readonly ObjectStream _stream = new
ObjectStream
();
engine\remoting\commands\PushRunspaceCommand.cs (1)
571
_stream = new
ObjectStream
();
16 references to ObjectStream
System.Management.Automation (16)
engine\remoting\client\ClientMethodExecutor.cs (1)
75
ObjectStream
methodExecutorStream,
engine\remoting\client\Job.cs (2)
3128
ObjectStream
hostCallsStream = sender as
ObjectStream
;
engine\remoting\client\remotepipeline.cs (1)
1033
internal
ObjectStream
MethodExecutorStream { get; }
engine\remoting\commands\ConnectPSSession.cs (3)
494
private readonly
ObjectStream
_writeStream;
502
ObjectStream
stream,
1109
private readonly
ObjectStream
_stream = new ObjectStream();
engine\remoting\commands\DisconnectPSSession.cs (3)
398
private readonly
ObjectStream
_writeStream;
400
internal DisconnectRunspaceOperation(PSSession session,
ObjectStream
stream)
560
private readonly
ObjectStream
_stream = new ObjectStream();
engine\remoting\commands\getrunspacecommand.cs (1)
543
private readonly
ObjectStream
_stream = new ObjectStream();
engine\remoting\commands\newrunspacecommand.cs (1)
1261
private readonly
ObjectStream
_stream = new ObjectStream();
engine\remoting\commands\PSRemotingCmdlet.cs (1)
3892
ObjectStream
stream, RunspaceRepository runspaceRepository,
engine\remoting\commands\PushRunspaceCommand.cs (1)
44
private
ObjectStream
_stream;
utils\ObjectReader.cs (2)
243
public ObjectReader([In, Out]
ObjectStream
stream)
353
public PSObjectReader([In, Out]
ObjectStream
stream)


--- layout: default nav: attributes > ic-always-update ---
ic-always-update
- The Always Update AttributeBy setting ic-always-update
attribute to "false", the element will not be swapped
if the current content is identical to the downloaded content.
This can be useful if you want to avoid the visual clutter of swapping content when no data has changed.
The value of this attribute can be either true
or false
This attribute may be placed on parent elements, allowing you to specify behavior across multiple elements.
No effect.


EPISODE I
INVASION OF THE DALEKS
The Daleks are invading. Doctor Who must stop them.
You are The Doctor. You must trick the Daleks into colliding with each other and exploding into lethal piles of rubble.  Lure the Daleks next to you and destroy them with your Screw Driver, but be careful, you can use it only once per level.

Good luck, Doctor...


What Is HOW-TO?
How-To is an app that puts the power into your hands. Tired of switching from one app to another trying to find the perfect tutorial? You can now find, all of your tutorials on one single app! We've made it easy and simple to find the perfect video, or article to help you with all your curious needs.
Problem Solved!
Now with just one app, you can, record and upload videos of tutorials. You also have the power to directly message Video producers, to lower risk when trying something for the first time.
Our mission is to, help people all across the world accomplish something new, everyday! We are all given one life, the things you try today, could be your favorite tomorrow. We are pushing comfort zones for the best!


The Gallery module manages multiple media formats. Media files can be categorized into albums and displayed in different views including a slideshow. The Gallery module can be added to a page and registered users can being adding media to the default album without any configuration.
Installation Note: This module must be deployed and installed on your site by a SuperUser.
Module Version: 04.04.00 / Minimum DNN Version: 05.06.02
The Gallery Module


PortaPlanter™ makes products that help you have healthier, more manageable, and more environmentally beneficial plants and planters. Our products enable you to use less water, energy, and effort than any of the alternatives, and they can decorate an office, house, or yard.
Our systems span from cozy and decorative 20 gallon models to full-sized (but still portable and beautiful) 240 gallon systems. See below for some of our models, and please contact us if you want to find out more
Our 10 and 20 Gallon containers are just 12 inches deep and at most 24 inches wide. They are perfect for accenting indoor spaces. Each can be planted in directly or divided by two to four removable planters.
Our 40 and 50 gallon containers are "panoramic" with a base 12 inches by 30 inches. They are great for decorating larger indoor spaces, can have a custom front panel design, and can be divided by three or four removable planters.
Our 80, 120, and 240 gallon containers are designed for outside decoration, garden, greenhouse, and commercial spaces. They range from two feet by three feet to a full four feet by four feet size, and all have a large front panel that can be artisticly designed. Planter sets divide the large space into approximately one foot 'cubes' for easy management of the plants. All containers 80 gallon and larger come with an optional pallet for support and movement, even when the lower water section (about 20 gallons for the 80 gallon container) is full.
These larger containers can transform dead spaces like driveways, walkways, and roofs into green beltways.
PortaPlanter™ products are being used in the San Francisco Bay Area from Palo Alto up through Daly City. Below are some pictures.
This 120 Gallon PortaPlanter™ is planted by 'V' in her semi-urban farm on what would otherwise be a dead zone (a driveway). For fun it has a mirror-box that reflects on the front, and the owner built out her own trellis system for it. It is planted with herbs (Oregano, Basil, Thyme, etc.), sweet peas, and Kale.
This 120 Gallon PortaPlanter™ sits in a dead zone of an Elementary School right next to the Kindergarten and First grade classrooms, so the kids can see the watering system run every couple hours (a minute at a time), and pick the peppers themselves to understand how plants grow and fruit. Besides peppers, it also contains many different types of herbs and some decorative flowers and ferns. There is no power nearby, so it runs with a Yeti 150 from GoalZero.
Pictured below is PortaPlanter™ 'Prototype-2', the second 120 gallon prototype which is planted directly in the container vs. having planters. At the time of the picture it was growing lettuces and peppers. Currently it is growing kale and carrots along with the peppers.
PortaPlanter™ was founded by Mark when he tried to tried to transform his wife's and daughter's backyard garden into a mobile and efficient mini-farm. By studying nature and farms, and after working through months of failures, Mark and his team invented the patent-pending FireHorse basin system. This enabled unprecedented productivity and efficiency: the systems use almost no energy (pennies a day) and they have almost no water loss. The basins can be "topped off" every week or even longer depending on the tank size. And the systems run perfectly on a small, portable or permanent, solar system like those from Goal Zero.

PortaPlanter™ has a small, talented, team of farming and gardening advisors, system designers, and builders located in Palo Alto, California. The following are some of the people who make PortaPlanter possible.
We have a great set of advisors who are helping guide the company to a great product and ultimate success.
Please give us a call or email if you are interested in finding out more.


{%extends 'base.html'%} {%block content%} {% load bootstrap3 %} {% load staticfiles%}
{{hood.name}}
location: {{hood.location}}
admin: {{hood.admin}}


MZ Mars Rovers
This project is my JavaScript implementation of the Mars Rovers coding challenge for Nando's, using Node.js as the engine behind it. You can check the documentation here: https://michaelzap94.github.io/mz_mars_rovers/
This is the Description of the Problem:
...
A squad of robotic rovers is to be landed by NASA on a plateau on Mars. This plateau, which is curiously rectangular, must be navigated by the rovers so that their on board cameras can get a complete view of the surrounding terrain to send back to Earth. A rover's position is represented by a combination of an x and y co-ordinates and a letter representing one of the four cardinal compass points. The plateau is divided up into a grid to simplify navigation. An example position might be 0, 0, N, which means the rover is in the bottom left corner and facing North. In order to control a rover, NASA sends a simple string of letters. The possible letters are 'L', 'R' and 'M'. 'L' and 'R' makes the rover spin 90 degrees left or right respectively, without moving from its current spot. 'M' means move forward one grid point, and maintain the same heading. Assume that the square directly North from (x, y) is (x, y+1)
Input:
- The first line of input is the upper-right coordinates of the plateau, the lower-left coordinates are assumed to be 0,0.
- The rest of the input is information pertaining to the rovers that have been deployed. Each rover has two lines of input. The first line gives the rover's position, and the second line is a series of instructions telling the rover how to explore the plateau.
- The position is made up of two integers and a letter separated by spaces, corresponding to the x and y co-ordinates and the rover's orientation.
- Each rover will be finished sequentially, which means that the second rover won't start to move until the first one has finished moving.
Output:
- The output for each rover should be its final co-ordinates and heading
Sample:
Test Input:
"5 5"
"1 2 N"
"LMLMLMLMM"
"3 3 E"
"MMRMMRMRRM"
Expected Output:
"1 3 N"
"5 1 E"
...
Design:
I created 1 file holding all the constant variables. I also created the following 4 classes:
- Plateau: Represents a Plateau where multiple Rovers can move around.
- Rover: Represents a Rover that will be able to move around the Plateau.
- Controller: Represents a Controller that will be able to create the Plateau, Rovers, and execute instructions. It extends the ControllerHelper.
- ControllerHelper: Represents a ControllerHelper that will contain the necessary methods and data for the Controller to create the Plateau, Rovers, and execute instructions.
Challenges faced:
The instructions were pretty clear on the expected output when everything goes well. However, they did not indicate how we should tackle the following two scenarios:
- The Rover may be at the end of the grid where a move is no longer possible.
- The Rover may be about to collide with another Rover.
Since there were no clear indications on how to approach these issues. I decided to implement my own logic here:
- Rover should ignore the current command 'M' if a move is not possible, and therefore, just log that a collision could happen when trying to move in some direction.
Technologies used:
MZ Mars Rovers uses several open-source projects to work properly:
- ES6 - JavaScript programming language including new features.
- node.js - Evented I/O framework for the backend.
- mocha - Mocha is a feature-rich JavaScript test framework running on Node.js.
- JSDocs - Generates an HTML documentation website using your comments.
And of course MZ Mars Rovers itself is open source with a public repository on GitHub.
Installation
First, you should clone this repository:
$ git clone https://github.com/michaelzap94/mz_mars_rovers.git
$ cd mz_mars_rovers
MZ Mars Rovers requires Node.js v12+ to run. Once you have installed Node.js, Install the dependencies and devDependencies and run the tests.
$ npm install -d
$ npm test
The tests will give you a broader understanding of how this software was implemented.
Alternatively, you can also run a quick test, that will execute the code by providing the instructions in one go. You will see the results in the terminal. (This test is also included in the test cases, using more instructions).
$ npm start
Todos
- Create a user interface
License
MIT
Free Software


Dunbar, "Neocortex size as a constraint on group size in primates", 1992.
Dunbar's number is a suggested cognitive limit to the number of people with whom one can maintain stable social relationships-relationships in which an individual knows who each person is and how each person relates to every other person. This number was first proposed in the 1990s by British anthropologist Robin Dunbar, who found a correlation between primate brain size and average social group size. By using the average human brain size and extrapolating from the results of primates, he proposed that humans can comfortably maintain only 150 stable relationships.


Enter Password
Ok Cancel
Service adapter requires you have implemented the service endpoints specified the service adapter implementation.
Custom user adapters allow you to add your own adapters. This tab can be used to test the adapter, but for the adapter to be seamless you will need to use an autorun script to create and switch this at environment load time.


The times specified are in military time. 01-02 indicates 1am to 2am, 12-13 indicates 12pm to 1pm, etc. Therefore select your time based on this criteria to see the map visualized by the hour.
The times specified are in military time. 01-02 indicates 1am to 2am, 12-13 indicates 12pm to 1pm, etc. Therefore select your time based on this criteria to see the map visualized by the hour.


Apple Releases AirPods Pro Firmware Update
by Bryan ChaffinApple pushed a firmware update for AirPods Pro on Thursday. It’s unclear what the firmware update does, and the update process is automatic. But, users are reporting their firmware version number went from 2B584 to 2B588. AirPods Pro were released on October 20th.
As noted, the update process is automatic, meaning you have little control over it. These are the steps you can take to check on your AirPods Pro firmware version.
Open the Settings app of your iPhone or iPad (iPod touch works, too). Go to General > About. Open your AirPods Pro case. When you do so, you’ll see a tab appear for your AirPods Pro. Tap that tab and look for your Firmware Version.
The old firmware version number is 2B584. Once it updates, it will be 2B588. I haven’t figured out a way to force the update,


To start your first Grow project, the easiest thing to do is to use the grow init
command. This command fetches a theme (which is like a scaffold) and clones it to your computer, ready for you to develop upon. Themes are Git repositories. They are just Grow projects with some special theme-related data.
But wait! You mentioned that Grow is all about configuration, not code, and now we're downloading scaffolding? Grow's default themes are primarily configuration scaffolds. When you run grow init
, Grow creates a set of all the basic required config files. Pods require you to implement absolutely zero business logic code; Grow uses the config files to determine your web site's entire architecture.
Run the following command:
# Clones the "codelab" default theme to a directory "my-codelab" in the current directory. $ grow init codelab ./my-codelab/ $ cd my-codelab/
You'll now have the "codelab" theme on your computer, ready to use with Grow. To understand what we mean by "configuration, not code," let's take a look at the structure of a Grow project.
Install dependencies
When first starting work with a grow site it is a good practice to run the install command to install and setup any dependencies for the project.
# Installs any dependencies such as node packages and extensions.
$ grow install
Pod structure
Grow projects (which we call pods) contain everything that Grow needs to build your site: content, structure, translations, static files, templates, etc. Again, you won't have to write any code to determine how your site is served or its architecture – configs take care of that for you. Because of this concept, if you need to change URLs later, or add or remove localizations (for example), it's simply a matter of changing the configs within your pod.
Let's now take a look at the structure of a pod. This is the "codelab" pod that was cloned to your computer.
/content/ # Content collections, blueprints, and documents. /source/ # Source files for asset/media/JS/CSS generation. /translations/ # Content and UI string translations. /views/ # Frontend templates. /podspec.yaml # Pod specification file.


Brazil's Lula calls for Saturday rally, national tour
CURITIBA, Brazil (Reuters) - Brazil’s former president Luiz Inacio Lula da Silva plans to hold a gathering of supporters at a metal workers union in greater Sao Paulo on Saturday before embarking on a national tour, he told a crowd after leaving prison on Friday.


Swimming into a hungry belly near you, come try Pat's Salmon Cookies!
Come to one of our five locations to try the finest pescatarian confections you ever wide-mouthed.
One bite of Pat's Salmon Cookies and you'll be hooked, line and sinker!
| 1st and Pike | SeaTac Airport | Seattle Center | Capitol Hill | Alki |
|---|---|---|---|---|
| 102 Pike St | 17801 International Blvd, Concourse C | 305 Harrison St | 140 Broadway E | 1702 Alki Ave SW |
| Seattle, WA 98101 | Seattle, WA 98158 | Seattle, WA 98109 | Seattle, WA 98102 | Seattle, WA 98116 |


Ever felt the need to have someone to talk to when you feel depressed but unable to reach out to anyone? WeCounsel provides a safe space to connect you to online therapists of your choice as well as your fellow peers.
Online therapy provides one with a strong sense of anonimity hence they feel they are in a much safe place to share there deep dark secrets that trouble them. Online therapy also gives those who live in remote areas a chance to contact a counsellor.
Here at WeCounsel you can choose to either become a peer listener or register as a professional therapist
Click here to join our community Already have an account? Click here to sign in
Get exposed to people from different backgrounds who are all on the same journey to mental freedom as you by engaging in our group discussion forum.


Ewan Clayton is a calligrapher and Professor in Design at the University of Sunderland, he is also a visiting calligraphy tutor on the type programmes at the University of Reading and Cooper Union in New York City. He is a core staff member at The Royal Drawing School in London. Lettering is in his blood. He grew up near the village of Ditchling in the UK, home to Edward Johnston and three generations of his family worked there in a guild of crafts people founded by Eric Gill.
Ewan’s interest in the written word ranges widely. He worked for 12 years as a consultant to Xerox PARC, researching the future of writing in the workplace.
His book on the history of writing with the Roman alphabet The Golden Thread was published in 2013 and has been translated into a number of languages, including Italian.
His real love is articulating the role the entire body plays in writing whatever the medium; he is a qualified somatic coach and body-worker.
Fluent styles of movement characterize good letterforms, they extend our creativity and encourage the emergence of personal expression.
In this workshop, suitable for designers of all levels, we will experiment, in a structured way (following in the footsteps of Rudolf Laban), with different movement styles.
{% if page.short %} {% else %}This workshop can work for the relative beginner in calligraphy and for the very experienced. Just as singers exercise their voices to expand their range of notes and tones so we will exercise our pens on the paper. Letters and marks that push, float, glide, flutter. Working initially with abstract pattern and lines we apply these movements to different styles of letterforms, overcoming limited and habitual patterns of movement in the process. You will emerge from this class with a new confidence in your own ability to write and to create personal styles of calligraphy - and with the work to prove it.
A "Drawing Kit" will be provided. The kit will include a Parallel stroke pen, ink refill, drawing sheets, pencils, thin marker, glue.
{% endif %}


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/keep.20a.20changelog.html ---
I just discovered Keep a Changlog, which reminded me of our previous discussions on mathlib releases.
Mathlib is an ongoing project without releases. You probably don't want a changelog for every commit. I think Mario once suggested that one could perhaps "pretend" that there's a release on the first of every month. Perhaps the community spending 5 minutes discussing what major things happened in the last month or so would be a good idea! For example I believe that this month we got polynomials in one variable.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Mackenzie Craig
software developer
Hiking, running, writing code, and studying Computer Science in Vancouver, Canada.
home
Archive
Categories
feed
Home
Hello World!
26 FEB 2017
•
1 min read
First ever post on my new website. Let’s see how this goes!
Share on:
Twitter
Facebook
Google+
Hacker News
Reddit


Generator iterators are created by the yield keyword. The real difference between them and ordinary functions is that yield unlike return is both exit and entry point for the function’s body. That means, after each yield call not only the generator returns something but also remembers its state. Calling the next() method brings control back to the generator starting after the last executed yield statement. Each yield statement is executed only once, in the order it appears in the code. After all the yield statements have been executed iteration ends.
Since generators support iterator protocol, they can be used in for loops.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 1
Preheat the oven to 200C/400F/Gas 6.
To make the blue cheese scones, place the flour, baking powder and butter into a food processor and blend.
Add the cheese, egg and milk and blend again, until the mixture is just coming together.
Bring the dough together with floured hands and roll onto a floured surface to 1cm/½in thickness.
Using a 5cm/2in chefs' ring, cut five rounds out of the pastry, then brush them with milk.
Place the rounds onto a baking sheet and place into the oven to bake for 15 minutes, or until risen and golden.
To make the pea soup, heat the olive oil in a saucepan over a medium heat. Add the garlic and shallot and fry for two minutes to soften.
Add the peas and cook for five minutes.
Add the stock and blue cheese, bring to the boil, then reduce the heat to simmer for 10 minutes.
Season, to taste, with salt and freshly ground black pepper, then blend with a hand blender until smooth.
To serve, pour into a large cappuccino cup or small bowl and place onto a large plate with the scones piled alongside.


Overview¶
Low level, pure Python D-Bus implementation for message bus clients.
Installation¶
# pip install dcar
Requirements¶
Python >= 3.7
Links¶
History¶
- 2020-08-08 (0.3.0)
Add property bus_type to class Bus
Add modules remote and introspection
Bugfix: UnknownMethod and InvalidArgs errors for incoming method calls are now handled
- 2020-08-02 (0.2.0)
Add parameter timeout to Bus.block()
Add field is_signal to class MessageInfo
The handler functions for incoming method calls and signals are not executed in the same thread as the recv-loop any more but in a separate thread sequentially
- 2019-06-03 (0.1.0)
First public release


--- layout: post title: bookkake in the kitchen the giant egg date: '2009-02-07T13:43:00+00:00' tags: [] tumblr_url: http://backlog.robbevan.com/post/76389834/bookkake-in-the-kitchen-the-giant-egg ---
Bookkake in the Kitchen: The Giant Egg


Business Intelligence Tools
SQL Server Integration Services (SSIS)
SQL Server Reporting Services (SSRS)
Web Applications
Agile Methodologies
Database Design
Microsoft SQL Server
SQL
T-SQL
SharePoint
CSS
HTML
ASP.NET
MS SQL Server
Visual Studio
JavaScript
jQuery
Oracle
Information Systems Development
Application Development


This application offers the graphical display of Ensembl Variant Effect Predictor output, on a per protein basis. It is aimed to be a demo for pViz.js (a dynamic JavaScript & SVG library for visualization of protein sequence features).
Upload your own .vep output file in the header bar or select on of our test cases as a starter, enter an ENSP protein Id and browse the results. Zoom in the sequence by dragging the mouse and zoom out with a double click.
Feel free to download or fork the code on github or build your own application on application based on pViz.js.
To work, this application needs a modern browser such as recent chrome, safari, or firefox.


Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galleyLorem Ipsum is simply dummy text of the printin


|
TSGL
A thread-safe graphics library
|
Draws a Nova (Newton Fractal) set on a CartesianCanvas. More...
#include <Nova.h>
Public Member Functions | |
| Nova (unsigned threads, unsigned depth) | |
| Explicitly constructs a Nova set. More... | |
| void | draw (Cart &can) |
| Draw the Nova set. More... | |
| Public Member Functions inherited from Mandelbrot | |
| Mandelbrot (unsigned threads, unsigned depth) | |
| Explicitly construct a Mandelbrot object. More... | |
| virtual | ~Mandelbrot () |
| Destroys a Mandelbrot object and any children of the Mandelbrot class. More... | |
| void | bindings (Cart &can) |
| Binds buttons and/or mouse clicks. More... | |
Additional Inherited Members | |
| Protected Member Functions inherited from Mandelbrot | |
| void | manhattanShading (CartesianCanvas &can) |
| Shades the fractal using Manhattan distances. More... | |
| Protected Attributes inherited from Mandelbrot | |
| int | myThreads |
| unsigned int | myDepth |
| bool | myRedraw |
Draws a Nova (Newton Fractal) set on a CartesianCanvas.
Extends the Mandelbrot class and overrides its draw() function and setRedraw() function.
Can zoom in and out of the Nova set by scrolling up and down on the mouse wheel (respectively).
| Nova::Nova | ( | unsigned | threads, |
| unsigned | depth | ||
| ) |
|
virtual |
Draw the Nova set.
Actually draws the Nova set onto the CartesianCanvas.
| can | Reference to the CartesianCanvas to draw to. |
Reimplemented from Mandelbrot.


Reducing tabs, windows, and clutter to one, easy to use website. Search or browse for current events or scholarly journals and take notes as your reading.
Or sign up here


CHAPTER FOUR
SOFTWARE DESIGN, ANALYSIS AND EVALUATION
In this chapter we represent a computer implementation system called Facility Layout Design and Evaluation (FlayDE), which is developed to enable the user solve the equal-area FLP, using the traditional layout methodology described in chapter three. The fully coded version of the algorithm is available upon request. The system also produces an effectiveness value of the displayed layout. The system was designed and built with JAVA Script.
The system is Object Oriented; its functionality is based on the object structure, which consists of main functional objects accompanied by useful supporting objects. The system is events-driven: the objects mostly communicate among themselves as well as the Graphical User Interface GUI elements (user control); thus by raising and watching for certain events. Objects and their structure are explained in detail in section 4.5.
User can communicate with the system through a GUI. It is a multi-window interface consisting of three main windows and one supporting window. These windows have their own functional purpose and elements. Most of the elements are user controls: controls designed to fit the exact problem or deliver the exact functionality. That enhances the usability of the GUI, and accompanied with appliance of error management using error handling routines, makes the system more stable and robust. The GUI is explained in detail in Chapter 4.6.
This application is an on-line integrated in the system, this makes the application accessible “on the move” it can be easily accessed anywhere with computers and mobile devices. This app can provide useful information to the user about the system and how to use it. Alongside this, there is also a table of codes and there corresponding values imbedded in the system to aid the conversion of relationship codes to their values to derive an result.
4.1 SOFTWARE AND HARDWARE REQUIREMENT
In order to run and use FlayDE, certain minimum requirements of hardware, software and memory must be met. These requirements are listed below:
Hardware
FlayDE requires the following hardware:
IBM PC compatible with Pentium class processor or later model
Hard disk drive with a minimum of 120Mb of free space, and
At least 32Mb of RAM memory
Software
FlayDE requires the following software:
MS Windows 98/2000 SP4/CE/Millennium Edition/Server 2000/XP Mediacentre Edition/XP Professional x64 Edition/XP SP2 or later operating system.
.NET Framework 2.0 or later.
4.2 INSTALLING FlayDE
The FlayDE is an online application along with other supporting application and documentation. The following steps describe how to install FlayDE on any windows Operating System which meets the minimum software and hardware requirement:
Internet connection
Enter the FlayDe URL
Once the site opens, enter username and password
The home page opens on the GUI and the user can start the optimization processes.
4.3 DATA ORGANIZATION AND MANAGEMENT
Data is organized in three groups: definition data, relationships data and result data.
The definition and relationships data for each layout problem are stored in one plain text file. The first part of the file contains general data of the problem such as name, source and some comments attributable to the facility. It also holds data such as the number of departments to be contained in the facility. The second part contains data of the department. This data includes the name, color coding, and area of the departments.
The third part of the file holds the departmental flow information of the facility.
The fourth part of the file is created when the layout is executed. It represents the result data which consist of the optimization data and layout summary data. The optimization data is made up of the nodal diagram, plant layout diagram, and cost effectiveness of the optimized layout that was produced.
FlayDE manages these categories of data separately so that small changes in one category do not affect the others, ones the user logs in; every work done by the user is saved on his profile. This allows the testing of several layout configurations without having to input all the information each time. Users enter this information directly into the system using textboxes, which also applies for inputs in the subsystem - each one dedicated to a specific category and for as long the user uses the application, past works can be recalled and readjusted if need be to suit a new work or creating a new work if need be.
4.4 IMPLEMENTATION OF THE ALGORITHM
The layout algorithm described in Chapter Four of this report is implemented in a single class (JAVA Script) called ClassMain. This class implements the algorithm using a number of functions which are designed to return precise information in specific object types.
The system uses the algorithm implementation class by calling two class procedures (subroutine), which acts as the class entry points. The parameter passed is a reference to the problem object, where the results are stored and returned to the system.
Classes are an important part of objected-oriented programming because they allow you to group related items as a unit, as well as control their visibility and accessibility to other procedures. Classes can also inherit and reuse code defined in other classes.
The advantage of the class implementation lies in the possibility of using the DLL (Dynamic Link Library) technology. With a little system redesign the implementation can be advanced upon and compiled into DLL. This would enable testing, analyzing, and using advanced implementations without needing to apply any changes to the FlayDE system.
4.5 OBJECT STRUCTURE
MAIN OBJECTS
A group of main objects are used to handle the facility layout problem, from problem definition to the results given by the system. Classes representing those objects are: frmLayD, frmRelationships, frmOptimization, and diaNameDepartments.
The frmLayD class is a parent class for frmRelationships and frmOptimization classes, and represents a single problem on a higher level. It consists of methods that support operations like creating new problem object structure and its initiation methods for working with reading and writing data from files as well as methods that cause different ways of displaying a problem. The class through its properties holds information about a problem object structure, by maintaining references to child object structure, by maintaining references to child objects, and links to user interface, by maintaining references to user controls that handle different ways of displaying a problem data. Its methods also support operations like reading and writing data to file as well definition data editing with data validation.
The frmRelationships class is a child of the frmLayD class. It handles departmental flow data in details. Its methods support an operation that displays the objects available to users for input only as required, and controls the labeling of the facility layout. This class is very dynamic and contains error handling procedures.
The frmOptimization class is also a child of the frmLayD class. It has two instances, for each type of layout display produced by the algorithm. It handles problem result data in detail through methods that support different display operations for the resulting part data.
The diaNameDepartments is a supporting class of frmLayD class. It handles departments name and color data through methods that support read/write operations as well as different display operations for the output as well as the user interface.
4.6 USER INTERFACE
The FlayDE User Interface is a Multi-Document Interface using an MDI Form (the Main Window) as a container for two functional windows: the Relationships Window and the Optimization Window, as can be seen in figure 4.2.
All the features, mentioned in the following text, are explained in detail in the FlayDE on-line help file.
Fig 4.1: SIGN IN TASK BAR
Fig 4.2: FLayDE
4.6.1 THE MAIN WINDOW
The purpose of the main window is to help the user work with a single problem and its details more easily.
The Main Window consists, as shown in Figure 4.2, five main elements: the main menu, two panels, and two child windows.
Fig 4.3: FlayDE Main Window
The main menu helps execute tasks, such as saving and printing problems, and executing, profile name and resetting the various child display style. It also contains the help menu and a means for exiting the program.
The problem general variables area is located immediately under the Main Menu. It consists of six general variables, defining the FLP: the name of facility, two comment variables (the source of the problem and a general comment the user can give to the problem), area of the departments, number of departments, and a link to a dialog where the name of the departments (see Figure 4.4) as well as a user chosen color. The color selection is made possible by the color dialog provided for each department (see Figure 4.4).
Fig 4.4: Name Departments Dialog
4.6.2 THE RELATIONSHIP WINDOW
The Relationships Window is a highly dynamic child window in the MDI system of FlayDE. It consists of three (beside a standard window bar with the name of currently opened problem) elements and controls: the Chart, the Conversion Aid, and the Show Department Name Checkbox. (Figure 4.5)
Fig 4.5: Relationships Window
The Chart (as in Figure 4.5) is the major element of the Relationships Window. It provides a 2-Dimensional array of textboxes where users can input departmental relationships for up to twenty departments. This array can be reduced, based on users’ input of the number of departments that is required for the FLP, thus providing a dynamic chart system. The chart only accepts values of relationships and not the code, and it has an error handling system to ensure users input valid values. Based on this error handling system, each time a textbox loses focus, the system checks that the variable entered IsNumeric and falls within the range of values (i.e. between 4 and -1), and is not a letter or IsNothing (i.e. empty). If the validation process returns correct, users can proceed to the next textbox, else the textbox would refuse to lose focus. The validation process serves to check for system crashes.
The Conversion Aid has no system functionality except to aid the user in the conversion of the Rel-Chart to the Value Chart. It is a repetition of that shown in Table 3.1.
The decision to show the name of the department in the layout or just a reference number corresponding to the department is made by the class ClassMain each time the “Optimize” button is clicked. It uses the “Show Department Name” checkbox immediately above the Optimize button. The ClassMain evaluates if the Show Department Name checkbox is checked. If it is, the name of departments entered in the Name Departments Window is displayed in there corresponding modules, else the reference numbers are used.
4.6.3 THE OPTIMIZATION WINDOW
The Optimization Window serves as an output element which displays the layout as well as has some visual-aid functionality.
It consists of three elements and control: the Nodal Diagram, the Plant Layout, and some visual-aid buttons. Figure 4.6
OPTIMIZATION
NODAL
Fig 4.6: Optimization Window
The Nodal Diagram and the Plant Layout elements are contained in the TabOptimization TabControl (TabControls are explained in section 4.6.4). The Nodal Diagram displays (as the name implies) the nodal diagram of the layout while the Plant Layout displays the Plant layout of the FLP. These displays combine to give the user an elaborate idea of the position of the various departments in the facility.
On the right corner of the Optimization Window consist of three buttons which constitute the visual-aid. The “ZOOM+” button enlarges the display of the TabControl that has focus 25 percent on each click. The “ZOOM-”button reduces the display on the TabControl that has focus 25 percent on each click. The “RESTORE” button, as the name implies, restores the display to its original dimension.
4.7 ClassMain
The ClassMain is the main class, and is responsible for the implementation of the algorithm described in Chapter Three.
It exposes a number of methods, namely “DepartmentalScripts”, “DepartmentalSequence, “DepartmentColor”, “HorDepartmentalRelationships”, “Points”, “RelationshipSorts”, “VetDepartmentalRelationships”, “Main”, and “NodalMain”. These methods combine to make the last two functional and would be described in the preceding texts. The Main and NodalMain methods are the entry point of the ClassMain.
4.7.1. DepartmentalScripts()
The DepartmentalScripts is a Function that if passed the department’s reference number (using the calling code) would return the Name of department. Details of these are contained in the fully coded version of the algorithm which is available upon request.
4.7.2. DepartmentalSequence()
The DepartmentalSequence is a Function that accepts the sequence of entry number or element (using the calling code) takes the sum of the horizontal relationships as well as the vertical relationships (as in the chart in the Relationships Window) to get a total sum for each department. The departments are then sorted according to the total sum, in descending order, and inserted into an array. Whenever DepartmentalSequence is called it returns the department sequentially, as they are in the array. Details of these are contained in the fully coded version of the algorithm which is available upon request.
4.7.3. DepartmentColor()
The DepartmentColor is a Function that if passed the department’s reference number (using the calling code) would return the color of department as inputted by the user in the “Name Departments” Window.
4.7.4. HorDepartmentalRelationships()
This is a Function that returns all the departments having the required horizontal relationship (4, 3, 2, and 1) with the specified department. It takes in the specified department as well as the required relationship as parameters in other to achieve its functionality.
4.7.5. Points()
The Points is a Function that returns an array of points holding the coordinates of the candidacy location of the next departments to be placed. It accepts the coordinates of the placed departments when it is called. It is this Function that affects the shape of the facility displayed in the Optimization window.
4.7.6. VetDepartmentalRelationships()
This is a Function that returns all the departments having the required vertical relationship (4, 3, 2, and 1) with the specified department. It takes in the specified department as well as the required relationship as parameters in other to achieve its functionality.
4.7.7. RelationshipSorts()
This Function is similar to the HorDepartmentalRelationships and the VetDepartmentalRelationships Functions described in section 4.7.6 and 4.7.4 respectively. The difference being that the RelationshipSorts checks for both vertical and horizontal relationships in on call. It first checks for horizontal relationship of 4, if it does not find any, then it checks for vertical relationship of 4. If it does not find any, it checks for 3 relationships, if it does not find any -it continues until it finds- to relationship -1. After carrying out the above process and finding any horizontal or vertical relationships at some stage, it returns an array holding all the departments with this relationship.
4.7.8. Main()
The “Main” is a very important procedure (subroutine) since it is the entry point to the class ClassMain which implements the algorithm described in Chapter Three. It also links all the Functions described above, to carry out its own functionality. The flow chart of the algorithm is shown in Figure 4.6.
The procedure starts by trying to place the first department in the centre of the Plant Layout. It does this by calling the DepartmentalSequence Function (described in section 4.7.2, and passing 1 as argument) which returns the department with the highest relationship; next, it gets the color of the first department by calling the DepartmentColor function (described in section 4.7.3, and passing the value returned after calling DepartmentalSequence as argument) which returns the color of the first department; the centroid of the Plant Layout is then calculated and used as the coordinated of the first department.
Next, the HorDepartmentalRelationships Function is then called to ascertain if the first department has any four-relationships. If it does these departments are placed about the first department with the help of the Points Function. The Points Function is called passing the coordinates of the first department as argument. The coordinate points returned (section 4.7.5) are checked alternatively to determine if they are occupied. If they are the next coordinate point is checked, and so on, until a free location is discovered.
Fig 4.6: Main Flow Chart
The DepartmentalSequence (this time passing two) is called again to get the “next department” that has the highest relationships. If this department has not been placed, the “Main”, calls RelationshipSorts (section 4.7.7) passing “next department” as argument. The RelationshipSorts returns the departments with the appropriate relationship, and the “next department” is placed next to these departments (those that have been placed) calling DepartmentColor and Points.
If “next department” have been placed, the “Main”, calls HorDepartmentalRelationships, passing “next department”, to get an array of the departments having four-relationship with it. This is then placed about the “next department”, each time calling DepartmentColor and Points. Details of these are contained in the fully coded version of the algorithm which is available upon request.


The State of Crypto Trends Report analyses the most interesting deelopments in crypto. We're a group of engineers, researchers, technologists, and crypto enthusiasts who started this to create more informed dialogue on the current state of crypto and it's implication on the future.
Learn more about the report below.
State of Crypto invites a range of contributions from well-known research organizations and individual contributors to contribute to the report we publish.
Part I of the State of Crypto Report summarizes the most interesting developments in crypto, covering topics along the key sections of technology, talent, commercial application, sustainability, regulatory compliance, and geopolitics (international impact).
Part II of the State of Crypto Report explores the data, our interpretation, and how we believe the industry will grow. We'll also look back on past predictions to rate our performance and understanding of the space.


Star Wars: Imperial Assault Campaign Tracker
Facebook Login
This site is in no way affiliated with Fantasy Flight Games or Lucasfilm Ltd.


To start using Journalinq, we need you to accept notifications. You can always change this through your browser settings
If you've accepted notifications, click here to start planning with Journalinq!


Project to Intercompare Regional Climate Simulations (PIRCS)
Eugene S. Takle (1,2,3), William J. Gutowski, Jr. (2), Raymond W.
Arritt (1), William A. Gallus, Jr. (2), R. W. Turner (2) and Z. Pan 2
(1)-Department of Agronomy, (2)-Department of Geological and Atmospheric
Sciences, and (3)-International Institute of Theoretical and Applied Physics
(IITAP)
3010 Agronomy Hall, Iowa State University, Ames, IA USA 50011.


The follow pages introduce some of the larger changes relating to the Java Virtual Machine introduced in the JDK 7 release:
In addition, the following enhancements are added:
Area: HotSpot
Standard/Platform: Java SE 7 Update 1
Synopsis: JIT and Loop Bugs: Three bugs reported by various parties, including Apache Lucene developers, have been fixed in JDK 7 Update 1, in addition to a fourth related bug found by Oracle.
RFE: 7070134,
7068051,
7044738,
7077439
Area: HotSpot
Standard/Platform: Java SE 7
Synopsis: The JVM/TI version number was changed from 1.1 to
1.2 in order to add the GetLocalInstance method.
RFE: 7003782,
7004582
Area: HotSpot
Standard/Platform: JDK 7
Synopsis: Classfiles with version number 51 are exclusively
veritified using the type-checking verifier, and thus the methods
must have StackMapTable attributes when appropriate. For
classfiles with version 50, the HotSpot JVM would (and continues
to) failover to the type-inferencing verifier if the stackmaps in
the file were missing or incorrect. This failover behavior does not
occur for classfiles with version 51 (the default version for
JDK7).
Any tool the modifies bytecode in a version 51 classfile must be
sure to update the stackmap information to be consistent with the
bytecode in order to pass verification.
RFE: 6693236
Area: HotSpot
Standard/Platform: JDK 7
Synopsis: In JDK 7, interned strings are no longer allocated
in the permanent generation of the Java heap, but are instead
allocated in the main part of the Java heap (known as the young and
old generations), along with the other objects created by the
application. This change will result in more data residing in the
main Java heap, and lessw data in the permanent generation, and
thus may require heap sizes to be adjusted. Most applications will
see only relatively small differences in heap usage due to this
change, but larger applications that load many classes or make
heavy use of the String.intern() method will see more
significant differences.
RFE: 6962931
Area: HotSpot
Standard/Platform: JDK 7
Synopsis: The default out-of-the-box heap size and shape
parameters for the concurrent mark sweep collector (CMS) have been
modified. The new settings take advantage of faster platforms that
have been introduced since JDK 6 was released. Like the other
collectors in HotSpot, CMS will now use the available physical
memory on the platform to size its heap, while attempting to shape
that heap to keep pause times associated with minor collections
"reasonable". The specific shape of the heap may be
platform-depenent in other ways as well.
Users can override all or some of these default settings by
explicitly sizing or shaping the heap, AKA "heap tuning", to suit
their specific needs.
For more information on the default settings for this and other
garbage collectors, please see the
Heap Tuning Guide for JDK 6.
RFE: 6896099
Area: HotSpot
Standard/Platform: JDK 7
Synopsis: The JDK 6 release notes included performance
enhancements for CMS. To provide a mechanism to continue using the
behavior provided by JDK 5, the CMSUseOldDefaults flag was
provided. This flag restored a number of settings to a default
state. During the last few years, this flag has received minimal
use and most customers prefer the improved CMS performance. The
CMSUseOldDefaults flag is now removed.
RFE: 7027529
Area: HotSpot
Standard/Platform: JDK 7
Synopsis: The GarbageFirst (G1) garbage collector is
experimental in this release. Some command line tools, such as
jstack or jmap, may not work properly when using
the G1 collector.
RFE: 6966967
Area: HotSpot
Standard/Platform: JDK 7
Synopsis: In previous releases of the JDK on Solaris only,
the Thread.interrupt() method would interrupt some
blocking I/O operatons resulting in InterruptedIOException
thrown by the target thread and leaving socket or file streams in
an inconsistent state. This so called "legacy interruptible I/O
support" has been disabled in JDK 7. Applications that previously
relied on this Solaris specific behavior can re-enable this support
by running with the following option on the command line:
-XX:+UseVMInterruptibleIO. A future release of the JDK may
remove the legacy interruptible I/O support completely.
RFE: 6554406


Terms & Conditions
Learn about the what the terms and conditions are of using the eyespace app!
Can Do
EyeSpace is committed to delivering accessibility, autonomy and inclusion to the
Visually Impaired in a fair and accessible way. This way, we aim to give a new look
at the world for the people with more security and practicality in the palm of your hands. We hope to
empower the visually impaired to achieve more.
Can't Do
EyeSpace is committed to delivering accessibility, autonomy and inclusion to the
Visually Impaired in a fair and accessible way. This way, we aim to give a new look
at the world for the people with more security and practicality in the palm of your hands. We hope to
empower the visually impaired to achieve more.


Kanye West Goes Into Opera
by Olawale AdeniyiAfter unveiling the very religious Jesus Is King Album on October 25, the turbulent rapper offers a new musical fantasy.
“Nebuchadnezzar”, this is the name of the next project by Kanye West, an opera premiered on November 24 at the Hollywood Bowl in Los Angeles. The musician announced the news via a Twitter publication, unveiling a kind of golden poster, designed by Nick Knight, a British fashion photographer. This one shows the profile of a man, who would be the profile of the Babylonian king Nebuchadnezzar II, who gave his name to the show.
The show will be directed by contemporary artist Vanessa Beecroft. Pitchofork says that it will also be about pieces by Peter Collins and Infinities. Tickets would go on sale Monday, November 18th. In an interview with journalist Zane Lowe on Beat 1, before the release of Jesus Is King, the musician had already mentioned the famous Babylonian king.
Kanye West recently unveiled his latest album Jesus Is King, with a film released on the same day in IMAX theatres.


Follow these steps to download invoices and receipts:
- Open the Billing page.
- Scroll down to the Invoices section and then click Download as PDF next to the invoice or receipt that you want to download.
- Click Download invoice or Download receipt.
A prompt to download the file to your local machine displays.


The Supreme Court of India is the highest judicial forum and final court of appeal under the Constitution of India, the highest constitutional court, with the power of judicial review. Consisting of the Chief Justice of India and a maximum of 30 other judges, it has extensive powers in the form of original, appellate and advisory jurisdictions.
As the final court of appeal of the country, it takes up appeals primarily against verdicts of the high courts of various states of the Union and other courts and tribunals. It safeguards fundamental rights of citizens and settles disputes between various governments in the country. As an advisory court, it hears matters which may specifically be referred to it under the constitution by President of India. It also may take cognisance of matters on its own (or suo moto), without anyone drawing its attention to them. The law declared by the supreme court becomes binding on all courts within India and also by the union and state governments.Per Article 142, it is the duty of the president to enforce the decrees of the supreme court.


| Package | Description |
|---|---|
| com.opengamma.strata.market.amount |
Defines representations of amounts typically used as result types.
|
| com.opengamma.strata.market.curve.node |
Curve nodes.
|
| com.opengamma.strata.market.explain |
Support for explaining results.
|
| com.opengamma.strata.measure.swap |
Calculation functions for swap products.
|
| com.opengamma.strata.pricer.curve |
Provides the ability to calibrate curves.
|
| com.opengamma.strata.pricer.swap |
Calculators for interest rate swaps.
|
| com.opengamma.strata.pricer.swaption |
Calculators for swaptions.
|
| com.opengamma.strata.product.bond |
Entity objects describing bonds.
|
| com.opengamma.strata.product.capfloor | |
| com.opengamma.strata.product.cms | |
| com.opengamma.strata.product.dsf |
Entity objects describing Deliverable Swap Futures (DSFs).
|
| com.opengamma.strata.product.swap |
Entity objects describing a swap.
|
| com.opengamma.strata.product.swap.type |
Conventions and templates to aid the construction of rate swaps.
|
| com.opengamma.strata.product.swaption |
Entity objects describing options on swaps, known as swaptions.
|
| Class and Description |
|---|
| ResolvedSwapLeg
A resolved swap leg, with dates calculated ready for pricing.
|
| SwapLegType
The type of a swap leg.
|
| Class and Description |
|---|
| ResolvedSwapTrade
A trade in a rate swap, resolved for pricing.
|
| SwapTrade
A trade in a rate swap.
|
| Class and Description |
|---|
| CompoundingMethod
A convention defining how to compound interest.
|
| Class and Description |
|---|
| ResolvedSwapTrade
A trade in a rate swap, resolved for pricing.
|
| SwapTrade
A trade in a rate swap.
|
| Class and Description |
|---|
| ResolvedSwapTrade
A trade in a rate swap, resolved for pricing.
|
| Class and Description |
|---|
| PaymentEvent
A payment event, where a single payment is made between two counterparties.
|
| PaymentPeriod
A period over which interest is accrued with a single payment.
|
| ResolvedSwap
A rate swap, resolved for pricing.
|
| ResolvedSwapLeg
A resolved swap leg, with dates calculated ready for pricing.
|
| ResolvedSwapTrade
A trade in a rate swap, resolved for pricing.
|
| Class and Description |
|---|
| PaymentEvent
A payment event, where a single payment is made between two counterparties.
|
| ResolvedSwap
A rate swap, resolved for pricing.
|
| ResolvedSwapLeg
A resolved swap leg, with dates calculated ready for pricing.
|
| Class and Description |
|---|
| InflationRateCalculation
Defines the calculation of a swap leg of a zero-coupon inflation coupon based on a price index.
|
| PaymentPeriod
A period over which interest is accrued with a single payment.
|
| Class and Description |
|---|
| IborRateCalculation
Defines the calculation of a floating rate swap leg based on an Ibor index.
|
| ResolvedSwapLeg
A resolved swap leg, with dates calculated ready for pricing.
|
| SwapLeg
A single leg of a swap.
|
| Class and Description |
|---|
| FixingRelativeTo
The base date that each rate fixing is made relative to.
|
| ResolvedSwap
A rate swap, resolved for pricing.
|
| ResolvedSwapLeg
A resolved swap leg, with dates calculated ready for pricing.
|
| SwapIndex
A swap index.
|
| SwapLeg
A single leg of a swap.
|
| Class and Description |
|---|
| ResolvedSwap
A rate swap, resolved for pricing.
|
| Swap
A rate swap.
|
| Class and Description |
|---|
| CompoundingMethod
A convention defining how to compound interest.
|
| FixedRateCalculation
Defines the calculation of a fixed rate swap leg.
|
| FixedRateCalculation.Builder
The bean-builder for
FixedRateCalculation . |
| FixedRateCalculation.Meta
The meta-bean for
FixedRateCalculation . |
| FixedRateStubCalculation
Defines the rate applicable in the initial or final stub of a fixed swap leg.
|
| FixedRateStubCalculation.Meta
The meta-bean for
FixedRateStubCalculation . |
| FixingRelativeTo
The base date that each rate fixing is made relative to.
|
| FxReset
An FX rate conversion for the notional amount of a swap leg.
|
| FxReset.Builder
The bean-builder for
FxReset . |
| FxReset.Meta
The meta-bean for
FxReset . |
| FxResetCalculation
Defines the calculation of an FX rate conversion for the notional amount of a swap leg.
|
| FxResetCalculation.Builder
The bean-builder for
FxResetCalculation . |
| FxResetCalculation.Meta
The meta-bean for
FxResetCalculation . |
| FxResetFixingRelativeTo
The base date that each FX reset fixing is made relative to.
|
| FxResetNotionalExchange
An exchange of notionals between two counterparties where FX reset applies.
|
| FxResetNotionalExchange.Builder
The bean-builder for
FxResetNotionalExchange . |
| FxResetNotionalExchange.Meta
The meta-bean for
FxResetNotionalExchange . |
| IborRateAveragingMethod
A convention defining how to average floating rates.
|
| IborRateCalculation
Defines the calculation of a floating rate swap leg based on an Ibor index.
|
| IborRateCalculation.Builder
The bean-builder for
IborRateCalculation . |
| IborRateCalculation.Meta
The meta-bean for
IborRateCalculation . |
| IborRateStubCalculation
Defines the rates applicable in the initial or final stub of an Ibor swap leg.
|
| IborRateStubCalculation.Builder
The bean-builder for
IborRateStubCalculation . |
| IborRateStubCalculation.Meta
The meta-bean for
IborRateStubCalculation . |
| ImmutableSwapIndex
A swap index implementation based on an immutable set of rules.
|
| ImmutableSwapIndex.Builder
The bean-builder for
ImmutableSwapIndex . |
| ImmutableSwapIndex.Meta
The meta-bean for
ImmutableSwapIndex . |
| InflationRateCalculation
Defines the calculation of a swap leg of a zero-coupon inflation coupon based on a price index.
|
| InflationRateCalculation.Builder
The bean-builder for
InflationRateCalculation . |
| InflationRateCalculation.Meta
The meta-bean for
InflationRateCalculation . |
| KnownAmountNotionalPaymentPeriod
A period within a swap that results in a known amount.
|
| KnownAmountNotionalPaymentPeriod.Builder
The bean-builder for
KnownAmountNotionalPaymentPeriod . |
| KnownAmountNotionalPaymentPeriod.Meta
The meta-bean for
KnownAmountNotionalPaymentPeriod . |
| KnownAmountPaymentPeriod
A period within a swap that results in a known amount.
|
| KnownAmountPaymentPeriod.Builder
The bean-builder for
KnownAmountPaymentPeriod . |
| KnownAmountPaymentPeriod.Meta
The meta-bean for
KnownAmountPaymentPeriod . |
| KnownAmountSwapLeg
A fixed swap leg defined in terms of known amounts.
|
| KnownAmountSwapLeg.Builder
The bean-builder for
KnownAmountSwapLeg . |
| KnownAmountSwapLeg.Meta
The meta-bean for
KnownAmountSwapLeg . |
| NegativeRateMethod
A convention defining how to handle a negative interest rate.
|
| NotionalExchange
An exchange of notionals between two counterparties.
|
| NotionalExchange.Builder
The bean-builder for
NotionalExchange . |
| NotionalExchange.Meta
The meta-bean for
NotionalExchange . |
| NotionalPaymentPeriod
A period over which interest is accrued with a single payment calculated using a notional.
|
| NotionalSchedule
Defines the schedule of notional amounts.
|
| NotionalSchedule.Builder
The bean-builder for
NotionalSchedule . |
| NotionalSchedule.Meta
The meta-bean for
NotionalSchedule . |
| OvernightAccrualMethod
The method of accruing interest based on an Overnight index.
|
| OvernightRateCalculation
Defines the calculation of a floating rate swap leg based on an Overnight index.
|
| OvernightRateCalculation.Builder
The bean-builder for
OvernightRateCalculation . |
| OvernightRateCalculation.Meta
The meta-bean for
OvernightRateCalculation . |
| PaymentEvent
A payment event, where a single payment is made between two counterparties.
|
| PaymentPeriod
A period over which interest is accrued with a single payment.
|
| PaymentRelativeTo
The base date that each payment is made relative to.
|
| PaymentSchedule
Defines the schedule of payment dates relative to the accrual periods.
|
| PaymentSchedule.Builder
The bean-builder for
PaymentSchedule . |
| PaymentSchedule.Meta
The meta-bean for
PaymentSchedule . |
| PriceIndexCalculationMethod
Reference price index calculation method.
|
| RateAccrualPeriod
A period over which a fixed or floating rate is accrued.
|
| RateAccrualPeriod.Builder
The bean-builder for
RateAccrualPeriod . |
| RateAccrualPeriod.Meta
The meta-bean for
RateAccrualPeriod . |
| RateCalculation
The accrual calculation part of an interest rate swap leg.
|
| RateCalculationSwapLeg
A rate swap leg defined using a parameterized schedule and calculation.
|
| RateCalculationSwapLeg.Builder
The bean-builder for
RateCalculationSwapLeg . |
| RateCalculationSwapLeg.Meta
The meta-bean for
RateCalculationSwapLeg . |
| RatePaymentPeriod
A period over which a rate of interest is paid.
|
| RatePaymentPeriod.Builder
The bean-builder for
RatePaymentPeriod . |
| RatePaymentPeriod.Meta
The meta-bean for
RatePaymentPeriod . |
| RatePeriodSwapLeg
A rate swap leg defined using payment and accrual periods.
|
| RatePeriodSwapLeg.Builder
The bean-builder for
RatePeriodSwapLeg . |
| RatePeriodSwapLeg.Meta
The meta-bean for
RatePeriodSwapLeg . |
| ResetSchedule
Defines the schedule of fixing dates relative to the accrual periods.
|
| ResetSchedule.Builder
The bean-builder for
ResetSchedule . |
| ResetSchedule.Meta
The meta-bean for
ResetSchedule . |
| ResolvedSwap
A rate swap, resolved for pricing.
|
| ResolvedSwap.Builder
The bean-builder for
ResolvedSwap . |
| ResolvedSwap.Meta
The meta-bean for
ResolvedSwap . |
| ResolvedSwapLeg
A resolved swap leg, with dates calculated ready for pricing.
|
| ResolvedSwapLeg.Builder
The bean-builder for
ResolvedSwapLeg . |
| ResolvedSwapLeg.Meta
The meta-bean for
ResolvedSwapLeg . |
| ResolvedSwapTrade
A trade in a rate swap, resolved for pricing.
|
| ResolvedSwapTrade.Builder
The bean-builder for
ResolvedSwapTrade . |
| ResolvedSwapTrade.Meta
The meta-bean for
ResolvedSwapTrade . |
| Swap
A rate swap.
|
| Swap.Builder
The bean-builder for
Swap . |
| Swap.Meta
The meta-bean for
Swap . |
| SwapIndex
A swap index.
|
| SwapLeg
A single leg of a swap.
|
| SwapLegType
The type of a swap leg.
|
| SwapTrade
A trade in a rate swap.
|
| SwapTrade.Builder
The bean-builder for
SwapTrade . |
| SwapTrade.Meta
The meta-bean for
SwapTrade . |
| Class and Description |
|---|
| CompoundingMethod
A convention defining how to compound interest.
|
| FixingRelativeTo
The base date that each rate fixing is made relative to.
|
| OvernightAccrualMethod
The method of accruing interest based on an Overnight index.
|
| PriceIndexCalculationMethod
Reference price index calculation method.
|
| RateCalculationSwapLeg
A rate swap leg defined using a parameterized schedule and calculation.
|
| SwapTrade
A trade in a rate swap.
|
| Class and Description |
|---|
| ResolvedSwap
A rate swap, resolved for pricing.
|
| Swap
A rate swap.
|
Copyright 2009-Present by OpenGamma Inc. and individual contributors
Apache v2 licensed
Additional documentation can be found at opengamma.github.io/StrataDocs.


group |
String |
'' |
The group |
animation |
String, Boolean |
slide |
Animation mode (slide, fade, delayed-fade, false). |
duration |
String|Boolean |
250 |
Animation duration in milliseconds. |
threshold |
Number |
10 |
Mouse move threshold before dragging starts. |
cls-item |
String |
uk-sortable-item |
The item class. |
cls-placeholder |
String |
uk-sortable-placeholder |
The placeholder class. |
cls-drag |
String |
uk-sortable-drag |
The ghost class. |
cls-drag-state |
String |
uk-sortable-dragging |
The body's dragging class. |
cls-base |
String |
uk-sortable |
The list's class. |
cls-no-drag |
String |
uk-sortable-nodrag |
Prevent dragging on elements with this class. |
cls-empty |
String |
uk-sortable-empty |
The empty list class. |
cls-custom |
String |
'' |
The ghost's custom class. |
handle |
String |
false |
The handle selector. |


Angular Best Practices
*You'd think a best practices application would follow the best practices. You'd be wrong.
Open the developer console to read AngularHint messages about the mistakes.
Show Best Practices For:
Controllers
Directives
DOM
Events
Interpolation
Modules
{{contributor.name}}


You can import the blocks presented here as a project or download them as a library to import into your projects.
This chapter of the guide includes many interactive elements that are known to run well in the Chrome or Edge browser. This chapter relies upon there being a camera that the browser can access. Note that the blocks described here create a second browser window for "training" the system. Snap! and training window are both in the same browser tab but only one is visible at any time.
In the previous chapters the new Snap! blocks used services that had been trained to recognize speech and images. In this chapter you do the training. This training is done by a deep learning system. Deep learning is a very successful set of machine learning techniques. It is called "deep" because there are many layers of simulated neurons that do the processing. Typically, the lowest layers pay attention to tiny details but higher layers can use the output of lower layers that capture some aspect of the image such as texture or edges. Here is a very nice 5-minute video that introduces the big ideas behind machine learning:
In this chapter we focus upon "supervised learning" which means that during training labels for the input are provided. The machine learns to then choose among training labels when presented with a new image (or other kinds of input). Rarely is the system completely confident that its choice of label is correct so instead it computes "confidence scores". The scores are between 0 (certain it is not this label) to 1 (certain it is). The sum of the scores of all the labels always adds up to 1. You may prefer to display confidence scores as percentages by multiplying the scores by 100. For example, a .8 score for label X can be thought of as saying the system is "80% sure the new input should have label X".
Unlike the previous chapters that rely upon pre-trained models here you can experiment with machine learning. You can learn what kinds of inputs the system can easily tell apart and which ones confuse it. You can experiment to answer questions such as how many examples of each label are needed to recognize them reliably and how does recognition degrade as more labels are introduced. In a later chapter you can not only train a neural network model but also design and create the model.
The Train with image buckets ... block opens a tab where you can train the system to label what is in front of the camera. (If the tab is blocked by your browser read the troubleshooting guide.) The first argument is the list of labels. A "bucket" is the collection of all the images with the same label. The system will attempt to determine the confidence that an image matches the images in each bucket. If you are training it to distinguish between two things (e.g. cats and dogs) then it is a good idea to add a third bucket for "everything else". During training then produce images of lots of different things that aren't cats or dogs while pressing the button to train for the "everything else" bucket.
This block does the training completely on your device. There are no privacy issues that arise when relying upon third-party cloud services. It also means this and associated blocks will work even when there is no Internet. (See instructions for how to download everything and then run offline.) Blocks that use your trained model will typically run much faster than a request over the internet to a web service, enabling more responsive apps.
In the following example there are only two labels: "leaning to the left" and "leaning to the right". You can edit the list to instead recognize different facial expressions, different people's faces, objects held in front of the camera, and much more. When the training tab launches you'll see two buttons:
Click to read an advanced topic
The Train with image buckets ... block only needs the first argument telling it the bucket labels. It has three additional optional arguments:
When training the system try to provide a variety of images that match the label. If you are training "leaning left" then lean different amounts and at different distances to the camera. Then when training "leaning right" don't allow the system to learn some difference that shouldn't matter. For example, don't change the lighting or background between training different labels. When you aren't pressing any training buttons the training page keeps trying to recognize what is in front of the camera. You can determine if your training is good by leaning one way and then the other and see if the confidence scores changes as they should. If not, try adding more images.
When you are ready to test the trained system return to the Snap! tab and click on the blocks that contain the label confidence scores from costume block. You will see the value reported which is a list of the probability of the first label ("leaning to the left" here) followed by the probability of the second label. Change what is in front of the camera and try again. Note that you can return to the training tab to add more training samples by clicking on the Open support panel block. When you are finished with this, close the training tab.
Here is a program that launches a training tab to determine whether your finger is pointing at the camera or to the right. While training move your hand around so it is trained to ignore where the hand is and just pay attention to which way the finger is pointing. When you return to Snap! the program will repeatedly check which way your finger is pointing. If it sees a finger pointing at the camera, then the sprite displaying the latest camera image moves forward. If not, then it rotates. It always displays the latest confidence scores.
Exercise. There are many ways of enhancing this program. Add a third or fourth label and use that label to control the turtle. For example, add the label of pointing left and change the program to turn left or right depending on which way the finger is pointing. Or add a gesture to stop moving.
A full screen version of the following program can be found here. Look at the script, it isn't very complicated considering what it does. There is a similar program where the sprite moves left or right depending upon which way you are leaning. Think of modifying it in interesting ways, e.g. a face whose eyes look left and right as you lean left and right. A web page where one can type by moving one's head (perhaps useful to those with physical disabilities) uses the same ideas as this.
Exercise. Explore how to make the training more accurate. How does the performance change as more examples are presented? Does it help to simplify the images (e.g. arrange so only your pointing hand with a neutral background is being captured by the camera)? If you train with one person and then replace with another does the system get confused? Does it help to train with both people?
In Snap! each sprite can have any number of "costumes". Costumes can be drawings, photos, or imported images.
Using the Train with all my costumes you can send all of a sprite's costumes to the training tab. This block is defined using the Add costume i to training ... block. You can also ask the training tab about label confidences of a costume using Label confidences of costume .... Note that the Prepare for training images ... block is a simple verison of Train with image buckets... block that avoids displaying the camera training window. You can experiment with these costume-based training blocks in the following.
While in a training window you will see a button Save your training. Clicking it save a file where you want.
To load saved training, you can either load the file on the local file system or host the file on the web and use its URL to access it.
Google has developed The Teachable Machine to introduce the process of training a model to categorize images, sounds, and poses. After training you can export your model to their server or download the files to your own web server. The Get prediction for costume ... block reports the probabilities that the costume is in each of the categories for which it was trained.
The Get predictions using Teachable Machine audio model ... block is different since it runs a command block input whenever a word is recognized. You can try an example of its use in the following exercise. In addition to Snap!'s stop sign button, you can stop it from listening by using the Stop listening for audio label confidences block.
In the previous chapter many blocks were introduced that do image recognition. These rely upon AI cloud services from large companies. Here we instead rely upon a trained machine learning model named MobileNet. This model runs in your browser and does not contact any cloud services. While it will choose from among 1000 labels it rarely does as well as the cloud services. For contexts where registering for API keys is a problem, or Internet access is limited or missing, or privacy is a concern then models like MobileNet are useful. It does, however, rely upon your device having a GPU to run at reasonable speeds. Note this will be slow to load but should run quickly thereafter.
Most of the things image recognition is good for and its dangers were discussed in chapter 3. But maybe the situation is different if users do the training instead of professionals in large corporations. Will the biases be different? Does the smaller training set make the system less reliable?
Click to read an advanced topic
We discussed how image recognition works in general in the previous chapter. The fact that training of a deep learning system is feasible inside of browser is due to the work on tensorflow.js. This JavaScript library speeds up learning and prediction by using the GPU that is part of nearly all computers. The GPU can be more than one hundred times faster at the computations that deep learning needs than using the CPU of the computer. The training window is based upon the teachable machine boilerplate. The deep learning model used is called MobileNet and it is designed to be smaller and faster than more accurate architectures. It works by using MobileNet to compute 1000 numbers for each trained image. These numbers capture high-level features of the image. Then when asked to classify a new image it sees which of the images used in training are the closest and reports a high confidence for the labels of those images.
Using machine learning one can make a rock paper scissors game that can be played by putting your hand into one of three configurations. If the game below doesn't work visit this help.
This game uses the train with all my costumes ... block four times. Once for rocks, paper, and scissors and a fourth time for "other". Once the training is completed the game starts and the program picks a random move and compares it to what it thinks your move was based upon the analysis of what is in front of the camera. You can start exploring and enhancing the game most easily by clicking on the Open this in a new tab block in the scripting area. This example was inspired by the great set of machine learning project examples at machine learning for kids
Much of the current success of machine learning system is a result of having trained them on huge data sets. Deep learning for machine translation, for example, didn't work well until they were trained with billions of sentences. So how could the examples in this chapter work with just dozens of examples for each label? Part of the answer is that big data is necessary for high accuracy. If you try the rock paper scissors game, you'll see it sometimes makes mistakes. See if you can improve its accuracy by adding more training images.
The image training command relies upon a deep learning model called MobileNet that was trained on 1000 categories in 1.2 million images. The Snap! command uses what is called transfer learning to start the training using the features that a well-trained system has already learned. The system does not know anything about, for example, hands shaped as paper, rock, or scissors but it has already learned about textures, edges, colors, and more. Each training image used in transfer learning is converted by MobileNet into a list of 1280 numbers. The confidence scores for the labels is then computed using an algorithm called k-nearest neighbors. To classify an image, its distance to each of the training images is computed and the "k" closest images are found. These closest images "vote" for their label as the classification and the sums are used to compute the confidences.
Another difference is that the image recognition services in the previous chapter can distinguish between many thousands of different kinds of images and has been trained for a long time on many millions of images. The Rock paper scissors game requires only four categories - an easier task. And AI vision services can do more than just choose a label for an image.
Computers can be trained to distinguish different sounds including spoken speech. Chapter 3 describes how to use cloud services that do speech recognition. Here you can create programs that respond to any sound. Also you can train it to recognize a few different words or phrases that works locally on your computer without sending any audio to a cloud server. This is useful in contexts without a reliable network connection or for increased privacy. Furthermore, the Audio label confidences block has an option to use a "Pre-trained model of 20 words" on your device. It is capable of recognising 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'up', 'down', 'left', 'right', 'go', 'stop', 'yes', and 'no'. This relies upon the speech command recognizer created by Google.
The Train with audio buckets... block uses a TensorFlow.js deep learning model which without a GPU runs too slow to be useful. For running on small computers such as a Raspberry Pi there is also the similar Train (without TensorFlow) with audio buckets... block and its accompanying Audio label confidences (without TensorFlow) block.
An example using audio training is to tell a sprite to go "forward", turn "right", or "stop". Note that these labels are for us humans, you can for example make any sound or speak in another language and the program should work just fine.
Google has released browser-based machine learning models for real-time human pose estimation. This software can determine the locations of 17 (or 33 depending upon which version is chosen) different face and body parts: noses, eyes, ears, shoulders, elbows, wrists, hips, knees, and ankles. These models were created using deep machine learning and makes use of Tensorflow.js. Google posted a blog describing how the pose models were made and some uses. This works in the browser without any special software or hardware.
The body poses of costume block reports a list of poses. One pose for each person in the costume (either obtained from the camera accessed by the browser or from photographic Snap! costumes. Each pose is a list of lists of keys and values. The PoseNet version works for multiple people, while the other two are best for a single pose. The get the <property> of <list of keys and values> block can fetch information from a pose. The models also report their confidence that it has correctly identified a particular body part (with scores between 0 and 1). Depending upon the value of the third input the location is reported as values between 0 and 100, as coordinates of the stage, or costume image coordinates. The BlazePose version also reports 3D coordinates between 0 and 1. Advanced options can be supplied to body poses of costume. One option modelType can be used to trade-off between speed and accuracy. See this documenation.
Google has also developed a model that reports 21 locations on a hand. The hand poses of costume reports these locations and their confidence scores. Like the body poses of costume block (see above) it can report locations in costume coordinates, stage coordinates, or percentages. Note that the location labels use anatomical abbreviations: CMC for carpometacarpal, MCP for metacarpophalangeal, and IP for interphalangeal, IP for proximal interphalangeal, and DIP for distal phalanges.
Google has released a model that can detect 468 locations on each face in an image. Each location includes the z dimension of its estimated depth. The face landmarks in costume block provides access to this model. It reports the 468 3D locations for each face in a costume (generated by the camera or a photo image) as well as the dimensions of the smallest box surrounding each face. These boxes, along with six facial landmarks, can also be obtained using the face detection using costume block which is much faster than face landmarks in costume block. A few of the locations also include the name of the location (e.g. "rightEye" and "lips"). There are a few advanced options for customizing this block. A sample project captures facial landmarks and can rotate the face in x, y, or z. And it can record an animation of the face rotating and shrinking or expanding.
Google developed a model that can estimate the depth of every pixel in a portrait photo. The portrait depth of costume block provides access to this. It reports a list of lists of depth numbers that range from 0 (furthest) to 1 (closest). The inner lists correspond to horizontal lines of the image. Google has made an interactive web demo using this to make photos look 3D.
Using the poses block a Simon Says game can be built. It chooses whether to preface its statement with "Simon says" and picks two body parts for the player to bring together. Pose detection is used to see if the user creates a pose that matches what was said.
Exercise. The full screen version of the game can be enhanced in many ways. Be creative.
Click to read an advanced topic
Google trained a deep learning model on over 64,000 images of people. Associated with each image was a mask showing which pixels were of a person (indicated by one or white) or not (zero or black). Also the locations of up to 17 face and body key points were provided. The trained model starts by first identifying the locations of body parts in a new image. It then refines their positions by considering neighboring key points (e.g. left elbow connects only with left wrist and left shoulder). If the image is of more than one person, the model needs to separate the key points to different people. The algorithm starts with the key point it has the most confidence rather than a favored starting point such as the nose. It then considers body part locations connected to that key point, and then those connected to those parts, and so on. If, in addition, segmentation is also required it assigns each pixel a code for each body part it belongs. Full details can be found in the paper PersonLab: Person Pose Estimation and Instance Segmentation with a Bottom-Up, Part-Based, Geometric Embedding Model.
BodyPix is a deep learning segmentation model that classifies each pixel in a photo of people as to whether it is a part of a body and if so what part. This is called segmentation since it segments the image into hands, arms, legs, etc.
There are two blocks for segmentation:
Both blocks can be used with images of any number of people but each one is faster and more informative when used as indicated.
Both blocks take as an argument a list of options indicating what information is desired:
These blocks report a list of findings. The get the key in table block provides a convenient way of retrieving a finding. The keys for the segmentation and pose of costume... block are costume, pixel codes, and all poses. Often all poses contains more poses than there are people but the extra ones have very low confidence scores. The segmentations and poses of costume... block reports a list of findings, one for each person detected. Each person finding can have the keys costume, pixel codes, pose, and person bitmap. The get value at x and y from bitmap can be used to read the value of either the pixel codes or the person bitmap.
Here you can explore the segmentation and pose of costume... block.
Here you can explore the segmentations and poses of costume... block.
The Balloon Game is an example of how a project might use segmentation. Balloons slowly fall down and a point is awarded when popped by a hand or foot. Balloons that pop on someone's head lose a point.
COCO-SSD is a deep learning object detection model. It can detect up to 100 objects of 80 different kinds. It labels them and provides a "bounding box" for each object detected. A bounding box is the smallest rectangle that surrounds the object.
COCO-SSD was trained using the COCO dataset which has labels and locations of 1.5 million objects in over 200,000 images. SSD stands for Single Shot MultiBox Detection because COCO-SSD is a single model that in one go has been trained to detect multiple bounding boxes of several objects in an image.
The objects in costume block reports a list of descriptions of each object detected. It optionally accepts a list of options.
You can experiment with the objects in costume block by clicking this image:
Recently researchers have invented a way to use two machine learning programs to take an image and turn it into one that looks like a famous painting. This is called style transfer. The Create costume in style ... block takes in a Snap! sprite costume (that can be any image or captured from the camera) and a style name and produces a new costume in that style.
The available styles are based upon these paintings:
Here is a sample program that takes a photo and creates all available styles of it. It uses Snap!'s "ghost effect" to dissolve in and out the styled images.
The Create costume in style ... block relies upon the work done by students at the New York University Tisch School of the Arts who created web-based versions of style transfer models. Adapting it to work with Snap! was done by a high school student named Luie. The core idea is to use a deep learning model that can recognize images to generate a new image that matches well the low-level style features of the style image and at the same time matches the high-level content features of a content image. A machine learning model has been trained to do this quickly.
A very good short video explaining how style transfer works is here:
Most of the project ideas listed for using image recognition services can be based upon the blocks described in this chapter. There is much that training by users enables that cloud services can't do. You can train the system to recognize yourself, distinguish between your friends, gestures, and the things that your robots may encounter in their particular environments.
Here are some project ideas that exploit the ability of users to train the system:
Many projects are possible by using the pose detection block, the segmentation block, and the style transfer block:
The machine learning for kids site also has sample projects that can be adapted.
Several enhancements to this chapter are planned. Interfaces to other pre-trained models are planned. These include ones that track faces and hands in detail.
In addition to the resources listed in the previous chapter there is the Learning about machine learning website. It has many "unplugged" activities and a long annotated list of resources appropriate for school students. The Royal Society has a good machine learning web site that includes two very nice interactive infographics: What is machine learning? and Machine learning in the world. Technical details on the deep learning model used here are documented here.
There is the Google blog post about style transfer that explains the ideas and introduces the idea of generating images that match multiple styles. A Neural Algorithm of Artistic Style is the paper that pioneered the idea of using deep learning models to transfer style while preserving content. Recently a painting created by a machine learning program was sold at a major art auction for the first time.
You can import the blocks presented here as a project or download them as a library to import into your projects.
Go to the next chapter on using AI on words and sentences
Return to the previous chapter on using image recognition services.


This is a simple jQuery Plugin that uses an AJAX request to determine whether the client machine is connected. It is free to use under MIT license. License