title = "Plugin components" url = "/demo/plugins" layout = "default" [demoTodo] max = 3 ==
Plugins can provide components, simple building blocks that enrich any page or layout. Check out the todo example below.
Learn more at October's Documentation


official-chat.html
Get Started: Chat application
In this guide we’ll create a basic chat application. It requires almost no basic prior knowledge of Node.JS or Socket.IO, so it’s ideal for users of all knowledge levels.
Introduction
Writing a chat application with popular web applications stacks like LAMP (PHP) has traditionally been very hard. It involves polling the server for changes, keeping track of timestamps, and it’s a lot slower than it should be.
Sockets have traditionally been the solution around which most realtime chat systems are architected, providing a bi-directional communication channel between a client and a server.
This means that the server can push messages to clients. Whenever you write a chat message, the idea is that the server will get it and push it to all other connected clients.
The web framework
The first goal is to setup a simple HTML webpage that serves out a form and a list of messages. We’re going to use the Node.JS web framework express to this end. Make sure Node.JS is installed.
First let’s create a package.json manifest file that describes our project. I recommend you place it in a dedicated empty directory (I’ll call mine chat-example).
{
"name": "socket-chat-example",
"version": "0.0.1",
"description": "my first socket.io app",
"dependencies": {}
}
Now, in order to easily populate the dependencies with the things we need, we’ll use npm install --save:
npm install --save<EMAIL_ADDRESS>Now that express is installed we can create an index.js file that will setup our application.
var app = require('express')();
var http = require('http').Server(app);
app.get('/', function(req, res){
res.send('Hello world
');
});
http.listen(3000, function(){
console.log('listening on *:3000');
});
This translates into the following:
Express initializes app to be a function handler that you can supply to an HTTP server (as seen in line 2).
We define a route handler / that gets called when we hit our website home.
We make the http server listen on port 3000.
If you run node index.js you should see the following:
And if you point your browser to http://localhost:3000:
Serving HTML
So far in index.js we’re calling res.send and pass it a HTML string. Our code would look very confusing if we just placed our entire application’s HTML there. Instead, we’re going to create a index.html file and serve it.
Let’s refactor our route handler to use sendFile instead:
app.get('/', function(req, res){
res.sendFile(__dirname + '/index.html');
});
And populate index.html with the following:
Socket.IO chat
If you restart the process (by hitting Control+C and running node index again) and refresh the page it should look like this:
Integrating Socket.IO
Socket.IO is composed of two parts:
A server that integrates with (or mounts on) the Node.JS HTTP Server: socket.io
A client library that loads on the browser side: socket.io-client
During development, socket.io serves the client automatically for us, as we’ll see, so for now we only have to install one module:
npm install --save socket.io
That will install the module and add the dependency to package.json. Now let’s edit index.js to add it:
var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);
app.get('/', function(req, res){
res.sendfile('index.html');
});
io.on('connection', function(socket){
console.log('a user connected');
});
http.listen(3000, function(){
console.log('listening on *:3000');
});
Notice that I initialize a new instance of socket.io by passing the http (the HTTP server) object. Then I listen on the connection event for incoming sockets, and I log it to the console.
Now in index.html I add the following snippet before the :
That’s all it takes to load the socket.io-client, which exposes a io global, and then connect.
Notice that I’m not specifying any URL when I call io(), since it defaults to trying to connect to the host that serves the page.
If you now reload the server and the website you should see the console print “a user connected”.
Try opening several tabs, and you’ll see several messages:
Each socket also fires a special disconnect event:
io.on('connection', function(socket){
console.log('a user connected');
socket.on('disconnect', function(){
console.log('user disconnected');
});
});
Then if you refresh a tab several times you can see it in action:
Emitting events
The main idea behind Socket.IO is that you can send and receive any events you want, with any data you want. Any objects that can be encoded as JSON will do, and binary data is supported too.
Let’s make it so that when the user types in a message, the server gets it as a chat message event. The scripts section in index.html should now look as follows:
And in index.js we print out the chat message event:
io.on('connection', function(socket){
socket.on('chat message', function(msg){
console.log('message: ' + msg);
});
});
The result should be like the following video:
Broadcasting
The next goal is for us to emit the event from the server to the rest of the users.
In order to send an event to everyone, Socket.IO gives us the io.emit:
io.emit('some event', { for: 'everyone' });
If you want to send a message to everyone except for a certain socket, we have the broadcast flag:
io.on('connection', function(socket){
socket.broadcast.emit('hi');
});
In this case, for the sake of simplicity we’ll send the message to everyone, including the sender.
io.on('connection', function(socket){
socket.on('chat message', function(msg){
io.emit('chat message', msg);
});
});
And on the client side when we capture a chat message event we’ll include it in the page. The total client-side JavaScript code now amounts to:
And that completes our chat application, in about 20 lines of code! This is what it looks like:
Homework
Here are some ideas to improve the application:
Broadcast a message to connected users when someone connects or disconnects
Add support for nicknames
Don’t send the same message to the user that sent it himself. Instead, append the message directly as soon as he presses enter.
Add “{user} is typing” functionality
Show who’s online
Add private messaging
Share your improvements!
Getting this example
You can find it on GitHub here.
$ git clone https://github.com/guille/chat-example.git


Joe Pasquale's panel show appearances
Joe Pasquale (born 1961-08-20[ref]) has appeared in 16 episodes between 2005-2015. Joe Pasquale on IMDB. Joe Pasquale on Wikipedia.
- 2015-05-01 / Loose Women
- 2014-10-24 / Loose Women
- 2013-10-10 / Loose Women
- 2013-01-21 / Loose Women
- 2012-11-15 / Loose Women
- 2012-03-28 / Loose Women
- 2011-10-19 / Loose Women
- 2011-03-18 / Loose Women
- 2010-10-07 / Loose Women
- 2009-10-01 / Loose Women
- 2008-10-03 / Loose Women
- 2008-03-07 / Loose Women
- 2007-04-20 / Loose Women
- 2006-10-17 / Loose Women
- 2005-09-28 / Loose Women
- 2005-04-21 / Loose Women


| Mon | Tue | Wed | Thu | Fri | Sat | Sun | ||
|---|---|---|---|---|---|---|---|---|
| Incoming |
|
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
| Outgoing |
|
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |
= $faker->numberBetween(5,1000) ?> = $faker->numberBetween(5,1000) ?> |


# Example: Sample Lint Check GitHub Project
The [](https://github.com/googlesamples/android-custom-lint-rules)
GitHub project provides a sample lint check which shows a working
skeleton.
This chapter walks through that sample project and explains
what and why.
## Project Layout
Here's the project layout of the sample project:
*******************************************************************
* *
* +----+ implementation +--------+ lintPublish +-------+ *
* |:app+----------------->|:library+-------------->|:checks| *
* +----+ +--------+ +-------+ *
* *
*******************************************************************
We have an application module, `app`, which depends (via an
`implementation` dependency) on a `library`, and the library itself has
a `lintPublish` dependency on the `checks` project.
## :checks
The `checks` project is where the actual lint checks are implemented.
This project is a plain Kotlin or plain Java Gradle project:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
apply plugin: 'java-library'
apply plugin: 'kotlin'
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! Tip
If you look at the sample project, you'll see a third plugin
applied: `apply plugin: 'com.android.lint'`. This pulls in the
standalone Lint Gradle plugin, which adds a lint target to this
Kotlin project. This means that you can run `./gradlew lint` on the
`:checks` project too. This is useful because lint ships with a
dozen lint checks that look for mistakes in lint detectors! This
includes warnings about using the wrong UAST methods, invalid id
formats, words in messages which look like code which should
probably be surrounded by apostrophes, etc.
The Gradle file also declares the dependencies on lint APIs
that our detector needs:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin linenumbers
dependencies {
compileOnly "com.android.tools.lint:lint-api:$lintVersion"
compileOnly "com.android.tools.lint:lint-checks:$lintVersion"
testImplementation "com.android.tools.lint:lint-tests:$lintVersion"
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The second dependency is usually not necessary; you just need to depend
on the Lint API. However, the built-in checks define a lot of
additional infrastructure which it's sometimes convenient to depend on,
such as `ApiLookup` which lets you look up the required API level for a
given method, and so on. Don't add the dependency until you need it.
## lintVersion?
What is the `lintVersion` variable defined above?
Here's the top level build.gradle
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin linenumbers
buildscript {
ext {
kotlinVersion = '1.4.32'
// Current lint target: Studio 4.2 / AGP 7
//gradlePluginVersion = '4.2.0-beta06'
//lintVersion = '27.2.0-beta06'
// Upcoming lint target: Arctic Fox / AGP 7
gradlePluginVersion = '7.0.0-alpha10'
lintVersion = '30.0.0-alpha10'
}
repositories {
google()
mavenCentral()
}
dependencies {
classpath "com.android.tools.build:gradle:$gradlePluginVersion"
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The `$lintVersion` variable is defined on line 11. We don't technically
need to define the `$gradlePluginVersion` here or add it to the classpath on line 19, but that's done so that we can add the `lint`
plugin on the checks themselves, as well as for the other modules,
`:app` and `:library`, which do need it.
When you build lint checks, you're compiling against the Lint APIs
distributed on maven.google.com (which is referenced via `google()` in
Gradle files). These follow the Gradle plugin version numbers.
Therefore, you first pick which of lint's API you'd like to compile
against. You should use the latest available if possible.
Once you know the Gradle plugin version number, say 4.2.0-beta06, you
can compute the lint version number by simply adding **23** to the
major version of the gradle plugin, and leave everything the same:
**lintVersion = gradlePluginVersion + 23.0.0**
For example, 7 + 23 = 30, so AGP version *7.something* corresponds to
Lint version *30.something*. As another example; as of this writing the
current stable version of AGP is 4.1.2, so the corresponding version of
the Lint API is 27.1.2.
!!! Tip
Why this arbitrary numbering -- why can't lint just use the same
numbers? This is historical; lint (and various other sibling
libraries that lint depends on) was released earlier than the Gradle
plugin; it was up to version 22 or so. When we then shipped the
initial version of the Gradle plugin with Android Studio 1.0, we
wanted to start the numbering over from “1” for this brand new
artifact. However, some of the other libraries, like lint, couldn't
just start over at 1, so we continued incrementing their versions in
lockstep. Most users don't see this, but it's a wrinkle users of the
Lint API have to be aware of.
## :library and :app
The `library` project depends on the lint check project, and will
package the lint checks as part of its payload. The `app` project
then depends on the `library`, and has some code which triggers
the lint check. This is there to demonstrate how lint checks can
be published and consumed, and this is described in detail in the
[Publishing a Lint Check](publishing.md.html) chapter.
## Lint Check Project Layout
The lint checks source project is very simple
```
checks/build.gradle
checks/src/main/resources/META-INF/services/com.android.tools.lint.client.api.IssueRegistry
checks/src/main/java/com/example/lint/checks/SampleIssueRegistry.kt
checks/src/main/java/com/example/lint/checks/SampleCodeDetector.kt
checks/src/test/java/com/example/lint/checks/SampleCodeDetectorTest.kt
```
First is the build file, which we've discussed above.
## Service Registration
Then there's the service registration file. Notice how this file is in
the source set `src/main/resources/`, which means that Gradle will
treat it as a resource and will package it into the output jar, in the
`META-INF/services` folder. This is using the service-provider loading facility in the JDK to register a service lint can look up. The
key is the fully qualified name for lint's `IssueRegistry` class.
And the **contents** of that file is a single line, the fully
qualified name of the issue registry:
```
$ cat checks/src/main/resources/META-INF/services/com.android.tools.lint.client.api.IssueRegistry
com.example.lint.checks.SampleIssueRegistry
```
(The service loader mechanism is understood by IntelliJ, so it will
correctly update the service file contents if the issue registry is
renamed etc.)
The service registration can contain more than one issue registry,
though there's usually no good reason for that, since a single issue
registry can provide multiple issues.
## IssueRegistry
Next we have the `IssueRegistry` linked from the service registration.
Lint will instantiate this class and ask it to provide a list of
issues. These are then merged with lint's other issues when lint
performs its analysis.
In its simplest form we'd only need to have the following code
in that file:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
package com.example.lint.checks
import com.android.tools.lint.client.api.IssueRegistry
class SampleIssueRegistry : IssueRegistry() {
override val issues = listOf(SampleCodeDetector.ISSUE)
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
However, we're also providing some additional metadata about these lint
checks, such as the `Vendor`, which contains information about the
author and (optionally) contact address or bug tracker information,
displayed to users when an incident is found.
We also provide some information about which version of lint's API the
check was compiled against, and the lowest version of the lint API that
this lint check has been tested with. (Note that the API versions are
not identical to the versions of lint itself; the idea and hope is that
the API may evolve at a slower pace than updates to lint delivering new
functionality).
## Detector
The `IssueRegistry` references the `SampleCodeDetector.ISSUE`,
so let's take a look at `SampleCodeDetector`:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin linenumbers
class SampleCodeDetector : Detector(), UastScanner {
// ...
companion object {
/**
* Issue describing the problem and pointing to the detector
* implementation.
*/
@JvmField
val ISSUE: Issue = Issue.create(
// ID: used in @SuppressLint warnings etc
id = "SampleId",
// Title -- shown in the IDE's preference dialog, as category headers in the
// Analysis results window, etc
briefDescription = "Lint Mentions",
// Full explanation of the issue; you can use some markdown markup such as
// `monospace`, *italic*, and **bold**.
explanation = """
This check highlights string literals in code which mentions the word `lint`.
Another paragraph here.
""",
category = Category.CORRECTNESS,
priority = 6,
severity = Severity.WARNING,
implementation = Implementation(
SampleCodeDetector::class.java,
Scope.JAVA_FILE_SCOPE
)
)
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The `Issue` registration is pretty self-explanatory, and the details
about issue registration are covered in the [basics](basics.md.html)
chapter. The excessive comments here are there to explain the sample,
and there are usually no comments in issue registration code like this.
Note how on line 29, the `Issue` registration names the `Detector`
class responsible for analyzing this issue: `SampleCodeDetector`. In
the above I deleted the body of that class; here it is now without the
issue registration at the end:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin linenumbers
package com.example.lint.checks
import com.android.tools.lint.client.api.UElementHandler
import com.android.tools.lint.detector.api.Category
import com.android.tools.lint.detector.api.Detector
import com.android.tools.lint.detector.api.Detector.UastScanner
import com.android.tools.lint.detector.api.Implementation
import com.android.tools.lint.detector.api.Issue
import com.android.tools.lint.detector.api.JavaContext
import com.android.tools.lint.detector.api.Scope
import com.android.tools.lint.detector.api.Severity
import org.jetbrains.uast.UElement
import org.jetbrains.uast.ULiteralExpression
import org.jetbrains.uast.evaluateString
class SampleCodeDetector : Detector(), UastScanner {
override fun getApplicableUastTypes(): List


 The same was with Nokia 1 Plus which looks gorgeous with the back cover in red, or the Nokia 3310 which also came in vivid colors. Now the latest member of the Nokia Original series, Nokia 2720 Flip is also announced in red color. Nokia Mobile just announced it over twitter, but the official availability is still not known.
The phone in red color is still not listed on the official Nokia web store, but the photos of the red version are uploaded on the international site. Maybe it will soon be coming officially in India, and hopefully other markets too.
How do you like the Nokia 2720 Flip in red?
Juho Sarvikas posted new photos of the 2720 Flip in red colour where you can see that it has the black cover made of shiny plastic.


--- layout: default section_id: about skills: - title: Web Design percent: 84 - title: Web Development percent: 95 - title: Site Management percent: 70 - title: Branding percent: 61 members: - name: Mark Wayne position: founder desc: consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat consectetuer sit. avatar<EMAIL_ADDRESS>socials: - icon_class: fa fa-twitter url: http://twitter.com - icon_class: fa fa-facebook url: http://facebook.com - name: Kate Holms position: Creative Director desc: consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat consectetuer sit. avatar<EMAIL_ADDRESS>socials: - icon_class: fa fa-twitter url: http://twitter.com - icon_class: fa fa-facebook url: http://facebook.com - icon_class: fa fa-dribbble url: http://dribbble.com - name: Tom Hason position: Designer desc: consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat consectetuer sit. avatar<EMAIL_ADDRESS>socials: - icon_class: fa fa-twitter url: http://twitter.com - icon_class: fa fa-facebook url: http://facebook.com - icon_class: fa fa-tumblr url: http://tumblr.com - name: Lily Whrem position: Developer desc: consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat consectetuer sit. avatar<EMAIL_ADDRESS>socials: - icon_class: fa fa-twitter url: http://twitter.com - icon_class: fa fa-facebook url: http://facebook.com clients: -<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>---
we want to tell your wedding story through compelling images that will blow your mind. We don't want to just give you photos, we want to give you works of art that transcend wedding photography, that communicates the essence of who you are, that tell stories beyond what you see.
Shooting weddings with a little twist of Fashion and drama gives a couple something unique to cherish


--- title: The Evidence Lower Bound (ELBO) and Variational Bayes layout: post date: 2019-11-17 18:41:00-0400 comments: true --- {% include mathjax-macros.html %}
This note aims at deriving the evidence lower bound (ELBO) and motivate it using a Bayesian inference perspective. Here we consider an observed variable \(y\) and seek to infer the distribution over latent variables \(z\) given \(y\). That is to say, we want to find the posterior distribution over the latent variables,
\[ p(x|y) = \frac{p(y,x)}{p(y)} = \frac{p(y,x)}{\int p(y|x)p(x)\dm x}. \]
In general we cannot compute this distribution, and so we need to turn towards other methods like Markov Chain Monte Carlo, Importance Sampling, Variational Bayes (VB), etc.
It is within VB that we find the ELBO is an essential mathematical expression that allows for approximating the posterior distribution \(q(x|y)\approx p(x|y)\). It has been used successfully in many applications and machine learning methods such as Variational autoencoders (VAEs) kingma2014autoencoding. For a more in-depth explanation of VB and also the ELBO I suggest looking into excellent the pattern recognition book by Bishop bishop2006a and the review paper on variational inference blei2017a.
We will derive the ELBO from an inference perspective, i.e. we want to approximate \(p(x|y)\) with \(q(x|y;\theta)\). Here we explicitly parameterized \(q\) with \(\theta\) and we shall assume the flexibility of \(q\) is precisely defined by \(\theta\). The objective then is to find \(\theta\) such that \(q(x|y;\theta)\approx p(x|y)\). This requires some mathematical expression which tells us how to find such a \(\theta\) and the ELBO is one such expression. We denote the ELBO as \(\gL\) and as we will see it takes the following form,
\begin{equation} \label{eq:elbo} \gL = \E_{q(x|y;\theta)}\br{\ln{\frac{p(x,y)}{q(x|y;\theta)}}}, \end{equation}and we shall see two different ways to derive that expression.
To measure closeness between \(q\) and \(p\) and consider the Kullback–Leibler (KL) divergence,
\begin{align*} \mr{KL}\br{q(x|y;\theta)|p(x|y)} &= -\int \ln{\frac{p(x|y)}{q(x|y;\theta)}} q(x|y;\theta)\dm x\\ & = -\br{ \int \ln{\frac{p(x,y)}{q(x|y;\theta)}} q(x|y;\theta)\dm x - \int \ln p(y) q(x|y;\theta)\dm x }\\ & = -\E_{q(x|y;\theta)}\br{\ln{\frac{p(x,y)}{q(x|y;\theta)}}} \dm x + \ln p(y), \end{align*}which we rearrange to,
\[ \ln p(y) = \mr{KL}\br{q(x|y;\theta)|p(x|y)} + \E_{q(x|y;\theta)}\br{\ln{\frac{p(x,y)}{q(x|y;\theta)}}} = \mr{KL}\br{q(x|y)|p_{\theta}(x|y)} + \gL. \]
Because the KL-divergence is non-negative we identify \(\ln p(y)\ge\gL\), making \(\gL\) a lower bound on the evidence \(p(y)\), hence the name.
As shown above there is a direct connection between the evidence \(p(y)\) and the ELBO \(\gL\) and we will here derive the expression of \(\gL\) directly from \(\ln p(y)\) using Jensen’s inequality,
\[ f(\E\br{x}) \le \E\br{f(x)}, \quad \text{for a convex function}~f, \] or \[ f(\E\br{x}) \ge \E\br{f(x)}, \quad \text{for a concave function}~f. \]
With this we can write,
\begin{align*} \ln p(y) &= \ln \int p(y|x)p(x) \dm x \\ &= \ln \int \frac{p(y,x)}{q(x|y;\theta)}q(x|y;\theta) \dm x \\ &\ge \E_{q(x|y;\theta)}\br{\ln\frac{p(y,x)}{q(x|y;\theta)}}, \end{align*}which is exactly the expression in \ref{eq:elbo}
The topics of VB and the ELBO, relates to a series of other topics some of which I will be making other notes about. Some of these topics include but is certainly not limited:
And much, much more.


--- layout: plainarticle permalink: '/elections/' title: Elections ---
The voting for this election has concluded.
Vote for the above candidates here. You can only vote once per registered user. If you don’t see the voting box at this point, you’ve probably voted already :)
Voting is open until Sunday, 26th Mar. 2017, 23:59 CEST.
If you encounter any issues, please contact<EMAIL_ADDRESS>The voting for this election has concluded.
Vote for the above candidates here. You can only vote once per registered user. If you don’t see the voting box at this point, you’ve probably voted already :)
Voting is open until Friday, 23rd Sept. 2016, 14:00.
If you encounter any issues, please contact<EMAIL_ADDRESS>Apply by email to<EMAIL_ADDRESS>The application needs to be in the form of a short (max. 3 mins) video clip, explaining your motivation to run, and what ideas you bring to the table (please, do not send the video as an attachment but rather as a Google Drive shared link or any other file-sharing service you prefer to use). It can be accompanied by a max. 1 A4 page document that would help alumni better understand your background (similar to a resume). In addition, you can provide your LinkedIn and/or Xing profile link.
NOTE: Your video WILL be cut at 3 minutes if you record beyond this limit!
If you have any further questions on the role, the Alumni Board or the Association, please do not hesitate to get in touch with us via apply@jacobs-alumni.de.


Interactive Tools
and Stories
Editing Interactive Stories
How We Got Started
Video
Photography
Graphics
Games
Audio
Behind the Scenes
">
Our First Interactive Stories
">


You need to enable JavaScript to run this app.
Current game:
Replay
% Mined:
Rows:
Columns:
Count down:
Cell size:
x1
x2
x3
x4
x5
New game:
Create
% Mined:
Rows:
Fit screen
Columns:
Fit screen


Elevators make sectors and walls dynamic. They can obviously be used to create lifts, platforms, doors etc., but you often also need dummy (i.e. non-accessible) elevators for level control purposes.
Elevators will usually have stops, which are different values the elevator can arrive at.
Elevators may also have slaves copying their actions.


| 1.1 |
Geographical area of West Bengal by District |
|
|
| 1.2 |
Administrative Divisions of the State of West Bengal-2015 |
|
|
| 1.3 |
Population and Density of Population Per Square Kilometer by District in West Bengal |
|
|
| 1.4 |
Decadal Variation of Population by District |
|
|
| 1.5 |
Rural and Urban Population by District in West Bengal |
|
|
| 1.6 |
Population by Sex and by District in West Bengal |
|
|
| 1.7 |
Population of Urban Agglomerations in West Bengal (As per Census 2011) |
|
|
| 1.8 |
Cities and Towns (with population one lakh and above) Classified by Population, 2011 |
|
|
| 1.9 |
Scheduled Castes and Scheduled Tribes Population by Sex and by District, 2011 |
|
|
| 1.10 |
Population by Age-Group, Sex and District in West Bengal, 2001 |
|
|
| 1.10a |
Population by Age-Group, Sex and District in West Bengal, 2011 |
|
|
| 1.11 |
Population by Religion, Sex and District in West Bengal |
|
|
| 1.12 |
Distribution of Population by Major Schedule Languages, 1991 |
|
|
| 1.13 |
Population by Age-Group, Sex and Civil Condition, 2011 |
|
|


{% extends 'layout.html' %} {% block pageTitle %} Conduct inclusive research - Inclusive and equitable NHS services {% endblock %} {% block beforeContent %} {{ breadcrumb({ items: [ { href: "/index", text: "Home" }, { href: "/things-to-do/conduct-inclusive-research", text: "Conduct inclusive user research" } ] }) }} {% endblock %} {% block content %}
Be aware of users' challenges and assistive technology they may be using. Make sure the way you recruit participants is as inclusive as possible. Test with a diverse pool of people from all backgrounds and lived experiences.
We tested the NHS website’s chickenpox page with people who have a range of skin tones. We also tested it with people with different access needs including users with a visual impairment, dyslexia, cerebral palsy and a neurological disorder.
When you introduce yourself, tell the person your pronouns. This normalises asking for pronouns, and allows everyone to express how they would like to be addressed. Never assume someone’s pronouns.
Where you might be asking someone to view non-inclusive content, it’s beneficial to give people trigger warnings. This can be as simple as a verbal warning like “We’re going to show you a page on breastfeeding now, which might be triggering. If at any point you need to leave or stop, please do so.” It is important to do this because:
[add more]
[add more]
[add more]
Ensure that tasks and scenarios are kept as short as possible, without compromising on clarity. Present these to the participants and read through the tasks and scenarios with them. This will make it easier for people with dyslexia and attention deficits to follow.
Where appropriate, provide visual rather than/in addition to written instructions. This will make it easier for participants with dyslexia, and learning and communication difficulties to follow.
It is common within UX research to ask participants to imagine that they are a fictional person (e.g. “Imagine you’re Chris, you’re 57 years old and you’d like to fly to Malta with your partner, Skye, on 3 December”). These abstract concepts can be difficult for people with certain cognitive impairments to grasp, so it’s preferable to allow them to complete tasks and scenarios as themselves.
Some of this user group may become easily overwhelmed or find it difficult to remember large chunks of information. It is therefore important to reduce the cognitive load for participants by splitting up tasks and questions into smaller, more manageable chunks.
People with certain cognitive impairments, like learning difficulties, may struggle to understand how to provide a rating that is truly indicative of their opinion. However, rating scales can be used as a conversation point with these participants, instead of relying on just the number they answer with. Always asks participants why they gave that number so that they are prompted to discuss their opinions and thoughts further.
Activities might involve hands on activities, such as cutting out pictures or text and creating collages, or making drawings. These tasks may involve fine motor skills which are difficult to complete for users with motor impairments. It’s therefore important to ensure that there are alternative activities which are also accessible to those who do not have fine motor controls.
For participants with a severe mobility impairment, for example, someone who uses an eye tracker to interact and communicate with others, it may be preferable to rely more heavily on observational data. It’s therefore important to have clear tasks with clear indicators of success at the end of tasks, so that you can easily evaluate whether the tasks were completed successfully, based on observations alone.
Usually, as user researchers, we like to ask lots of open questions. For participants who are non-verbal and rely on a communication device it can make the research more comfortable for the participant if you do not rely on them giving you lengthy answers but instead rely more on observational data and ask more closed questions. This is not to say that you shouldn’t ask any open questions, but that you may have to adjust the balance of the two.
Have instructions written down so that participants can read them instead of you talking to them and them using an interpreter or lipreading. This will be down to personal preference of the participant, however, sometimes reading will take less energy and will be easier for them.
When talking to someone with an auditory impairment, the following steps will make it easier for them to lip read and understand you:
Some deaf people will have an interpreter with them. Although they will be helping you to communicate with the participant, it is best practice (and polite) to speak directly to the participant, not to their interpreter.
Deaf people who may ordinarily be OK with lip reading may struggle with this more in a remote research session. It’s therefore best practice to offer subtitles (ideally provided by a panel typist) during a research session.
Allow users to set their screen reader to the speed they usually would use it at home: this will encourage them to engage naturally with the website or app. However, some advanced screen reader users may use their screen reader at such a speed that it is difficult to know what they are doing or what the screen reader announces.
To get around this, when they discover an issue or if the user becomes confused, ask them to explain the issue and what keys they pressed. If needed, also ask them to slow the screen reader down and show you the issue, so that you can understand what was announced and what happened.
When an issue is identified, as much as possible, record what keystrokes screen reader participants are using to interact with your product. That way you can understand how users are trying to interact with the website, and how they expect it to behave.
As a researcher, you may sometimes need to guide blind participants. Best practice is to offer them your elbow for them to hold on to, and to make sure you tell them where you’re going and where things are (e.g. “we’re going through a door; the chair is to your right”).
Some blind people may have a guide dog, it is therefore important to ensure that the research space is large enough for them too. It is also good to have a water bowl for the guide dog in the room.
If you’re using visual cues (e.g. rating scales) make sure you print them off in large print for those with low vision. For blind participants, make sure that you’re not asking them to remember too much information. For example, with rating scales, don’t tell them what each number stands for (e.g. somewhat/strongly agree/disagree) just tell them what number 1 and number 5 stand for and ask them to pick one in between.
When asking users to do things like annotate print outs using different coloured pens, or placing different coloured stickers on print outs, be aware that not all users can perceive colour. Try to use other markers as well as colour. For example, if using stickers, try to find stickers which aren’t only a different colour but also a different shape. If you have any documents which you would like participants to read, make sure information isn’t conveyed using colour alone.
HTML prototypes can be easily tested with screenreader users. Using tools like Figma and Invision is inherently exclusive because they don’t work with screenreaders.
Send information and consent forms ahead of the session, so participants have time to review, process information and clarify any concerns/uncertainties. Alternatively, read through the consent form at the start of the session and get their verbal consent (don’t forget to record this).
Sometimes it may be more beneficial to go to a place that’s more convenient for the person you’re researching with, such as their home, or place of work or learning. This way they can be more able to use their own equipment and software and you can get a much better idea of how they would use things in daily life.
Build extra time into the research session to allow for any technical setup, and the extra time it will take for you to build rapport and make sure you understand the participant’s experience.
If using a recruiter, be as specific as possible about the types of participants you want and make sure you’re happy with the screener they’re going to use. Some common pitfalls:


Customer
Customer IP address
{{item.customer_ip}}
Order subtotal
${{finalTotal | number:'2.2-2'}} excl tax
Order shipping
${{item.order_shipping_excl_tax | number:'2.2-2'}} excl tax
Order tax
${{item.order_tax | number:'2.2-2'}}
Order total
${{finalTotal | number:'2.2-2'}}
Refunded amount
${{item.refunded_amount | number:'2.2-2'}}
Payment method
{{item.payment_method_system_name}}
Profit
${{profitTotal | number:'2.2-2'}}


Zabit reveals infection entering UFC Moscow; says he ‘fully’ deserves next title shot
by Milan OrdoñezSince he entered the UFC in 2017, Zabit Magomedsharipov proved himself to be a legitimate contender at 145 pounds. After six fights and four post-fight bonuses, he now feels he is ready for a crack at the title.
Speaking through a translator in a post-fight interview with ESPN, Zabit expressed excitement and interest towards the upcoming featherweight title fight between Max Holloway and Alexander Volkanovski at UFC 245 this December.
“I think it is going to be a very exciting fight; I can’t wait to see it,” Magomedsharipov said (via MMA Fighting). “I will also be happy to face the winner of this upcoming fight.
“I think I fully deserve the title fight and after enough preparation, I should be more than ready to have a go at the title.”
Zabit fought through a scrappy three-round battle against Calvin Kattar at UFC Moscow on Saturday, earning him a unanimous decision victory. But apparently, he labored through the final round, battling the effects of an infection he caught while training in Asia.
“I knew he was a tough guy,” he said of Kattar. “We didn’t expect him to block so much, so I had to kick him in the legs. This is what was different from our expectations.
“I got a little tired in the third round because I had an infection when I was in Thailand,” he revealed. “I have to take antibiotics, so I think that influenced my performance.”
Zabit is now on a 14-fight win streak he began in 2013. He currently holds a record of 18-1 (with 13 wins by stoppage). He also won $50,000 for Fight of the Night honors.


 It is the simplest and the easyest way understand what it realy feels like to juggle. Althought it is where people start it in not mean to say that it is simple. Far from it, there are so many things that people can do with balls it is spactacual. Some people start learing cool tricks and minipulartion of the ball. Others go strait to number juggling. People commenly go for juglging 5 balls, but some people are even know to go up to 11 balls!
 If you have them already then you can skip right to step two.
- Before one can get in to the nitty griry of learning to juggling, one has to exept a single fact.  When you are ready hold two in the right hand and one in the left (reverced for leftys). Then throw then up and make absolutly no effort to chatch them. Listen to the sound they make when the hit the floor. Enjoy that sound. It will soon be a very commen sound to your ears. If you have not compleatly understood this, feel free to reapeat this as many times as nessesary until you feel comfterable with this.
- This step is probobly the most improtant step and the one that very few people spend enough time on. Althought it sound very simple, if not mastered everthing else will take much longer to learn. You will need to learn to throw one ball from hand to hand. Start with the ball in one hand, does not matter which. You will want to be able to throw it at about eye level hight to the other hand. You want to make sure that you are not chasing the ball around. Until you learn to thorw one ball their is not way you can learn to juggle three objects.
- After being able to constistently throw one ball back and forth at a consistent hight, you are ready for two balls. Start with one ball in each hand, with the right hand you, throw one ball to the other hand at eye level. When that ball gets to the top of its ark, throw the one from the left hand to the right. Then do the same thing but starting with the left hand. Repeat this until it feels very comfterable. Remember, getting down the beggining steps solid will make everything down the line easier.
- Next we have what is called the snake.  (Dont worry we will get to both hands.)  You want to make sure that the second ball leaves your hand before the first ball gets to the other hand. You will want to do this with the same hand several times before starting with the other hand. Once you feel comfterable with doing it from both hand you will want to start chaining this prosses.  Do the same to the second ball. It will almost feel as if one ball is chasing the other.
- Now it is time to get that third ball that you have a put it to use. You are already know how to juggle three balls, we just did it one side at time. Hold two balls in one hand and one in the other. Throw the ball in the hand that has two to the other hand. As it reaches the peek of its flight throw the ball in the other hand. It is like an exchange. As the second ball you threw gets to its peek, throw the third ball. There you go! You are now juggling! Just keep practicing that until your feel compleatly comfterable with that. Then, go explore all the other tricks in juggling. Remember, just have fun.


Initialization
Commit
Branch
Difference Viewer
Merge
Difference Viewer
Select two branches to view the difference between them.
previously
created
branches
previously
created
branches


Conftools
created by
lightyoruichi
Most Tweets
more stats
twitterslurp tweets
(Searching on
twitterslurp
)
stop
start
more


ContainerConfig class
Container configuration defined as a list of component configurations.
See [ComponentConfig]
- Inheritance
- Object
- ListBase<
ComponentConfig> - ContainerConfig
Constructors
-
ContainerConfig([List<
ComponentConfig> components ]) - Creates a new instance of container configuration. [...]
Properties
- length ↔ int
-
Returns the number of objects in this list. [...]
read / write, override
- first ↔ ComponentConfig
-
Returns the first element. [...]
read / write, inherited
- hashCode → int
-
The hash code for this object. [...]
read-only, inherited
- isEmpty → bool
-
Returns
true
if there are no elements in this collection. [...]read-only, inherited - isNotEmpty → bool
-
Returns true if there is at least one element in this collection. [...]
read-only, inherited
-
iterator
→ Iterator<
ComponentConfig> -
Returns a new
Iterator
that allows iterating the elements of thisIterable
. [...]read-only, inherited - last ↔ ComponentConfig
-
Returns the last element. [...]
read / write, inherited
-
reversed
→ Iterable<
ComponentConfig> -
Returns an
Iterable
of the objects in this list in reverse order.read-only, inherited - runtimeType → Type
-
A representation of the runtime type of the object.
read-only, inherited
- single → ComponentConfig
-
Checks that this iterable has only one element, and returns that element. [...]
read-only, inherited
Methods
-
add(
ComponentConfig element) → void -
Adds
value
to the end of this list, extending the length by one. [...]inherited -
addAll(
Iterable< ComponentConfig> iterable) → void -
Appends all objects of
iterable
to the end of this list. [...]inherited -
any(
bool test(ComponentConfig element)) → bool -
Checks whether any element of this iterable satisfies
test
. [...]inherited -
asMap(
) → Map< int, ComponentConfig> -
Returns an unmodifiable
Map
view ofthis
. [...]inherited -
cast<
R> () → List< R> -
Returns a view of this list as a list of
R
instances. [...]inherited -
clear(
) → void -
Removes all objects from this list;
the length of the list becomes zero. [...]
inherited
-
contains(
Object element) → bool -
Returns true if the collection contains an element equal to
element
. [...]inherited -
elementAt(
int index) → ComponentConfig -
Returns the
index
th element. [...]inherited -
every(
bool test(ComponentConfig element)) → bool -
Checks whether every element of this iterable satisfies
test
. [...]inherited -
expand<
T> (Iterable< T> f(ComponentConfig element)) → Iterable<T> -
Expands each element of this
Iterable
into zero or more elements. [...]inherited -
fillRange(
int start, [ int end, [ ComponentConfig fill ]) → void -
Sets the objects in the range
start
inclusive toend
exclusive to the givenfillValue
. [...]inherited -
firstWhere(
bool test(ComponentConfig element), { ComponentConfig orElse() }) → ComponentConfig -
Returns the first element that satisfies the given predicate
test
. [...]inherited -
fold<
T> (T initialValue, T combine(T previousValue, ComponentConfig element)) → T -
Reduces a collection to a single value by iteratively combining each
element of the collection with an existing value [...]
inherited
-
followedBy(
Iterable< ComponentConfig> other) → Iterable<ComponentConfig> -
Returns the lazy concatentation of this iterable and
other
. [...]inherited -
forEach(
void action(ComponentConfig element)) → void -
Applies the function
f
to each element of this collection in iteration order.inherited -
getRange(
int start int end) → Iterable< ComponentConfig> -
Returns an
Iterable
that iterates over the objects in the rangestart
inclusive toend
exclusive. [...]inherited -
indexOf(
Object element, [ int start = 0 ]) → int -
Returns the first index of
element
in this list. [...]inherited -
indexWhere(
bool test(ComponentConfig element), [ int start = 0 ]) → int -
Returns the first index in the list that satisfies the provided
test
. [...]inherited -
insert(
int index, ComponentConfig element) → void -
Inserts the object at position
index
in this list. [...]inherited -
insertAll(
int index, Iterable< ComponentConfig> iterable) → void -
Inserts all objects of
iterable
at positionindex
in this list. [...]inherited -
join(
[String separator = "" ]) → String -
Converts each element to a
String
and concatenates the strings. [...]inherited -
lastIndexOf(
Object element, [ int start ]) → int -
Returns the last index of
element
in this list. [...]inherited -
lastIndexWhere(
bool test(ComponentConfig element), [ int start ]) → int -
Returns the last index in the list that satisfies the provided
test
. [...]inherited -
lastWhere(
bool test(ComponentConfig element), { ComponentConfig orElse() }) → ComponentConfig -
Returns the last element that satisfies the given predicate
test
. [...]inherited -
map<
T> (T f(ComponentConfig element)) → Iterable< T> -
Returns a new lazy
Iterable
with elements that are created by callingf
on each element of thisIterable
in iteration order. [...]inherited -
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a non-existent method or property is accessed. [...]
inherited
-
reduce(
ComponentConfig combine(ComponentConfig previousValue ComponentConfig element)) → ComponentConfig -
Reduces a collection to a single value by iteratively combining elements
of the collection using the provided function. [...]
inherited
-
remove(
Object element) → bool -
Removes the first occurrence of
value
from this list. [...]inherited -
removeAt(
int index) → ComponentConfig -
Removes the object at position
index
from this list. [...]inherited -
removeLast(
) → ComponentConfig -
Pops and returns the last object in this list. [...]
inherited
-
removeRange(
int start int end) → void -
Removes the objects in the range
start
inclusive toend
exclusive. [...]inherited -
removeWhere(
bool test(ComponentConfig element)) → void -
Removes all objects from this list that satisfy
test
. [...]inherited -
replaceRange(
int start, int end, Iterable< ComponentConfig> newContents) → void -
Removes the objects in the range
start
inclusive toend
exclusive and inserts the contents ofreplacement
in its place. [...]inherited -
retainWhere(
bool test(ComponentConfig element)) → void -
Removes all objects from this list that fail to satisfy
test
. [...]inherited -
setAll(
int index, Iterable< ComponentConfig> iterable) → void -
Overwrites objects of
this
with the objects ofiterable
, starting at positionindex
in this list. [...]inherited -
setRange(
int start, int end, Iterable< ComponentConfig> iterable, [ int skipCount = 0 ]) → void -
Copies the objects of
iterable
, skippingskipCount
objects first, into the rangestart
, inclusive, toend
, exclusive, of the list. [...]inherited -
shuffle(
[Random random ]) → void -
Shuffles the elements of this list randomly.
inherited
-
singleWhere(
bool test(ComponentConfig element), { ComponentConfig orElse() }) → ComponentConfig -
Returns the single element that satisfies
test
. [...]inherited -
skip(
int count) → Iterable< ComponentConfig> -
Returns an
Iterable
that provides all but the firstcount
elements. [...]inherited -
skipWhile(
bool test(ComponentConfig element)) → Iterable< ComponentConfig> -
Returns an
Iterable
that skips leading elements whiletest
is satisfied. [...]inherited -
sort(
[int compare(ComponentConfig a ComponentConfig b) ]) → void -
Sorts this list according to the order specified by the
compare
function. [...]inherited -
sublist(
int start, [ int end ]) → List< ComponentConfig> -
Returns a new list containing the elements between
start
andend
. [...]inherited -
take(
int count) → Iterable< ComponentConfig> -
Returns a lazy iterable of the
count
first elements of this iterable. [...]inherited -
takeWhile(
bool test(ComponentConfig element)) → Iterable< ComponentConfig> -
Returns a lazy iterable of the leading elements satisfying
test
. [...]inherited -
toList(
{bool growable: true }) → List< ComponentConfig> -
Creates a
List
containing the elements of thisIterable
. [...]inherited -
toSet(
) → Set< ComponentConfig> -
Creates a
Set
containing the same elements as this iterable. [...]inherited -
toString(
) → String -
Returns a string representation of this object.
inherited
-
where(
bool test(ComponentConfig element)) → Iterable< ComponentConfig> -
Returns a new lazy
Iterable
with all elements that satisfy the predicatetest
. [...]inherited -
whereType<
T> () → Iterable< T> -
Returns a new lazy
Iterable
with all elements that have typeT
. [...]inherited
Operators
-
operator [](
int index) → ComponentConfig -
Returns the object at the given
index
in the list or throws aRangeError
ifindex
is out of bounds.override -
operator []=(
int index, ComponentConfig value) → void -
Sets the value at the given
index
in the list tovalue
or throws aRangeError
ifindex
is out of bounds.override -
operator +(
List< ComponentConfig> other) → List<ComponentConfig> -
Returns the concatenation of this list and
other
. [...]inherited -
operator ==(
dynamic other) → bool -
The equality operator. [...]
inherited
Static Methods
-
fromConfig(
ConfigParams config) → ContainerConfig - Creates a new ContainerConfig object based on configuration parameters. Each section in the configuration parameters is converted into a component configuration. [...]
-
fromValue(
dynamic value) → ContainerConfig - Creates a new ContainerConfig object filled with key-value pairs from specified object. The value is converted into ConfigParams object which is used to create the object. [...]


Lil Nas X Knows You Think He Dressed like a Jojo Character for the AMAs
by Jacoby BancroftThe American Music Awards aired Sunday night, and although artist Lil Nas X won for Favorite Rap/Hip-Hop Song for his hit "Old Town Road (Remix)," it was his bold, bright fashion choice that has most people talking.
With a lime green tuxedo and a zebra-print top with matching green gloves, it wasn't long before Twitter users started drawing comparisons between Lil Nas X's outfit and JoJo's Bizarre Adventure, the popular anime series with a very distinct color palette and style.
The feedback got to the point where Lil Nas X even had to set the record straight himself, asking people to please stop in their comparisons to certain JoJo's Bizarre Adventure characters.
This isn't the first time Lil Nas X has turned heads with his fashion choices, as the artist has become known for his eclectic taste in fashion. However, his most recent look has already brought with it its own series of fan art and drawings.
JoJo's Bizarre Adventure follows the strange and wacky adventures of the Joestar family across multiple generations. The most recent anime adaptation started in 2012 and has aired four seasons.
Lil Nas X only won one award at the AMAs, but he was nominated for a slew of other categories, including Favorite New Artist, Favorite Song Pop/Rock, Favorite Video and Favorite Collaboration.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2Anime Newshttps://www.cbr.com/category/anime-news/ListItem3Lil Nas X Knows You Think He Dressed like a Jojo Character for the AMAshttps://www.cbr.com/lil-nas-x-jojos-bizarre-adventure/


Team Roster
Bear
Role: Manager
Employee ID: 555
Email<EMAIL_ADDRESS>Office Number: 555-5555
Sarah
Role: Engineer
Employee ID: 232
Email<EMAIL_ADDRESS>Github: sarahcool
Dave
Role: Intern
Employee ID: 999
Email<EMAIL_ADDRESS>School: OSU


[Gecode] int/count
Christian Schulte
schulte at imit.kth.se
Thu Nov 20 11:15:12 CET 2003
This is definitely handwritten and as said I see currently no need to change
it in any way.
While I do appreciate your enthusiasm I think that you should not try to do
structural changes to Gecode at your current level of expertise on your own.
It might be a good idea to seek discussion first.
Christian
--
Christian Schulte, http://www.imit.kth.se/~schulte/
> -----Original Message-----
> From: gecode-bounces at ps.uni-sb.de
> [mailto:gecode-bounces at ps.uni-sb.de] On Behalf Of Gabor Szokoli
> Sent: Tuesday, November 18, 2003 16:55
> To: gecode at ps.uni-sb.de
> Subject: [Gecode] int/count
>
>
> Hi!
>
> Is all that source code in int/count handwritten or
> generated? (I'd hate
> to waste effort modifying it only to be overwritten when
> re-generated...)
>
> Gabor
> _______________________________________________
> Gecode mailing list
> Gecode at ps.uni-sb.de http://www.ps.uni-sb.de/mailman/listinfo/gecode
>
More information about the gecode-users
mailing list


The exterior panels show the world during creation, probably on the Third Day, after the addition of plant life but before the appearance of animals and humans.
When the triptych’s wings are closed, the design of the outer panels becomes visible. Rendered in a green–gray grisaille, these panels lack colour, probably because most Netherlandish triptychs were thus painted, but possibly indicating that the painting reflects a time before the creation of the sun and moon, which were formed, according to Christian theology, to “give light to the earth”. It was common for the outer panels of Netherlandish altarpieces to be in grisaille, such that their blandness highlighted the splendid colour inside.
The outer panels are generally thought to depict the creation of the world, showing greenery beginning to clothe the still-pristine Earth. God, wearing a crown similar to a papal tiara (a common convention in Netherlandish painting), is visible as a tiny figure at the upper left. Bosch shows God as the father sitting with a Bible on his lap, creating the Earth in a passive manner by divine fiat. Above him is inscribed a quote from Psalm 33 reading “Ipse dixit, et facta sunt: ipse mandāvit, et creāta sunt”—For he spake and it was done; he commanded, and it stood fast. The Earth is encapsulated in a transparent sphere recalling the traditional depiction of the created world as a crystal sphere held by God or Christ. It hangs suspended in the cosmos, which is shown as an impermeable darkness, whose only other inhabitant is God himself.
Despite the presence of vegetation, the earth does not yet contain human or animal life, indicating that the scene represents the events of the biblical Third Day. Bosch renders the plant life in an unusual fashion, using uniformly gray tints which make it difficult to determine whether the subjects are purely vegetable or perhaps include some mineral formations. Surrounding the interior of the globe is the sea, partially illuminated by beams of light shining through clouds. The exterior wings have a clear position within the sequential narrative of the work as a whole. They show an unpopulated earth composed solely of rock and plants, contrasting sharply with the inner central panel which contains a paradise teeming with lustful humanity.


Cookbook for Keck/LRIS Reductions
BACK
This page describes the types of calibrations recommended
(or required) to use the Low-Redux pipeline to reduce data
acquired with the longslit Kast spectrometer.
Calibrations:
AFTERNOON+TWILIGHT: The following table summarizes the recommended calibration
exposures for the grisms+gratings supported within the Low-Redux pipeline.
Binning: For the blue-side observations, we
present values assuming binning 2x2 (spatialxspectral). We recommend
this level of binning when using the 1200 grism to reduce the readnoise
by a factor of sqrt(4)=2. For a 1" slit, binning by 2 in the spectral
dimension implies a sample of 4 pixels.
The spatial plate-scale on the blue-side is 0.135" per native pixel.
Therefore, 2x binning will lead to Nyquist sampled seeing only for
FWHM ~ 0.6".
Flat fielding: Our approach for flat fielding these
spectroscopic observations is to divide up the flat fielding
into a pixel-flat which represents the intrinsic pixel-to-pixel
response variations of the CCD (i.e. the
response to a smooth source), and an illumination flat,
which represents the larger scale illumination variations due
to non-uniformities in the width of the slit, vignetting, etc.
This separation is clearly not perfect, but our experience is
that the illumination flats significantly improve sky subtraction.
The pixel-flat for the blue-side is constructed in a novel manner
for the high resolution grisms.
One observes the twilight sky
with the grism in place but without a slitmask (i.e. "direct").
This smears the solar spectral features sufficiently that the
flat can be properly normalized before applying a
pixel-to-pixel correction. We use the twilight sky because
the internal and dome lamps both emit too little UV light.
Although one might record a few thousand counts with these lamps,
we have confirmed that this is dominated by scattered red
light (e.g. one observes fringing!).
For the red side, dome flats are better than internal flats for
correcting the pixel-to-pixel variations because they reduce the
level of scattered light. However, one may desire to take internal
flats on the sky during the night (or twilight) to remove fringing.
The same dome flats can be used for the illumination correction
although observations at twilight may be preferable.
| Blue Side Calibrations (2x2 Binning) |
| Type |
Grism |
Lamp(s) |
Slit |
Exp |
NExp |
Notes |
| Arc |
Any |
All |
1" |
3 |
2 |
IMPORTANT: One should wait ~5min for the Zn+Cd lamps to warm up.
|
| Illum+PixelFlat |
300/5000 |
Twilight |
1" |
10 |
5 |
Keep peak under 40,000 DN. This set of exposures is
used for both pixel-to-pixel and illumination calibration.
WARNING: This procedure is not well tested. |
| IllumFlat |
600/4000 |
Twilight |
1" |
XX |
3 |
Take very near sunset (or sunrise).
Aim for peak counts of ~30,000 DN |
| IllumFlat |
1200/3400 |
Twilight |
1" |
XX |
3 |
Take very near sunset (or sunrise).
Aim for peak counts of ~30,000 DN |
| PixelFlat |
600/4000 |
Twilight |
None! |
XX |
3 |
Slitless. Take very near sunset (or sunrise).
Aim for peak counts of ~30,000 DN |
| PixelFlat |
1200/3400 |
Twilight |
None! |
XX |
3 |
Slitless. Take very near sunset (or sunrise).
Aim for peak counts of ~30,000 DN |
| Red Side Calibrations (1x1 Binning) |
| Type |
Grating |
Lamp(s) |
Slit |
Exp |
NExp |
Notes |
| Arc |
Any |
All |
1" |
1s |
2 |
|
| Illum+PixelFlat |
300/7500 |
Dome/Spec |
1" |
8 |
7 |
Keep peak under 40,000 DN. This set of exposures is also
fine for pixel-to-pixel calibration. |
| Illum+PixelFlat |
600/7500 |
Dome/Spec |
1" |
30 |
7 |
Keep peak under 40,000 DN. This set of exposures is also
fine for pixel-to-pixel calibration. |
| Illum+PixelFlat |
600/10000 |
Dome/Spec |
1" |
240 |
7 |
Keep peak under 40,000 DN. This set of exposures is also
fine for pixel-to-pixel calibration. |
| Illum+PixelFlat |
1200/7500 |
Dome/Spec |
1" |
50 |
7 |
Keep peak under 40,000 DN. This set of exposures is also
fine for pixel-to-pixel calibration. |
TWILIGHT+NIGHTTIME: In addition to these calibrations, if one wishes to flux the
spectra it is necessary to observe a spectrophotometric standard
with the same instrument configuration. Furthermore, it is
best if one chooses from the CALSPEC list of standards which can
be found here: $XIDL_DIR/Spec/Longslit/calib/standards/calspec
Organizing the Data
The first steps are to organize your data, create a plan file,
and edit it as necessary.
- Organize the data
- Create a 'Raw' directory -- mkdir Raw
- Place all of the Raw frames in the Raw directory
- gzip the files (optional)
- Create the plan file
- Launch IDL from above the Raw directory
- Run long_plan :: This
code parses the headers of each raw file and creates an ASCII file
which summarizes the data. It attempts to guess the 'type' of
each frame (e.g. arc, domeflat, science).
Example: IDL> long_plan, '*.fits*', 'Raw/'
- Edit the plan file (default: plan.par)
- Consider copying plan.par to a new file
- For longslit observations, 'slitthresh' is automatically
set in the code to be 0.10. For multislit observations you may
specify your own value of 'slitthresh' by including this parameter
in the plan file. The default for multislit observations is
currently 0.02. For short slits, lower 'slitthresh' as necessary.
- Edit 'maxobj' as needed. This sets the maximum number of
objects found per slit. For multislit observations, change to 2
to prevent lots of spurious objects from begin found.
- Edit 'reduxthresh' as needed. This is another parameter which is useful for controlling the identification of spurious objects. The code will only keep objects as bright as (reduxthresh)*(brightness of brightest object) in each slit.
- Remove unwanted images from the .par file.
- Inspect and edit the image types for the various exposures. (Listed in column 3 in the plan file)
For the LRIS spectrometer there are 5 types of interest:
| Type |
Description |
| arc |
Exposure of the arc lamps taken with the instrument
configured for spectroscopy (slit + dispersing elements).
|
| domeflat |
Flats used to calibrate the pixel-to-pixel variations
in the CCD. Blue side: At high dispersion (600 or 1200 grism), one
should observe the twilight sky without a slit. This is the only means
of getting enough blue counts in a spectrum that does not have sharp
features. At lower dispersion (300 grism), one can acquire a dome flat.
Red Side: One obtains 'standard' dome flats.
Note: The code currently attempts to distinguish between domeflats and twilight flats by considering the time the exposures were taken and the position of the dome slit relative to the pointing. There is no header keyword that specifies the dome lamps being on or off. Therefore, pay extra attention to these files to make sure they are labelled correctly.
|
| twiflat |
Flats used to calibrate the larger scale variations
(i.e. greater than 5 pixels) in the illumination pattern of the CCD.
Spectrum of the twilight sky through the longslit or slitmask.
|
| iflat |
Flats used to calibrate the pixel-to-pixel variations in the CCD. Domeflats are always preferred to minimize scattered light, but internal flats can be used if necessary.
|
| bothflat |
If the user specifies this designation,
the flat image will used for both pixel and illumionation corrections
(i.e. it will be treated as a domeflat and a twiflat simultaneously).
This is useful in cases where twiflats were not taken and the user
wishes to make an illumination correction. One should ALWAYS use this
option when reducing red side data taken with the 600/7500 grating--
replace 'domeflat' with 'bothflat' in the plan file.
|
| science |
Spectrum of an astronomical object.
This includes 'standard stars'.
|
| std |
If the user specifies this designation,
this frame will be used as a crutch for tracing other objects.
The frame should be reduced BEFORE it is included as a crutch.
|
- Insure that the necessary calibration files exist.
Files of 'arc' type are always needed. In addition, it is
ideal to have both domeflat (or iflat) and twiflat files for each
grating/grism/slit combination; this gives the best calibration of
pixel-to-pixel variations in the CCD and illumination function.
One exception is in the case of Red Side 600/7500 data-- here only
the domeflat should be used, and the label should be changed to
'bothflat'. Additionally, in general if only domeflats are available, these may be used for both the pixel-to-pixel calibs and the illumination calibs by changing the 'domeflat' type to 'bothflat' in the plan file.
Reduce!
All of the reduction steps are run by the code
long_reduce
Example: IDL> long_reduce, 'plan.par'
This routine:
- Stacks and process the flats
- Identifies the edges of the longslit
- Calibrates the various arc images
- Processes the science frame (flattens)
- Finds/traces objcets within the slit
- Extracts using a non-parameteric optimal extraction algorithm
The correct sequence for setting up the reductions is as follows:
- The blue-side calibration takes a bit more work than the red side.
- First you need to make a separate .par file that includes all images of the sky without a slit mask (name this file slitless.par).
- Edit the image types of these observations to all be "domeflat"
- Run long_reduce with your slitless.par file
- In your plan.par file insure that you include one of the files that you used in your slitless.par file, again insuring that its image type is changed to "domeflat".
- Run long_reduce with your plan.par file. Be sure to include your twilight flats that were taken with the slit in labelled as "twiflat".
- The Redside is much simpler, you only need to use the dome flats. Be sure to change the file types in your plan.par file to "bothflat"
The pipeline outputs the following calibration files:
| Name |
Description |
| pixflat-xxx |
FITS file generated from the domeflats which corrects for
pixel-to-pixel variations in the CCD.
|
| illumflat-xxx |
Flat frame used to correct for imperfections in the slit
width along the slit-length.
|
| profile-xxx |
Binary FITS table containing the object profile used
for optimal extraction. In particular, the tag .profile contains an
image of the profile.
|
| slits-xxx |
Binary FITS table containing the parameters which
describe the slit edges.
|
| wave-xxx.fits |
FITS image of the wavelength array created by the code.
|
| wave-xxx.ps |
Postscript file showing the results from the 1D arc
solution.
|
Tip: If you have longslit science frames with no bright objects in the
slit AND if you have standard star data, it is a good idea to re-run
long_reduce after deleting the science frames and keeping the reduced
standard frames. You can also do this if you are working with
multislit data. Re-run like this:
Example: IDL> long_reduce, 'plan.par', filestd='Science/std-lred0044.fits.gz'
This will use the standard star frames as a first guess at the trace when extracting faint objects from your science data.
IMPORTANT: Check the reduction.
Check the reduction as the pipeline progresses.
- As soon as the slits-XXX file is produced, check the following:
- Were all the slits found? If not, the code may have combined
two slits into one, for example. This can cause many problems
(e.g., a wavelength solution failure). To discourage the code
from doing this, you can reduce the 'slitthresh' parameter
in the plan file; the default value for multislit masks is 0.02.
- If one particular slit is causing trouble that cannot be
fixed by changing slitthresh, you can use the code
'long_fiddleslit' to completely remove it:
Example: IDL> long_fiddleslits, 'slits-XXX.fits',
REMOVE=(slit number to remove), WAVE_FIL= 'wave-XXX.fits'
- Sometimes, no matter what you do with
'slitthresh', the pipeline still fails to find all the
slits. (This is rare.) If you need to add a slit into your
slitmask, you can use the ADD_SLITS keyword. Just make a file
with two columns, where the first contains the x value at the
start of the new slit, and the second contains the x value at the
end of the slit.
Example: IDL> long_reduce, 'plan.par',
ADD_SLITS= 'add_slits.txt'
- Yet another slit-adjustment keyword is COMBINE_SLITS.
This allows you to combine two adjacent slits into one:
Example: IDL> long_reduce, 'plan.par',
COMBINE_SLITS=[slitnum]
Here, 'slitnum' has the lower slit ID number of the two
you want to combine.
- At this point, you may also check for overlapping
slits. This will be easier to see in the final science images,
however. See below for options for dealing with this problem.
Remember that the slit edges affect every part of the
data reduction, so make sure that if you remake the slit file, have
the code remake everything else as well! (You can use the /CLOBBER
flag for this with 'long_reduce', but use with caution-- if you have a standard star
frame in your plan file, it will get re-reduced with the slitmask
calibration files-- and you don't want that!)
- As soon as the wave-XXX.ps file is produced, check the
wavelength solution! For each slit, check that there aren't large numbers of lines
that weren't identified, and check that a few lines are not
significantly affecting the fit. If they are, you can:
- Remove (or comment out) individual lines from your lris_red[or
blue]_XXX.lst file.
- Re-run long_reduce to tweak the solution for a particular
slit:
Example: IDL> long_reduce, 'plan.par',
TWEAK_ARC=[slitnum]
This will launch a fun GUI, and rewrite your wave-XXX.* files
after you re-fit:
- Put in values for a 'SHIFT', and a
'STRETCH' if needed.
- Click 'APPLY'
- Hit 'L' to see all the lines labelled
- Hit 'F' to perform the fit
- Hit 'R' to see the fit residuals
- 'q' saves the new fit and quits
Primary Science Product
The primary science products are written a multi-extension
FITS file in the Science/ directory. One file is written
per exposure. This table describes the various extensions:
| Extension |
Description |
| 0 |
Processed 2D image of the data.
|
| 1 |
Inverse variance |
| 2 |
Sky model |
| 3 |
Model of the object flux |
| 4 |
Mask of good/bad pixels |
| 5 |
Structure array (one per object identified in the
slit). The key tags are: wave_opt, flux_opt, ivar_opt, wave_box,
flux_box, ivar_box.
|
One can examine the 1 and 2D spectra extracted from each
data frame using the following steps:
- cd Science
- UNIX> idl
- IDL> .run long_look
This will launch a GUI list of all the sci-*.fits.gz files in the
current directory.
- Choose the sci-* file that you want from the GUI list
This will launch a view of the 2D image (using the IDL task atv).
After completing the step described below, you can use this Image display
GUI to examine the 2D spectrum.
A postscript file summarizing the S/N of the various extracted spectra is shown
and also a GUI list of the objects in the frame indexed slit-object
(e.g. 1-2 for slit 1 and object #2 in the slit).
- Choose an object from the GUI list
This will launch an x_specplot GUI that the user can use
to examine the 1D spectrum. At this point the xatv window will now
be active. The wavelength of the cursor position is printed in the
xatv window next to the pixel number.
- Play with the two GUI's.
IMPORTANT: Check your science frames.
Here are some problems/issues you may encounter when checking out your final reductions.
- Overlapping slits or funny slit edges-- you have a couple of options:
- Re-run the full reduction, trimming all of your slit edges
Example: IDL> long_reduce, 'plan.par',
TRIM_SEDGE=npix (where npix = the number of pixels to trim from
each edge)
Note: if you use this keyword concurrently with ADD_SLITS, the new
slits that you add in will not be trimmed.
- If you feel you must be more aggressive about removing slit overlap, you can try:
Example: IDL> long_reduce, 'plan.par',
EDIT_SEDGE_FIL=filename
Here, EDIT_SEDGE_FIL is a text file with 5 columns:
- The x value near the middle of the problem slit
- '1' for the left edge of the slit, or
'2' for the right edge
- The number of pixels to trim from that particular edge
- Pixel number (in y direction) where you want to start
the adjustment
- Pixel number (in y direction) where you want to end
the adjustment
This file must be made by hand while examining the science
reduction. You may also run 'long_reduce' including
both the TRIM_SEDGE and the EDIT_SEDGE_FIL flags at once.
TRIM_SEDGE will only affect slit edges which are NOT being
modified by the EDIT_SEDGE_FIL.
- If you notice horizontal stripes across some slits:
This is likely because a particular slit contains a very wide object but is itself quite narrow. This means that to fit the sky, the code is being forced to use pixels very close to the slit edges. This can cause ringing in the bspline fit to the sky. Our best fix so far is as follows:
- Turn off local sky subtraction for particular problem slits:
Example: IDL> long_reduce, 'plan.par',
ISLIT=slitnum, /NOLOCAL, ONLYSCI=exposure ( 'exposure ' is
something like 'lred0072.fits ')
This will make a new sci-XXX.fits file, retaining the previous reduction of all the other slits but replacing the reduction of the problem slit with the new version.
- You may also want to re-run your reduction, including a standard
frame for the code to use as a crutch:
- Make sure the standard frame has been reduced (with its own
plan file)
- Include the frame in the science plan file, making sure
that it's labelled a 'std'
CAUTION: One can do this for only one slit using the ISLIT
flag, but make sure you include the /ONLYSCI flag as well, or the
standard frame will get re-reduced!
Example: IDL> long_reduce, 'plan.par', ISLIT=slitnum, ONLYSCI=exposure
Coadd
As you will note, the multi-extension FITS file that contains
the spectra are not especially easy to handle. Furthermore, it
is common that a user will wish to coadd multiple exposures of
a given object. This is accomplished with the task
long_coadd :: This
routine takes as input a list of sci- files and a corresponding list of object ID numbers, chooses a
wavelength array for registration, and coadds weighting by the
square of the median S/N ratio (or exposure time).
Call: IDL> long_coadd, files, objid, OUTFIL=name
Example: IDL> long_coadd, ['sci-b263.ccd.gz', 'sci-b265.ccd.gz'], 1, OUTFIL='FSpec/J0905+1014_b.fits'
In the above example, we have set objid=1 to indicate that we wish to
coadd the first object identified in the slit. But we could have set
objid to [3,4] if we wanted to coadd the 3rd object from the first
science frame and the 4th object from the second science frame. The
output file (e.g. FSpec/J0905+1014_b.fits) is a multi-extension FITS
array containing three extension: 0=flux array; 1=sigma array;
2=wavelength array.
One can inspect the data using the XIDL routine x_specplot.
Example: IDL> x_specplot, filename, inflg=2
Flux
Fluxing is relatively straightforward. One includes a calibration
standard in the plan.par file and the code will reduce the data
in a similar fashion as the science exposures. One does NOT apply
the COADD algorithm, but skips to this task
long_sensfunc :: This
algorithm requires that one use one of the standards included
in the Longslit package (contact JH or JXP to add a new file).
These files are found here: $XIDL_DIR/Spec/Longslit/calib/standards/calspec.
WARNING: Most of these standards are only calibrated to 9200A and the
code will truncate the data at larger wavelength.
Call: IDL> sens = long_sensfunc( sci_file, sens_file, std_name=std_name)
Example: IDL> bsens =
long_sensfunc('Science/std-lblue1022.fits', 'Flux/feige34_bsens.fits', std_name='feige34_005',/MSK_BALM)
Note that you are recommended to mask the balmer lines. With a sensitivity function in hand, the final step is to apply
it to the science spectra. This is accomplished with
long_fluxcal :: This
code simply notes the exposure time and applies the sensitivity
function. It also corrects for differences in the airmass of the
two exposures assuming an extinction function appropriate for KPNO.
Call: IDL> long_fluxcal,
coadded_data_file, SENSFUNCFILE=sens_file, OUTFIL=fluxed_data
Example: IDL> long_fluxcal, 'FSpec/J0905+1014_b.fits', SENSFUNCFILE='Flux/feige34_bsens.fits', OUTFIL='FSpec/J0905+1014b_XF.fits'
One can inspect the data using the XIDL routine x_specplot.
Example: IDL> x_specplot, filename, inflg=2
Note that the fluxed spectrum is in units of F_lambda, and needs to be multiplied by a scaling factor of 10^17.
Last modified 2010-04-02


--- layout: post authors: ["Amy Brown"] title: "Job Opportunity at University College London" date: 2014-01-09 time: "10:40:00" tags: ["Jobs"] ---
The University College London Research Software Development Team is recruiting a research software developer. Their ideal candidate will have experience creating and maintaining research software in one or more fields, and will "design, extend, refactor and maintain scientific software accross all subject areas". Sound like you? Have a look at James Hetherington's post about the position. Good luck!


No more Waiting in Toll,Pay the Toll amount Online and Free to Go..
Have a Safe Journey
Highly Secured,So no need to worry about your Personal Data,Fell free to use
We have provided detailed documentation to help new users get started. We are also always open to feedback and can answer any questions a user may have about this process.


1) Use the Spline Tool to Sketch the Base of the Volcano
2) Create a New Plane to Sketch the Top of the Volcano
3) Use the Spline Tool to Sketch the Top of the Volcano
4) Use the Loft Tool to Create the Body of the Volcano
5) Use the Shell Tool to Make the Volcano Hollow
6) Use the Fillet Tool to Soften the Edges of the Volcano
*) Use the Appearance Panel to Change the Color of the Volcano Body
7) Create a New Plane for the Lava
8) Use the Spline Tool and Line Tool to Sketch the Lava
New Part Studio
9) Use the Extrude Tool to Make the Lava 3D
10) Use the Fillet Tool to Soften the Curves of the Lava
We used SPLINE, PLANE, SHELL, LOFT, FILLET, and EXTRUDE.
To make sure the volcano appears upright, start with a sketch on the Top plane.
The plane that you sketch on matters when you put the parts together in Assembly. It's good to get into the habit of building as if you were physically building it with your hands. Think: if you had some clay and started molding on the wall (Right or Front plane) instead of on a table (Top plane), your volcano will be sideways. But no worries, you can change the orientation in the Assembly; it's just an extra step!
Use the spline tool to draw a random shape as the base. Click as many times as you want to make curves in your volcano, and go around in a circular path.
With the spline tool, you are essentially playing "connect the dots," except in this case, you are creating and connecting the dots simultaneously. Once you are done using the tool, you can either click "esc" on your keyboard or deselect the tool in the tool bar.
 **
You can tell that you made a closed-off shape because your shape's interior will be slightly shaded.  Think: volcanos are solids, so you want a solid base.  If you completed the circle, you'd be able to remove your circle from the rest of the paper.
Click the green check mark to finish the sketch.
Change your orientation to the Front view so that you can see the sketch layers better. So far, you can see your first sketch, which will be the base of the volcano.
Before sketching the top of the volcano, use the plane tool to create a new plane.  In this case, we offsetted it by 3 inches, so this volcano will be 3 inches tall.
When 3D modeling, you need to specify where you want things to be and/or where you want them to end up. When you sketch on a plane, you are directly sketching on that plane, wherever it is located. This is why we need to create another plane and offset it so that our sketch for the top of the volcano isn't directly on top of our base. Think: it's like drawing both the base and the top on the same sheet of paper. The paper is 2D, and so your volcano will be 2D as well.
Click the green check mark to finish adding the plane.
On the new plane that you just created (Plane 1), use the spline tool again to sketch the top of the volcano.
** Remember that a volcano normally has a wide base and a smaller top, so make sure the sketch of the top of the volcano is smaller than that of the base. In other words, make the circular path shorter/smaller.
Click the green check mark to finish the sketch of the top plane.
When you look at the Front view, you can see your two sketchs: the larger one on the bottom and the smaller one on top.
We want to create the body of the volcano by connecting the larger sketch (base of volcano) to the smaller sketch (top of volcano). To do this, use the loft tool and select the faces of the two sketches.
Loft is a unique tool that gives the users a bit more freedom. It's almost like the extrude tool, except you can control how and where it ends. As long as you have a starting sketch/face and an end sketch/face, Loft will connect the two.
Click the green check mark to finish the loft.
Select the shell tool, and then click on the top surface of the volcano.
** We want the top of the volcano to be hollow, not the bottom. So make sure to select the top surface and not the bottom.
You may run into some issues with this tool. Perhaps Onshape isn't letting you make your volcano hollow, and there are red outlines on your sketch or you get error messages. This is because of how you made the body of your volcano. Try adjusting your shell thickness by making it smaller. Also, checking "Hollow" will only make the inside of your volcano hollow and won't include the top. The shell tool just empties out your volcano and just leaves the shell of it.
Select the fillet tool, and then select the outer edge of the top of the volcano.
Think of the fillet tool as sandpaper. You're softening and curving the edges so that it's not as pointy.
Set the fillet radius to 0.1 inches.
Some of you might run into some issues with this as well. Depending on how thick/thin your shell is, you may have to play around with the fillet radius. Try adjusting it! The fillet radius is the radius of the curve, so if your shell thickness is small, then you might have to decrease the radius of the curve.
Click the green check mark to finish the fillet.
Right click on the body of the volcano and select "edit appearance."
Adjust the color to get the color of your liking, then click the green check mark to finish the edit.
In the same part studio as the volcano body, use the plane tool to create another plane on the Front plane.
You can draw the lava in another part studio; this is just to help people sketch the angle at which they want their lava and to visualize how they want their sketch to look.
From the left plane perspective, offset the plane by enough to be near the edge of the volcano's body. In this example, we offset it by 1.5 inches.
** Make sure that the plane still entirely intersects the volcano body.
Remember that your sketch goes directly on the plane, wherever the plane is located. So, we want to make sure that our plane is just on the edge of the side of our volcano because that is where the lava on a volcano normally is.
Click the green check mark to finish creating the new plane.
On the new plane that you made (Plane 2), use the spline tool to create the lava by drawing out what you think lava falling down a volcano should look like.
** To make it look more liquidious/smooth, create many dots/checkpoints, which will create curves for the lava. **
Use the line tool to connect and close off your lava so that it is its own shape.
Copy the sketch of the lava that you just made. In a new part studio, paste that sketch into a new sketch (Sketch 1).
We want to do this in a separate part studio because we want the lava to be a separate part than the body. If we kept it in the first part studio, it would simply be a surface instead of its own part. This becomes an issue when you try to import it into an Assembly or when you try to 3D print it: neither can process a surface. Think: try building a volcano with something like clay. Normally, we mold the body of the volcano first and then use more clay material to mold the lava. We either mold the lava separately and press it onto the body, or we mold it on the body itself. Either way, we can separate the clay lava and the clay body into two parts.
Use the extrude tool to extrude add the surface of the lava. This will make the lava 3D.
Adjust how thick you want the lava to be, and then click the green check mark to finish the extrude.
Start off by filleting the top curve. Select the fillet tool and then click on the top edge of the lava. Use the arrow that appears afterwards and drag it as far down as you want.
Click on the green check mark to finish the top fillet. Then click on the tool again and select the side edges of the lava. You can adjust how much you want to fillet it by changing the radius, but we are satisfied with 0.2 inches fillet.
Click on the green check mark to finish the fillets.
Right click on the lava part and select "edit appearance."
Play around with the colors and choose a color that you think is best.
Click the green check mark to finish editing the color.
** You can add an Assembly tab by clicking on the "+" button on the bottom left hand corner. **
In a new Assembly, import the two parts that you made (the volcano body and the lava) by clicking on "Insert" at the top left hand corner.
The parts that you made are like LEGO bricks. You have to put the two together, and Assembly is the place to do it. Think: we're now pressing our clay pieces together to finalize our volcano.
Use your mouse or the arrows provided on the parts to move your parts around and assemble your volcano.
The arrows are used to move the parts linearly: foward, backward, sideways. The circles are used to rotate or turn the part around. The squares are used to move the entire part anywhere you'd like. Recommendation: change your view to just one: Front, Back, Right, etc. Then use the arrows to adjust the part within that view, and then move onto the next view. That way you won't be overwhelmed with all the different arrows, squares, and circles.


{%load static%}
Please share your contacts to us. Only registered users have permission to order tickets.
We have tours to everywhere. Literally.
Our price policy will satisfy you. We promise.
We'll provide you with the best medical care.
These rocks are perfect for ski, so that`s why people prefer them.
Black Lake is simply an awesome place. And also mysterious.
Hawaii is a piece of heaven on the Earth.


Hello = parentName ?>,
Thank you for registering for SUNIA 2020! We're so excited to meet your child this summer. My name is Michael DeMarco, our Registrar.
Now that you have filled out our registration form, there are just a few more steps in your registration:
Here's the information we received. (It's a touch long, but please do check it all! It'll save us both time in the end.)
Student Information
First name: = registrant.firstName ?>
Preferred name: = registrant.prefName ?>
Last name: = registrant.lastName ?>
Week: = registrant.week ?>
Bus: = registrant.bus ?>
Phone: = registrant.studentPhone ?>
Email: = registrant.studentEmail ?>
Age: = registrant.age ?>
Gender: = registrant.gender ?>
Health Care: = registrant.healthNumber ?>
Address: = registrant.address ?>
City: = registrant.city ?>
Province: = registrant.province ?>
Country: = registrant.country ?>
Postal Code: = registrant.postalCode ?>
Health Concerns: = registrant.healthConcerns ?>
Diet: = registrant.diet ?>
Parent Information
Parent Name: = registrant.parentName ?>
Relation: = registrant.parentRelationship ?>
Email: = registrant.parentEmail ?>
Phone: = registrant.parentPhone ?>
School Information
School: = registrant.schoolName ?>
School City: = registrant.schoolCity ?>
School Province: = registrant.schoolProvince ?>
School Country: = registrant.schoolCountry ?>
Grade: = registrant.grade ?>
First Emergency Contact
Name: = registrant.ecName ?>
Relation: = registrant.ecRelationship ?>
Phone #1: = registrant.ecPhone ?>
Type: = registrant.ecPhoneType ?>
Phone #2: = registrant.ecAltPhone ?>
Type: = registrant.ecAltPhoneType ?>
Second Emergency Contact
Name: = registrant.ec2Name ?>
Relation: = registrant.ec2Relationship ?>
Phone #1: = registrant.ec2Phone ?>
Type: = registrant.ec2PhoneType ?>
Phone #2: = registrant.ec2AltPhone ?>
Type: = registrant.ec2AltPhoneType ?>
On the note of payment, I would like to take this opportunity to inform you of our refund policy. In the case that your child cannot attend SUNIA for any reason, and you wish to cancel their registration prior to July 1st 2020, $495 will be refunded to you (the total you have paid, less a $100 processing fee). However, cancellations received on or after July 1st will receive no refunds whatsoever.
I hope to speak to you about these items over the phone at some point in the next few days. In the meantime, please do not hesitate to reach out to me at<EMAIL_ADDRESS>with any questions or concerns you may have. Our staff looks forward to welcoming your child to SUNIA this August!
Speak soon,
Michael DeMarco
Registrar
<EMAIL_ADDRESS>(780) 680-9634
sunia.ca


REST API app has three types of authentication:
- Basic authentication with username/password: user's
email address and password from m_user table
- Basic authentication with account/shared key: account id with
the shared key from external_authentication table, which should have
a row for that account id with the api_productid = 16, similar to
how other "integrations" must be activated/configured
- session-id parameter in the url or cookie (must be a valid session)
All of these should be sent with a header called 'X-Integration-ID' with a value of '16'.


{% extends "im/account_base.html" %} {% load filters astakos_tags %} {% block headjs %} {{ block.super }} {% endblock %} {% block page.body %}
These are the specifications of the Project you want to create. If you hit the "Submit" button this form will be officially sent to {{ BRANDING_COMPANY_NAME }} for review. Please make sure the following reflect exactly your request.


Microformats Hootenanny
Arrive
2014-01-01T12:00:00+00:00
, stay until
six pee em GMT on the first day of the first month, year three thousand, four and ten.
That’s right, the microformats
party
hootenanny
lasts for
ONE THOUSAND YEARS
.
at precisely
1:21 am
3/11 9:55
15:28
on
2014-01-30
9999-01-14T11:52+08:00


Cops probing 'indecent offence' at Scots H&M store release CCTV image of 6ft man
Police say the incident caused serious upset and have appealed for help in identifying the man they believe can help the investigation.
by Kathleen SpeirsPolice probing an 'indecent offence' at an H&M store have released CCTV footage of a man they think may help with their enquiries.
The incident took place at around 4.45pm on Monday, August 5 at the Union Square shopping centre in Aberdeen .
PC Mark Brechin, who is leading the enquiry, said: "The incident caused serious upset to those involved.
"I would urge anyone who has any information relating to the man in the CCTV images to make contact with police and pass on that information.
"The man is described as approximately six foot tall with dark hair.
"He was wearing dark trousers and a light coloured top."
You can contact Police Scotland via the 101 non-emergency telephone number quoting reference number CF0198110819.
Those wishing to remain anonymous can call the registered charity, Crimestoppers on 0800 555 111.


WITNESS LIST Pensions & Investments Committee March 23, 2005-8:00A HB 1655 For: Gardner, J.D. (Self and Pasadena Fire Dept. HCFFA (Harris County Fire Fighters Assn.), Texas Fire Cheifs Assn.) Klesel, Rex (Alvin Vol. Fire Dept.) Perdue, Eugene Steven (Self and SFFMA) Scopel, Allen J. (Self and Texas Statewide Emergency Service Personnel Pension Fund (Vice Chairman)) Stacy, David (Self and Midland Fireman's Relief and Retirement Fund) Torres, Frank (Self and Texas Statewide Emergency Services Retirement Fund) Weiss, Robert (Brenham Fire Dept.) Wisko, Willie (Self and State Firemen's and Fire Marshal's Association) Against: Floyd, Beaman (Allstate, State Farm, Nationwide, USAA, American Insurance Association) Krier, Cyndi Taylor (USAA) On: Fenlaw, Mark R. (Texas Statewide Emergency Services Personnel Retirement Fund) Miller, Lisa Ivie (Self and Fire Fighters Pension Commission) Registering, but not testifying: For: Choate, Oscar (Texas Statewide Emergency Services Personnel Retirement Fund) Donaldson, Kyle A. (Sonora Vol. Fire Dept.) Johnson, Helen L. (State Firemen's and Fire Marshals Assoc.) Martin, Tim (Self and Texarkana Firemans Relief and Retirement Fund) Marzean, Barbara (VFIS of Texas) Shelton, Kevin (Self) Sitzes, Kenneth A. (Self and Granbury Vol. Fire Dept.) Smith, Roddy (Texarkana Fire Fighters Pension) Stevens, Buck (Self and Pearland Vol. Fire Dept.) Vargas, Manuel (Self and Mcallen Firemen's Relief and Retirement Fund) On: Browning, Jr., Roy (Self) Deiters, Kevin (Fire Fighter Pension Comm.) HB 2566 For: Gardner, J.D. (Pasadena Fire Dept., HCFFA (Harris County Fire Fighters Assn.), Texas Fire Cheifs Assn.) Johnson, Helen L. (State Firemen's and Fire Marshal's Assoc.) Klesel, Rex (Alvin Vol. Fire Dept.) Scopel, Allen J. (Self and Texas Statewide Emergency Service Personnel Pension Fund (Vice Chairman)) Torres, Frank (Self and Texas Statewide Emergency Services Retirement Fund) Wisko, Willie (Self and State Firemen's and Fire Marshals' Association) On: Fenlaw, Mark R. (Texas Statewide Emergency Services Personnel Retirement Fund) Miller, Lisa Ivie (Self and Fire Fighter's Pension Commission) Registering, but not testifying: For: Choate, Oscar (Texas Statewide Emergency Services Personnel Retirement Fund) Donaldson, Kyle A. (Sonora Vol. Fire Dept.) Martin, Tim (Self and Texarkana Firemans Relief and Retirement Fund) Marzean, Barbara (VFIS of Texas) Shelton, Kevin (Self) Sitzes, Kenneth A. (Self and Granbury Vol. Fire Dept.) Smith, Roddy (Texarkana Fire Fighters Pension) Stacy, David (Self and Midland Fireman's Relief and Retirement Fund) Stevens, Buck (Self and Pearland Vol. Fire Dept.) Vargas, Manuel (Self and Mcallen Fireman's Relief and Retirement Fund) On: Browning, Jr., Roy (Self) Deiters, Kevin (Fire Fighter Pension Comm.)


Classes
The following classes are available globally.
-
Object representation of a Sensibill User Get the current user
See moreDeclaration
Swift
@objc(SBLUser) public class User : CoreDataManaged
-
Structure that holds all necessary credential information for a user
See moreDeclaration
Swift
@objc(SBLCredentials) public class Credentials : NSObject, NSCoding
-
Handles authentication, and tokenProvider registration
See moreDeclaration
Swift
@objc(SBLAuthenticator) public class Authenticator : NSObject
-
Handles all authentication flows for the Password Authenticated users
See moreDeclaration
Swift
@objc(SBLPasswordAuthenticator) public class PasswordAuthenticator : Authenticator
-
Structure that represents the evaluated password strength, as determined by the backend
See moreDeclaration
Swift
@objc(SBLPasswordEvaluation) public class PasswordEvaluation : NSObject
-
Describes properties of an item
See moreDeclaration
Swift
@objc(SBLItemProperty) public class ItemProperty : NSObject
-
Discount
See moreDeclaration
Swift
@objc(SBLDiscount) public class Discount : NSObject
-
Fee
See moreDeclaration
Swift
@objc(SBLFee) public class Fee : NSObject
-
Represents the loyalty rewards earned for a receipt
See moreDeclaration
Swift
@objc(SBLReward) public class Reward : NSObject
-
Original receipt document
See moreDeclaration
Swift
@objc(SBLOriginal) public class Original : NSObject
-
Use the ReceiptCollection shared instance to query our Receipts database
See moreDeclaration
Swift
@objc(SBLReceiptCollection) public class ReceiptCollection : NSObject
-
Use a SearchFilter instance to query a specific set of receipts
See moreDeclaration
Swift
@objc(SBLReceiptSearchFilter) public class ReceiptSearchFilter : NSObject
-
Create an instance of Request to communicate with the Sensibill Web API
See moreDeclaration
Swift
@objc(SBLRequest) public class Request : NSObject
-
Main class used to configure the Sensibill Environment
See moreDeclaration
Swift
@objc public class Sensibill : NSObject
-
UIViewController used by Receipt Capture to show information.
contentViewControllerBlock
is the only interface that should currently be used externally.Declaration
Swift
@objc(SBLCaptureTipsViewController) public class CaptureTipsViewController : GenericCaptureTipsViewController, CaptureTipsViewControllerProtocol
-
UIViewController used by Receipt Capture to show information first time capture is used.
contentViewControllerBlock
is the only interface that should currently be used externally.Declaration
Swift
@objc(SBLCaptureOnboardingViewController) public class CaptureOnboardingViewController : GenericCaptureTipsViewController, CaptureTipsViewControllerProtocol
-
List of recent exports. Allows user to download exported receipts.
See moreDeclaration
Swift
@objc(SBLRecentExportsViewController) public class RecentExportsViewController : UITableViewController
-
UINavigationController used to show the main List of Receipts.
See moreDeclaration
Swift
@objc(SBLReceiptListViewController) public class ReceiptListViewController : UINavigationController, SBLReceiptListViewControllerDataSource


About Pat's Pizza Place
Pat LOVES pizza! Back in 1962, Pat started a tradition of taste that would eventually deliver Pat's Pizza into the national eye. Recognized by people across America, this pizza has earned national honors for robust flavor and affordable prices.
Founded on a fresh recipe and an even fresher delivery idea, we earned a distinct reputation for hearty authenticity and unconditional taste focus for the serious pizza eater. Starting with our daily hand-tossed dough, mixed with extra virgin olive oil, our pies are then topped with our signature sauce, made from freshly-packed, vine-ripened tomatoes and covered with 100% Real® mozzarella cheese. Each pie is finished off with the freshest of toppings for your enjoyment.
Pizza is not our only love. Pat enjoys a good plate of pasta, too. Homemade pasta noodles and rich sauces will make you come back for more and more!
Just for the kids! Click to enlarge coloring page. Bring in for 15% off!