--- title: Graceful asynchronous programming with Promises slug: Learn/JavaScript/Asynchronous/Promises tags: - Beginner - CodingScripting - Guide - JavaScript - Learn - Promises - async - asynchronous - catch - finally - then ---
Promises are a comparatively new feature of the JavaScript language that allow you to defer further actions until after a previous action has completed, or respond to its failure. This is useful for setting up a sequence of async operations to work correctly. This article shows you how promises work, how you'll see them in use with web APIs, and how to write your own.
| Prerequisites: | Basic computer literacy, a reasonable understanding of JavaScript fundamentals. |
|---|---|
| Objective: | To understand promises and how to use them. |
We looked at Promises briefly in the first article of the course, but here we'll look at them in a lot more depth.
Essentially, a Promise is an object that represents an intermediate state of an operation — in effect, a promise that a result of some kind will be returned at some point in the future. There is no guarantee of exactly when the operation will complete and the result will be returned, but there is a guarantee that when the result is available, or the promise fails, the code you provide will be executed in order to do something else with a successful result, or to gracefully handle a failure case.
Generally, you are less interested in the amount of time an async operation will take to return its result (unless of course, it takes far too long!), and more interested in being able to respond to it being returned, whenever that is. And of course, it's nice that it doesn't block the rest of the code execution.
One of the most common engagements you'll have with promises is with web APIs that return a promise. Let's consider a hypothetical video chat application. The application has a window with a list of the user's friends, and clicking on a button next to a user starts a video call to that user.
That button's handler calls {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} in order to get access to the user's camera and microphone. Since getUserMedia()
has to ensure that the user has permission to use those devices and ask the user which microphone to use and which camera to use (or whether to be a voice-only call, among other possible options), it can block until not only all of those decisions are made, but also the camera and microphone have been engaged. Also, the user may not respond immediately to these permission requests. This can potentially take a long time.
Since the call to getUserMedia()
is made from the browser's main thread, the entire browser is blocked until getUserMedia()
returns! Obviously, that's not an acceptable option; without promises, everything in the browser becomes unusable until the user decides what to do about the camera and microphone. So instead of waiting for the user, getting the chosen devices enabled, and directly returning the {{domxref("MediaStream")}} for the stream created from the selected sources, getUserMedia()
returns a {{jsxref("promise")}} which is resolved with the {{domxref("MediaStream")}} once it's available.
The code that the video chat application would use might look something like this:
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">function handleCallButton(evt) { setStatusMessage("Calling..."); navigator.mediaDevices.getUserMedia({video: true, audio: true}) .then(chatStream => { selfViewElem.srcObject = chatStream; chatStream.getTracks().forEach(track => myPeerConnection.addTrack(track, chatStream)); setStatusMessage("Connected"); }).catch(err => { setStatusMessage("Failed to connect"); }); }This function starts by using a function called setStatusMessage()
to update a status display with the
message "Calling...", indicating that a call is being attempted. It then calls getUserMedia()
, asking for
a stream that has both video and audio tracks, then once that's been obtained, sets up a video element to show the
stream coming from the camera as a "self view," then takes each of the stream's tracks and adds them to the WebRTC {{domxref("RTCPeerConnection")}} representing a
connection to another user. After that, the status display is updated to say "Connected".
If getUserMedia()
fails, the catch
block runs. This uses setStatusMessage()
to update the status box to indicate that an error occurred.
The important thing here is that the getUserMedia()
call returns almost immediately, even if the camera stream hasn't been obtained yet. Even if the handleCallButton()
function has already returned to the code that called it, when getUserMedia()
has finished working, it calls the handler you provide. As long as the app doesn't assume that streaming has begun, it can just keep on running.
Note: You can learn more about this somewhat advanced topic, if you're interested, in the article Signaling and video calling. Code similar to this, but much more complete, is used in that example.
To fully understand why promises are a good thing, it helps to think back to old-style callbacks and to appreciate why they are problematic.
Let's talk about ordering pizza as an analogy. There are certain steps that you have to take for your order to be successful, which doesn't really make sense to try to execute out of order, or in order but before each previous step has quite finished:
With old-style callbacks, a pseudo-code representation of the above functionality might look something like this:
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">chooseToppings(function(toppings) { placeOrder(toppings, function(order) { collectOrder(order, function(pizza) { eatPizza(pizza); }, failureCallback); }, failureCallback); }, failureCallback);This is messy and hard to read (often referred to as "callback
hell"), requires the failureCallback()
to be called multiple times (once for each nested function),
with other issues besides.
Promises make situations like the above much easier to write, parse, and run. If we represented the above pseudo-code using asynchronous promises instead, we'd end up with something like this:
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">chooseToppings() .then(function(toppings) { return placeOrder(toppings); }) .then(function(order) { return collectOrder(order); }) .then(function(pizza) { eatPizza(pizza); }) .catch(failureCallback);This is much better — it is easier to see what is going on, we only need a single .catch()
block to handle all the errors, it doesn't block the main thread (so we can keep playing video games while we wait for the pizza to be ready to collect), and each operation is guaranteed to wait for previous operations to complete before running. We're able to chain multiple asynchronous actions to occur one after another this way because each .then()
block returns a new promise that resolves when the .then()
block is done running. Clever, right?
Using arrow functions, you can simplify the code even further:
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">chooseToppings() .then(toppings => placeOrder(toppings) ) .then(order => collectOrder(order) ) .then(pizza => eatPizza(pizza) ) .catch(failureCallback);Or even this:
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">chooseToppings() .then(toppings => placeOrder(toppings)) .then(order => collectOrder(order)) .then(pizza => eatPizza(pizza)) .catch(failureCallback);This works because with arrow functions () => x
is valid shorthand for () => { return x; }
.
You could even do this, since the functions just pass their arguments directly, so there isn't any need for that extra layer of functions:
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">chooseToppings().then(placeOrder).then(collectOrder).then(eatPizza).catch(failureCallback);This is not quite as easy to read, however, and this syntax might not be usable if your blocks are more complex than what we've shown here.
Note: You can make further improvements with async
/await
syntax, which we'll dig into in the next article.
At their most basic, promises are similar to event listeners, but with a few differences:
Promises are important to understand because most modern Web APIs use them for functions that perform potentially lengthy tasks. To use modern web technologies you'll need to use promises. Later on in the chapter, we'll look at how to write your own promise, but for now, we'll look at some simple examples that you'll encounter in Web APIs.
In the first example, we'll use the
fetch()
method to fetch an
image from the web, the {{domxref("Body.blob", "blob()")}} method to transform the fetch response's raw body contents
into a {{domxref("Blob")}} object, and then display that blob inside an {{htmlelement("img")}} element. This is very
similar to the example we looked at in the first article of the
series, but we'll do it a bit differently as we get you building your own promise-based code.
Note: The following example will not work if you just run it directly from the file (i.e. via a
file://
URL). You need to run it through a local testing server, or use an online
solution such as Glitch or GitHub pages.
First of all, download our simple HTML template and the sample image file that we'll fetch.
Add a {{htmlelement("script")}} element at the bottom of the HTML {{htmlelement("body")}}.
Inside your {{HTMLElement("script")}} element, add the following line:
let promise = fetch('coffee.jpg');
This calls the fetch()
method, passing it the URL of the image to fetch from the network as a parameter. This can also take an options object as an optional second parameter, but we are just using the simplest version for now. We are storing the promise object returned by fetch()
inside a variable called promise
. As we said before, this object represents an intermediate state that is initially neither success nor failure — the official term for a promise in this state is pending.
To respond to the successful completion of the operation whenever that occurs (in this case, when a
{{domxref("Response")}} is returned), we invoke the
.then()
method
of the promise object. The callback inside the .then()
block (referred to as the
executor) runs only when the promise call completes successfully and returns the
{{domxref("Response")}} object — in promise-speak, when it has been fulfilled. It is passed the
returned {{domxref("Response")}} object as a parameter.
Note: The way that a .then()
block works is similar to when you add an event listener to an object using AddEventListener()
. It doesn't run until an event occurs (when the promise fulfills). The most notable difference is that a .then()
will only run once for each time it is used, whereas an event listener could be invoked multiple times.
We immediately run the blob()
method on this response to ensure that the response body is fully downloaded, and when it is available transform it into a Blob
object that we can do something with. The result of this is returned like so:
response => response.blob()
which is shorthand for
function(response) { return response.blob(); }
Unfortunately, we need to do slightly more than this. Fetch promises do not fail on 404 or 500 errors — only on
something catastrophic like a network failure. Instead, they succeed, but with the
response.ok
property set to false
.
To produce an error on a 404, for example, we need to check the value of response.ok
, and if
false
, throw an error, only returning the blob if it is true
. This can be done like so — add
the following lines below your first line of JavaScript.
let promise2 = promise.then(response => { if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } else { return response.blob(); } });
Each call to .then()
creates a new promise. This is very useful; because the blob()
method also returns a promise, we can handle the Blob
object it returns on fulfillment by invoking the .then()
method of the second promise. Because we want to do something a bit more complex to the blob than just run a single method on it and return the result, we'll need to wrap the function body in curly braces this time (otherwise it'll throw an error).
Add the following to the end of your code:
let promise3 = promise2.then(myBlob => { })
Now let's fill in the body of the executor function. Add the following lines inside the curly braces:
let objectURL = URL.createObjectURL(myBlob); let image = document.createElement('img'); image.src = objectURL; document.body.appendChild(image);
Here we are running the {{domxref("URL.createObjectURL()")}} method, passing it as a parameter the Blob
returned when the second promise fulfills. This will return a URL pointing to the object. Then we create an {{htmlelement("img")}} element, set its src
attribute to equal the object URL and append it to the DOM, so the image will display on the page!
If you save the HTML file you've just created and load it in your browser, you'll see that the image is displayed in the page as expected. Good work!
Note: You will probably notice that these examples are somewhat contrived. You could just do away with the whole fetch()
and blob()
chain, and just create an <img>
element and set its src
attribute value to the URL of the image file, coffee.jpg
. We did, however, pick this example because it demonstrates promises in a nice simple fashion, rather than for its real-world appropriateness.
Something is missing — currently, there is nothing to explicitly handle errors if one of the promises fails
(rejects, in promise-speak). We can add error handling by running the
.catch()
method off the previous promise. Add this now:
To see this in action, try misspelling the URL to the image and reloading the page. The error will be reported in the console of your browser's developer tools.
This doesn't do much more than it would if you just didn't bother including the .catch()
block at all, but think about it — this allows us to control error handling exactly how we want. In a real app, your .catch()
block could retry fetching the image, or show a default image, or prompt the user to provide a different image URL, or whatever.
Note: You can see our version of the example live (see the source code also).
This is a very longhand way of writing this out; we've deliberately done this to help you understand what is going on
clearly. As shown earlier on in the article, you can chain together .then()
blocks (and also
.catch()
blocks). The above code could also be written like this (see also simple-fetch-chained.html
on GitHub):
Bear in mind that the value returned by a fulfilled promise becomes the parameter passed to the next .then()
block's executor function.
Note: .then()
/.catch()
blocks in promises are basically the async
equivalent of a
try...catch
block
in sync code. Bear in mind that synchronous try...catch
won't work in async code.
There was a lot to cover in the above section, so let's go back over it quickly to give you a short guide that you can bookmark and use to refresh your memory in the future. You should also go over the above section again a few more time to make sure these concepts stick.
.then()
block onto the end of the promise chain. The executor function inside the .then()
block will contain the promise's return value..catch()
block onto the end of the promise chain.The above example showed us some of the real basics of using promises. Now let's look at some more advanced features. For a start, chaining processes to occur one after the other is all fine, but what if you want to run some code only after a whole bunch of promises have all fulfilled?
You can do this with the ingeniously named
Promise.all()
static method. This takes an array of promises as an input parameter and returns a new Promise
object
that will fulfil only if and when all promises in the array fulfil. It looks something like this:
If they all fulfil, the chained .then()
block's executor function will be passed an array containing all those results as a parameter. If any of the promises passed to Promise.all()
reject, the whole block will reject.
This can be very useful. Imagine that we’re fetching information to dynamically populate a UI feature on our page with content. In many cases, it makes sense to receive all the data and only then show the complete content, rather than displaying partial information.
Let's build another example to show this in action.
Download a fresh copy of our page
template, and again put a <script>
element just before the closing </body>
tag.
Download our source files (coffee.jpg, tea.jpg, and description.txt), or feel free to substitute your own.
In our script, we'll first define a function that returns the promises we want to send to Promise.all()
. This would be easy if we just wanted to run the Promise.all()
block in response to three fetch()
operations completing. We could just do something like:
let a = fetch(url1); let b = fetch(url2); let c = fetch(url3); Promise.all([a, b, c]).then(values => { ... });
When the promise is fulfilled, the values
passed into the fulfilment handler would contain three Response
objects, one for each of the fetch()
operations that have completed.
However, we don't want to do this. Our code doesn't care when the fetch()
operations are done. Instead, what we want is the loaded data. That means we want to run the Promise.all()
block when we get back usable blobs representing the images, and a usable text string. We can write a function that does this; add the following inside your <script>
element:
function fetchAndDecode(url, type) { return fetch(url).then(response => { if(!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } else { if(type === 'blob') { return response.blob(); } else if(type === 'text') { return response.text(); } } }) .catch(e => { console.log(`There has been a problem with your fetch operation for resource "${url}": ` + e.message); }); }
This looks a bit complex, so let's run through it step by step:
fetch()
function to fetch the resource at the specified URL, then chain it onto another promise that returns the decoded (or "read") response body. This was always the blob()
method in the previous example.type
value is. Inside the executor function, we include a simple if ... else if
statement to return a different promise depending on what type of file we need to decode (in this case we've got a choice of blob
or text
, but it would be easy to extend this to deal with other types as well).return
keyword before the fetch()
call. The effect this has is to run the entire chain and then run the final result (i.e. the promise returned by blob()
or text()
) as the return value of the function we've just defined. In effect, the return
statements pass the results back up the chain to the top.At the end of the block, we chain on a .catch()
call, to handle any error cases that may occur with any of the promises passed in the array to .all()
. If any of the promises reject, the .catch()
block will let you know which one had a problem. The .all()
block (see below) will still fulfill, but it won't display the resources that had problems. Remember that, once you handle the promise with a .catch()
block, the resulting promise is considered resolved but with a value of undefined
; that's why in this case the .all()
block will always get fulfilled. If you wanted the .all()
to reject, you'd have to chain the .catch()
block on to the end of the .all()
instead.
The code inside the function body is async and promise-based, therefore in effect, the entire function acts like a promise — convenient.
Next, we call our function three times to begin the process of fetching and decoding the images and text and store each of the returned promises in a variable. Add the following below your previous code:
let coffee = fetchAndDecode('coffee.jpg', 'blob'); let tea = fetchAndDecode('tea.jpg', 'blob'); let description = fetchAndDecode('description.txt', 'text');
Next, we will define a Promise.all()
block to run some code only when all three of the promises stored above have successfully fulfilled. To begin with, add a block with an empty executor inside the .then()
call, like so:
Promise.all([coffee, tea, description]).then(values => { });
You can see that it takes an array containing the promises as a parameter. The executor will only run when all three promises resolve; when that happens, it will be passed an array containing the results from the individual promises (i.e. the decoded response bodies), kind of like [coffee-results, tea-results, description-results].
Finally, add the following inside the executor. Here we use some fairly simple sync code to store the results in separate variables (creating object URLs from the blobs), then display the images and text on the page.
console.log(values); // Store each value returned from the promises in separate variables; create object URLs from the blobs let objectURL1 = URL.createObjectURL(values[0]); let objectURL2 = URL.createObjectURL(values[1]); let descText = values[2]; // Display the images in <img> elements let image1 = document.createElement('img'); let image2 = document.createElement('img'); image1.src = objectURL1; image2.src = objectURL2; document.body.appendChild(image1); document.body.appendChild(image2); // Display the text in a paragraph let para = document.createElement('p'); para.textContent = descText; document.body.appendChild(para);
Save and refresh and you should see your UI components all loaded, albeit in a not particularly attractive way!
The code we provided here for displaying the items is fairly rudimentary but works as an explainer for now.
Note: If you get stuck, you can compare your version of the code to ours, to see what it is meant to look like — see it live, and see the source code.
Note: If you were improving this code, you might want to loop through a list of items to display, fetching and decoding each one, and then loop through the results inside Promise.all()
, running a different function to display each one depending on what the type of code was. This would make it work for any number of items, not just three.
Also, you could determine what the type of file is being fetched without needing an explicit type
property. You could, for example, check the {{HTTPHeader("Content-Type")}} HTTP header of the response in each case
using response.headers.get("content-type")
, and
then react accordingly.
There will be cases where you want to run a final block of code after a promise completes, regardless of whether it fulfilled or rejected. Previously you'd have to include the same code in both the .then()
and .catch()
callbacks, for example:
In more recent modern browsers, the
.finally()
method is available, which can be chained onto the end of your regular promise chain allowing you to cut down on code
repetition and do things more elegantly. The above code can now be written as follows:
For a real example, take a look at our promise-finally.html
demo (see the source
code also). This works the same as the Promise.all()
demo we looked at in the above section, except
that in the fetchAndDecode()
function we chain a finally()
call on to the end of the chain:
This logs a simple message to the console to tell us when each fetch attempt has finished.
Note: then()
/catch()
/finally()
is the async equivalent to try
/catch
/finally
in sync code.
The good news is that, in a way, you've already built your own promises. When you've chained multiple promises together with .then()
blocks, or otherwise combined them to create custom functionality, you are already making your own custom async promise-based functions. Take our fetchAndDecode()
function from the previous examples, for example.
Combining different promise-based APIs together to create custom functionality is by far the most common way you'll do custom things with promises, and shows the flexibility and power of basing most modern APIs around the same principle. There is another way, however.
It is possible to build your own promises using the
Promise()
constructor. The main situation in which you'll want to do this is when you've got code based on an old-school
asynchronous API that is not promise-based, which you want to promis-ify. This comes in handy when you need to use
existing, older project code, libraries, or frameworks along with modern promise-based code.
Let's have a look at a simple example to get you started — here we wrap a
setTimeout()
call with
a promise — this runs a function after two seconds that resolves the promise (using the passed
resolve()
call) with a string of "Success!".
resolve()
and reject()
are functions that you call to fulfil or reject the newly-created promise. In this case, the promise fulfills with a string of "Success!".
So when you call this promise, you can chain a .then()
block onto the end of it and it will be passed a string of "Success!". In the below code we alert that message:
or even just
pre data-role="codeBlock" data-info="js" class="language-javascript" class="brush: js notranslate">timeoutPromise.then(alert);Try running this live to see the result (also see the source code).
The above example is not very flexible — the promise can only ever fulfil with a single string, and it doesn't have
any kind of
reject()
condition specified (admittedly, setTimeout()
doesn't really have a fail condition, so it doesn't matter
for this simple example).
Note: Why resolve()
, and not fulfill()
? The answer we'll give you, for now, is it's complicated.
We can create a promise that rejects using the
reject()
method — just like resolve()
, this takes a single value, but in this case, it is the reason to reject
with, i.e., the error that will be passed into the .catch()
block.
Let's extend the previous example to have some reject()
conditions as well as allowing different messages to be passed upon success.
Take a copy of the previous
example, and replace the existing timeoutPromise()
definition with this:
Here we are passing two arguments into a custom function — a message to do something with, and the time interval to pass before doing the thing. Inside the function we then return a new Promise
object — invoking the function will return the promise we want to use.
Inside the Promise constructor, we do several checks inside if ... else
structures:
setTimeout()
.Since the timeoutPromise()
function returns a Promise
, we can chain .then()
, .catch()
, etc. onto it to make use of its functionality. Let's use it now — replace the previous timeoutPromise
usage with this one:
When you save and run the code as is, after one second you'll get the message alerted. Now try setting the message to an empty string or the interval to a negative number, for example, and you'll be able to see the promise reject with the appropriate error messages! You could also try doing something else with the resolved message rather than just alerting it.
Note: You can find our version of this example on GitHub as custom-promise2.html (see also the source code).
The above example was kept deliberately simple to make the concepts easy to understand, but it is not really very async. The asynchronous nature is basically faked using setTimeout()
, although it does still show that promises are useful for creating a custom function with a sensible flow of operations, good error handling, etc.
One example we'd like to invite you to study, which does show a useful async application of the
Promise()
constructor, is Jake Archibald's
idb library. This takes the IndexedDB API, which is
an old-style callback-based API for storing and retrieving data on the client-side, and allows you to use it with
promises. In the code you'll see the same kind of techniques we discussed above being used there. The following block
converts the basic request model used by many IndexedDB methods to use promises (see
this code, for example).
Promises are a good way to build asynchronous applications when we don’t know the return value of a function or how long it will take to return. They make it easier to express and reason about sequences of asynchronous operations without deeply nested callbacks, and they support a style of error handling that is similar to the synchronous try...catch
statement.
Promises work in the latest versions of all modern browsers; the only place where promise support will be a problem is in Opera Mini and IE11 and earlier versions.
We didn't touch on all promise features in this article, just the most interesting and useful ones. As you start to learn more about promises, you'll come across further features and techniques.
Most modern Web APIs are promise-based, so you'll need to understand promises to get the most out of them. Among those APIs are WebRTC, Web Audio API, Media Capture and Streams, and many more. Promises will be more and more important as time goes on, so learning to use and understand them is an important step in learning modern JavaScript.
Promise()
{{PreviousMenuNext("Learn/JavaScript/Asynchronous/Timeouts_and_intervals", "Learn/JavaScript/Asynchronous/Async_await", "Learn/JavaScript/Asynchronous")}}


Who am
I?
I'm a nonconventional full-stack software engineer. My passion for tech motivated me to transition from a sales and commercial roll where I had 5+ years of experience. I've worked with high impact clients. I believe that truly amazing things are achieved not by isolated individuals but by motivated and focused teams. I like to read both fictional and nonfictional. From time to time I write at https://medium.com/@tomasmontoya123 I am a friendly and kind person, analyst and abstract thinker, I enjoy talking to people. I am very eager to help and please others. I am effective in responding to questions, comments, and objections of others. I am almost always looking for ways to change and improve methods, systems, processes, and results.


| Modifier and Type | Method and Description |
|---|---|
protected IBoxRequestAuth |
BoxClient.createAuthorization(IAuthDataController controller)
From auth data controller, generate IBoxRequestAuth, which can be applied to api requests.
|
IBoxRequestAuth |
BoxClient.getAuth()
Get the auth object used to make api calls.
|
IBoxRequestAuth |
BoxClient.getSharedItemAuth(java.lang.String sharedLink,
java.lang.String password)
Get the authorization needed for shared items.
|
| Modifier and Type | Class and Description |
|---|---|
class |
OAuthAuthorization
This is authorization class for API requests using OAuth.
|
class |
SharedItemAuth
Class implementing the shared item authorization used to make api calls on shared link items.
|
class |
SharedLinkAuthorization
Shared link authorization.
|
| Modifier and Type | Method and Description |
|---|---|
void |
BoxFileDownload.execute(IBoxRequestAuth auth,
java.io.File destination,
IBoxJSONParser parser,
BoxDefaultRequestObject requestObject)
Execute a download.
|
java.io.InputStream |
BoxFileDownload.execute(IBoxRequestAuth auth,
IBoxJSONParser parser,
BoxDefaultRequestObject requestObject)
Execute the download and return the raw InputStream.
|
void |
BoxFileDownload.execute(IBoxRequestAuth auth,
java.io.OutputStream[] outputStreams,
IBoxJSONParser parser,
BoxDefaultRequestObject requestObject)
Execute a download.
|
| Modifier and Type | Method and Description |
|---|---|
IBoxRequestAuth |
AbstractBoxResourceManager.getAuth() |
| Modifier and Type | Method and Description |
|---|---|
IBoxResourceManager |
IPluginResourceManagerBuilder.build(IBoxConfig config,
IBoxResourceHub resourceHub,
IBoxJSONParser parser,
IBoxRequestAuth auth,
IBoxRESTClient restClient) |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultAuthHeaderAuth
Auth to be set in http request header.
|
class |
DefaultRequestAuth
Base class for default Auth to be used for DefaultBoxRequest.
|
class |
DefaultUsernamePasswordAuth
Auth for username/password.
|
| Modifier and Type | Method and Description |
|---|---|
IBoxRequestAuth |
IBoxRequest.getAuth()
Auth.
|
IBoxRequestAuth |
DefaultBoxRequest.getAuth() |
| Modifier and Type | Method and Description |
|---|---|
void |
IBoxRequest.setAuth(IBoxRequestAuth auth)
Set authorization.
|
void |
DefaultBoxRequest.setAuth(IBoxRequestAuth auth) |


--- layout: post title: "proper cube pattern" date: 2016-12-04 20:18:00 categories: experiments custom_js: - three/three.min.js - local/fs.js ---


Welcome to the Spaghetti Hog!
Our Food
Spaghetti Hog cuisine is the finest in comfort food. Our spaghetti is so good. It's amazing. Really.
Menu
Contact Us


|
NotSoTinyThread++
1.0
|
TinyThread++ is a minimal, portable implementation of basic threading classes for C++.
They closely mimic the functionality and naming of the C++11 standard, and should be easily replaceable with the corresponding std:: variants.
The Win32 variant uses the native Win32 API for implementing the thread classes, while for other systems, the POSIX threads API (pthread) is used.
In order to mimic the threading API of the C++11 standard, subsets of several classes are provided. The fundamental classes are:
The following special keywords are available: thread_local.
For more detailed information (including additional classes), browse the different sections of this documentation. A good place to start is: tinythread.h.


This intention searches for all classes that can implement selected abstract method, and creates default method implementation there.


The code invokes hashCode on an array. Calling hashCode on
an array returns the same value as System.identityHashCode, and ingores
the contents and length of the array. If you need a hashCode that
depends on the contents of an array a
,
use java.util.Arrays.hashCode(a)
.
For any two arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b).
void checkHashcode(String [] bankNames,String [] passportNames){ if(bankNames.hashcode()==passportNames.hashcode()} // Incorrect : Always FALSE as both hashcode be different unless point to same object. { System.out.println("Hashcode Equals"); } }
void checkHashcode(String [] bankNames,String [] passportNames){ if(Arrays.hashCode(bankNames) == Arrays.hashCode(passportNames)} // Correct : Returns a hash code based on the contents of the specified array. { System.out.println("Hashcode Equals"); } }


Internationalized Domain Names in Applications (IDNA)¶
Support for the Internationalised Domain Names in Applications (IDNA) protocol as specified in RFC 5891. This is the latest version of the protocol and is sometimes referred to as “IDNA 2008”.
This library also provides support for Unicode Technical Standard 46, Unicode IDNA Compatibility Processing.
This acts as a suitable replacement for the “encodings.idna” module that comes with the Python standard library, but only supports the old, deprecated IDNA specification (RFC 3490).
Basic functions are simply executed:
# Python 3
>>> import idna
>>> idna.encode('ドメイン.テスト')
b'xn--eckwd4c7c.xn--zckzah'
>>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
ドメイン.テスト
# Python 2
>>> import idna
>>> idna.encode(u'ドメイン.テスト')
'xn--eckwd4c7c.xn--zckzah'
>>> print idna.decode('xn--eckwd4c7c.xn--zckzah')
ドメイン.テスト
Installation¶
To install this library, you can use pip:
$ pip install idna
Alternatively, you can install the package using the bundled setup script:
$ python setup.py install
This library works with Python 2.6 or later, and Python 3.3 or later.
Usage¶
For typical usage, the encode
and decode
functions will take a domain
name argument and perform a conversion to A-labels or U-labels respectively.
# Python 3
>>> import idna
>>> idna.encode('ドメイン.テスト')
b'xn--eckwd4c7c.xn--zckzah'
>>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
ドメイン.テスト
You may use the codec encoding and decoding methods using the
idna.codec
module:
# Python 2
>>> import idna.codec
>>> print u'домена.испытание'.encode('idna')
xn--80ahd1agd.xn--80akhbyknj4f
>>> print 'xn--80ahd1agd.xn--80akhbyknj4f'.decode('idna')
домена.испытание
Conversions can be applied at a per-label basis using the ulabel
or alabel
functions if necessary:
# Python 2
>>> idna.alabel(u'测试')
'xn--0zwm56d'
Compatibility Mapping (UTS #46)¶
As described in RFC 5895, the IDNA specification no longer normalizes input from different potential ways a user may input a domain name. This functionality, known as a “mapping”, is now considered by the specification to be a local user-interface issue distinct from IDNA conversion functionality.
This library provides one such mapping, that was developed by the Unicode Consortium. Known as Unicode IDNA Compatibility Processing, it provides for both a regular mapping for typical applications, as well as a transitional mapping to help migrate from older IDNA 2003 applications.
For example, “Königsgäßchen” is not a permissible label as LATIN CAPITAL LETTER K is not allowed (nor are capital letters in general). UTS 46 will convert this into lower case prior to applying the IDNA conversion.
# Python 3
>>> import idna
>>> idna.encode(u'Königsgäßchen')
...
idna.core.InvalidCodepoint: Codepoint U+004B at position 1 of 'Königsgäßchen' not allowed
>>> idna.encode('Königsgäßchen', uts46=True)
b'xn--knigsgchen-b4a3dun'
>>> print(idna.decode('xn--knigsgchen-b4a3dun'))
königsgäßchen
Transitional processing provides conversions to help transition from the older 2003 standard to the current standard. For example, in the original IDNA specification, the LATIN SMALL LETTER SHARP S (ß) was converted into two LATIN SMALL LETTER S (ss), whereas in the current IDNA specification this conversion is not performed.
# Python 2
>>> idna.encode(u'Königsgäßchen', uts46=True, transitional=True)
'xn--knigsgsschen-lcb0w'
Implementors should use transitional processing with caution, only in rare cases where conversion from legacy labels to current labels must be performed (i.e. IDNA implementations that pre-date 2008). For typical applications that just need to convert labels, transitional processing is unlikely to be beneficial and could produce unexpected incompatible results.
encodings.idna
Compatibility¶
Function calls from the Python built-in encodings.idna
module are
mapped to their IDNA 2008 equivalents using the idna.compat
module.
Simply substitute the import
clause in your code to refer to the
new module name.
Exceptions¶
All errors raised during the conversion following the specification should
raise an exception derived from the idna.IDNAError
base class.
More specific exceptions that may be generated as idna.IDNABidiError
when the error reflects an illegal combination of left-to-right and right-to-left
characters in a label; idna.InvalidCodepoint
when a specific codepoint is
an illegal character in an IDN label (i.e. INVALID); and idna.InvalidCodepointContext
when the codepoint is illegal based on its positional context (i.e. it is CONTEXTO
or CONTEXTJ but the contextual requirements are not satisfied.)
Building and Diagnostics¶
The IDNA and UTS 46 functionality relies upon pre-calculated lookup tables for
performance. These tables are derived from computing against eligibility criteria
in the respective standards. These tables are computed using the command-line
script tools/idna-data
.
This tool will fetch relevant tables from the Unicode Consortium and perform the required calculations to identify eligibility. It has three main modes:
idna-data make-libdata
. Generatesidnadata.py
anduts46data.py
, the pre-calculated lookup tables using for IDNA and UTS 46 conversions. Implementors who wish to track this library against a different Unicode version may use this tool to manually generate a different version of theidnadata.py
anduts46data.py
files.idna-data make-table
. Generate a table of the IDNA disposition (e.g. PVALID, CONTEXTJ, CONTEXTO) in the format found in Appendix B.1 of RFC 5892 and the pre-computed tables published by IANA.idna-data U+0061
. Prints debugging output on the various properties associated with an individual Unicode codepoint (in this case, U+0061), that are used to assess the IDNA and UTS 46 status of a codepoint. This is helpful in debugging or analysis.
The tool accepts a number of arguments, described using idna-data -h
. Most notably,
the --version
argument allows the specification of the version of Unicode to use
in computing the table data. For example, idna-data --version 9.0.0 make-libdata
will generate library data against Unicode 9.0.0.
Note that this script requires Python 3, but all generated library data will work in Python 2.6+.
Testing¶
The library has a test suite based on each rule of the IDNA specification, as well as tests that are provided as part of the Unicode Technical Standard 46, Unicode IDNA Compatibility Processing.
The tests are run automatically on each commit at Travis CI:


Lakota Tribe
Below is the audio recording of an instance when the Lakota Tribe performs their ritual of rain-dancing. They sing and dance enthusiastically and soon experience the rain pouring down on their lands.
Press play to hear how they connected with nature:
Time:
The Rain Calling Ritual
Among rituals of Lakota and other Native Americans are weather modification rituals such as rain dances, performed by both the men and women of the tribe.
The droughts could bring serious problems for the natives since having some rain was essential for their survival and their food crops. So, their chants would be rigrous and with a lot of conviction that they could modify weather to even invoke lightning through their songs.
The rain dance would usually take place in the driest month of the year, so usually this ritual was performed in mid to late August every year. These Native Americans wore special costumes when performing the rain dance ceremony, and these costumes were used just for this specific ceremony every year.
About The Tribe
The Lakota tribe or the people of Standing Rock are one of the first original Native American tribes who inhabited the North Americas before the arrival of Europeans.
Often referred to as the Great Sioux Nation, these people can be divided into three distinct groups based on language and geography. These groups are Dakota, Lakota, and Nakota. “Dakota” and “Lakota” means “friends” or “allies”.
By the end of the 16th century, these tribes were living in the upper Mississippi River region (present-day Wisconsin, Minnesota, Iowa, and the Dakotas).


Robot ID connect safety on safety off a1 mode nav/slam mode amcl mode slam save map navigation start navigation start loop navigation stop init pos mode init pos set wp setting wp mode add waypoint delete waypoint clear waypoints reset wp pos wp target up wp target down save waypoints load waypoints wall setting wall mode add wall delete wall clear wall save wall wall target up wall target down others connect wifi connect LTE camera up camera down bird_view start bird_view stop
Camera Gamma


Here's your own information.
Write your dynamics here
If you think you have the passion, attitude and capability to join us the next big software company s so that we can get the convers.


| dinit_spec {pomp} | R Documentation |
Specification of the initial-state distribution density evaluator, dinit.
To fully specify the unobserved Markov state process, one must give its distribution at the zero-time (t0
).
One specifies how to evaluate the log probability density function for this distribution using the dinit
argument.
As usual, this can be provided either as a C snippet or as an R function.
In the former case, bear in mind that:
The goal of a this snippet is computation of a log likelihood, to be put into a variable named loglik
.
In addition to the state variables, parameters, and covariates (if any), the variable t
, containing the zero-time, will be defined in the context in which the snippet is executed.
General rules for writing C snippets can be found here.
If an R function is to be used, pass
dinit = f
to pomp
, where f
is a function with arguments that can include the time t
, any or all of the model state variables, parameters, and covariates.
As usual, f
may take additional arguments, provided these are passed along with it in the call to pomp
.
f
must return a single numeric value, the log likelihood.
Some Windows users report problems when using C snippets in parallel computations.
These appear to arise when the temporary files created during the C snippet compilation process are not handled properly by the operating system.
To circumvent this problem, use the cdir
and cfile
options to cause the C snippets to be written to a file of your choice, thus avoiding the use of temporary files altogether.
More on implementing POMP models:
Csnippet
,
accumvars
,
basic_components
,
betabinomial
,
covariates
,
dmeasure_spec
,
dprocess_spec
,
emeasure_spec
,
eulermultinom
,
parameter_trans()
,
pomp-package
,
pomp_constructor
,
prior_spec
,
rinit_spec
,
rmeasure_spec
,
rprocess_spec
,
skeleton_spec
,
transformations
,
userdata
,
vmeasure_spec


DNA Basecaller
CPU Speed
Total Ecoli DNA: {{cputotal}}
FPGA Speed
Total EColi DNA: {{fpgatotal}}
Run


 Enter your email address below, and we’ll email instructions for setting a new one. {% csrf_token %} {{form |crispy}} {% endblock %}
Forgotten your password? Enter your email address below, and we’ll email instructions for setting a new one.


{% extends 'board/base.html' %} {% block title %}My reservations{% endblock title %} {% block body %}
| Number | Airline | Departure | Arrival | Gate | Date | Seat | Ticket | Edit | Delete | |||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {{reservation.flight.number}} | {{reservation.flight.airline}} | {{reservation.flight.dep_time|time:"H:i"}} | {{reservation.flight.arr_time|time:"H:i" }} | {{reservation.flight.gate}} | {{reservation.date|date:"d.m.Y"}} | {{reservation.seat}} | {% if reservation.ticket_number %}{{reservation.ticket_number}} | {% endif %} {% if not reservation.ticket_number %} | - | Edit | {% endif %} |


PART
: particle
Definition
Particles are function words that must be associated with another word or phrase to impart meaning and that do not satisfy definitions of other universal parts of speech (e.g. adpositions, coordinating conjunctions, or subordinating conjunctions). Particles may encode grammatical categories such as negation, mood etc. Ukrainian particles are not inflected.
Note that response words such as так “yes”, ні “no”, etc. are considered particles in grammars of Ukrainian but they are tagged as interjections under the UD standard. Also note that ні can be used in two ways, one would be translated as English “no” and the other as “nor”. Only the former should become interjection, while the latter will stay a conjunction.
Examples
- Sentence modality: но, хай, нехай (“May you have an enjoyable stay!”)
- тільки “just, only”
- аж “only, as late as, even, up to”
Treebank Statistics (UD_Ukrainian)
There are 39 PART
lemmas (1%), 39 PART
types (1%) and 319 PART
tokens (2%).
Out of 17 observed tags, the rank of PART
is: 8 in number of lemmas, 10 in number of types and 11 in number of tokens.
The 10 most frequent PART
lemmas: не, навіть, ще, ж, лише, і, й, аж, саме, таки
The 10 most frequent PART
types: не, навіть, ще, ж, лише, і, й, аж, саме, таки
The 10 most frequent ambiguous lemmas: ще (ADV 21, PART 16), і (CCONJ 271, PART 13), й (CCONJ 37, PART 11), саме (PART 7, ADV 1), то (SCONJ 8, PRON 6, PART 6, CCONJ 4), чи (CCONJ 9, PART 6, SCONJ 3), тільки (PART 5, ADV 2, SCONJ 1), просто (PART 4, ADV 1), якраз (PART 4, ADV 4), а (CCONJ 64, PART 3)
The 10 most frequent ambiguous types: ще (ADV 19, PART 14), і (CCONJ 258, PART 9), й (CCONJ 36, PART 11), саме (PART 5, ADV 1, DET 1), то (SCONJ 8, PART 4, CCONJ 4, PRON 2), чи (CCONJ 8, PART 4, SCONJ 3), тільки (PART 5, SCONJ 1, ADV 1), просто (PART 4, ADV 1), якраз (PART 2, ADV 1), а (CCONJ 46, PART 2)
- ще
- і
- й
- саме
- то
- чи
- тільки
- просто
- якраз
- а
Morphology
The form / lemma ratio of PART
is 1.000000 (the average of all parts of speech is 1.380843).
The 1st highest number of forms (1) was observed with the lemma “а”: а.
The 2nd highest number of forms (1) was observed with the lemma “аж”: аж.
The 3rd highest number of forms (1) was observed with the lemma “б”: б.
PART
occurs with 2 features: uk-feat/Polarity (144; 45% instances), uk-feat/PronType (1; 0% instances)
PART
occurs with 2 feature-value pairs: Polarity=Neg
, PronType=Prs
PART
occurs with 3 feature combinations.
The most frequent feature combination is _
(174 tokens).
Examples: навіть, ще, ж, лише, і, й, аж, саме, таки, то
Relations
PART
nodes are attached to their parents using 4 different relations: uk-dep/discourse (166; 52% instances), uk-dep/advmod (144; 45% instances), uk-dep/fixed (8; 3% instances), uk-dep/conj (1; 0% instances)
Parents of PART
nodes belong to 13 different parts of speech: VERB (171; 54% instances), NOUN (47; 15% instances), ADV (42; 13% instances), ADJ (16; 5% instances), PART (11; 3% instances), PRON (11; 3% instances), PROPN (8; 3% instances), DET (6; 2% instances), CCONJ (2; 1% instances), SCONJ (2; 1% instances), ADP (1; 0% instances), AUX (1; 0% instances), NUM (1; 0% instances)
307 (96%) PART
nodes are leaves.
11 (3%) PART
nodes have one child.
0 (0%) PART
nodes have two children.
1 (0%) PART
nodes have three or more children.
The highest child degree of a PART
node is 3.
Children of PART
nodes are attached using 5 different relations: uk-dep/fixed (7; 50% instances), uk-dep/advmod (4; 29% instances), uk-dep/cc (1; 7% instances), uk-dep/discourse (1; 7% instances), uk-dep/punct (1; 7% instances)
Children of PART
nodes belong to 4 different parts of speech: PART (11; 79% instances), ADV (1; 7% instances), CCONJ (1; 7% instances), PUNCT (1; 7% instances)
PART in other languages: [am] [ar] [bg] [bxr] [ca] [ckb] [cop] [cs] [cu] [da] [de] [el] [en] [es] [et] [eu] [fa] [fi] [fo] [fr] [ga] [gl] [got] [grc] [he] [hi] [hr] [hu] [id] [it] [ja] [kk] [kmr] [ko] [la] [lv] [mr] [nl] [no] [pl] [pt] [ro] [ru] [sa] [sk] [sla] [sl] [so] [sr] [sv] [swl] [ta] [tr] [ug] [uk] [u] [urj] [ur] [vi] [yue] [zh]


It has already been a month since we landed in Grenada, sure
does not seem like it. As with anywhere it is easy to get
into a routine and the days just fly by. We thought you
might enjoy how our days fly by, if not sorry for the following
update.
Sun rise is currently 5:52 am and the boat is bright and sleep
is hard to come by. That does not mean that we get up at
that time but sleep is something that you have to work at by
that time. To be nice to others usually you head outside
and sit in the cockpit and view the other boats and have
breakfast.
Now breakfast on our boat varies from toasted wheat bread with
lemon tea to Cinnamon Toast Crunch cereal to white bread with
nutella and yogurt. It is up to the individual what they
want for breakfast and it is a fix it yourself type of meal.
At 7:30 the local VHF cruiser net comes on the radio and that
lasts for 1/2 to 1 hour depending upon how long people talk.
The net gives the latest weather and information on any
hurricanes, any social activities that are going on either by
the locals or other cruisers, and then parts/services/items of
the bilge to be sold by other cruisers. One of the
services provided by the local businesses it the "Shopping Bus".
On Tuesday and Friday there are buses that go to the marinas
where cruisers can board them and ride to the local grocery
stores. They cost $10 EC, about $3.50 US, for the ride to
and from the store. Usually one bus, it really is just a
van, full of 15 cruisers to the store requires two bus trips on
the return trip due to the extra shopping bags.
Around 8:15 Kris is jumping into the water for water aerobics,
or noodleing as it is called here. You use a swimming
noodle to help you float in the water and then do water
exercise. The class is an hour in length and has 6 to 12
folks participating in it.
Dean usually drops Kris off and then takes Sam for his morning
walk. There are several roads/paths that are available for
the walk and depending upon how warm/humid it is the length is
subject to change. There are several other dogs on boats
and usually one or two of them are encountered during the walk.
By the time Sam gets back to the boat he is ready for his
morning/afternoon nap.
As this is going on Derek has been hard work at school.
Kris has laid out a daily school schedule and Derek has working
on it and is eagerly awaiting the teachers to return and help
him on his next subject. OK maybe eager is too strong but
Derek is happy when Dean and Kris get back to the boat to help
him with school.
By this time it is lunch and Kris makes sandwiches or heats up
leftovers for our dining pleasure. After lunch, Derek
usually heads to the beach with other kids, or they hang out at
the boat swimming and jumping off the radar arch, or inventing
other swimming games around the boat. Dean and Kris may do
some laundry, work on a boat project, do computer work, play a
game, or just relax and read a book. Kris usually finds
time for a quick nap after lunch, and sometimes Dean is caught
napping as well.
Around 5:00 Derek comes home, Dean prepares dinner and we have
time to talk as a family. We usually watch a movie, or TV
show and relax in the evening. Derek likes to play on the
computer, and Kris and Dean read or play computer games or just
like to sit and watch the boats as the sun sets.
07/27/13; A "normal" week in Grenada
|
|
|
Noodles |
Swimming and playing off the boat |
A typical "bus" |
A tired dog |
hard at school
|
|
| |
|


This cosmos map shows data from the Sloan Digitial Sky Survey and the 2dF Galaxy Redshift Survey, visualized by Samuel Hinton.
Click on a blue point above
to fly to the selected galaxy.
Double-click on a blue point
to arrive there immediately.
How do galaxies move within the cosmos? Is there a relationship between the positions of galaxies and how they move relative to us? What can these properties of galaxies tell us about the history of our universe?
In this activity, you will collect your own galaxy data to investigate these questions. You will use real spectra data to measure galaxy velocities and will measure how large or small the galaxies appear in the sky to estimate their distances.
© 2020 WWT Ambassadors program. Powered by AAS WorldWide Telescope from the American Astronomical Society, created in collaboration with WGBH for NASA's Bringing the Universe to America's Classroom project under cooperative agreement award no. NNX16AD71A.


Cultural fiesta marks Appa’s birthday celebrations
by Staff ReporterThe 85th birthday of the eighth peetadhipathi of Sharnbasaveshwar Vidya Vardhak Sangha Sharnbaswappa Appa was marked by a cultural fiesta on the main campus of Sharnbasva University here on Thursday.
The event also marked the 50th birthday celebrations of Matoshree Dakshayani Appa.
The programme started with the lighting of the ceremonial lamp by Sarangadhar Deshikendra Swami of Saranga Mutt in Srisailam. The programme also included renditions of Dasoha Sutras and the life history of Sharnbasaveshwar.
The play Jhansi Ki Rani Laxmibai, enacted by the daughter of Sharnbasawappa Appa was praised by all.
The dance performance by the daughters of Dr. Appa — Komal, Shivani, and Maheshwari — and by his two-year-old son, Doddappa, was the cynosure of all eyes.
Shivaraj Shastri from Kannada Department at the Sharnbasaveshwar institution recited a poem for Dr. Appa. Sarangadhar Deshikendra Swami and Rajshekar Shivacharya Swami of Chowdapuri Mutt praised the contribution of Dr. Appa for empowering the people of Kalyan Karnataka.
The Sharnbasaveshwar Samasthan has been equipped with the state-of-art facilities which enable the students to hone their skills.


The topics include .
Indrani Roy,
Chester Rebeiro,
Aritra Hazra,
Swarup Bhunia,
SAFARI: Automatic Synthesis of Fault-Attack Resistant Block Cipher
Implementations
IEEE Trans. on CAD of Integrated Circuits and Systems,
39,
4,
752–765,
2020.
Keerthi K.,
Indrani Roy,
Chester Rebeiro,
Aritra Hazra,
Swarup Bhunia,
FEDS: Comprehensive Fault Attack Exploitability Detection for Software
Implementations of Block Ciphers
IACR Trans. Cryptogr. Hardw. Embed. Syst.,
2020,
2,
272–299,
2020.
Gnanambikai Krishnakumar,
Kommuru Alekhya Reddy,
Chester Rebeiro,
ALEXIA: A Processor with Lightweight Extensions for Memory Safety
ACM Trans. Embedded Comput. Syst.,
18,
6,
122:1–122:27,
2020.
K. C. Sivaramakrishnan,
Stephen Dolan,
Leo White,
Sadiq Jaffer,
Tom Kelly,
Anmol Sahoo,
Sudha Parimala,
Atul Dhiman,
Anil Madhavapeddy,
Retrofitting Parallelism onto OCaml
CoRR,
abs/2004.11663,
2020.
Aditya Pradeep,
Vishal Mohanty,
Adarsh M. Subramaniam,
Chester Rebeiro,
Revisiting AES SBox Composite Field Implementations for FPGAs
Embedded Systems Letters,
11,
3,
85–88,
2019.
Manaar Alam,
Sarani Bhattacharya,
Sayan Sinha,
Chester Rebeiro,
Debdeep Mukhopadhyay,
IPA: an Instruction Profiling-Based Micro-architectural Side-Channel
Attack on Block Ciphers
J. Hardware and Systems Security,
3,
1,
26–44,
2019.
Himanshi Jain,
D. Anthony Balaraju,
Chester Rebeiro,
Spy Cartel: Parallelizing Evict+Time-Based Cache Attacks on Last-Level
Caches
J. Hardware and Systems Security,
3,
2,
147–163,
2019.
Sareena Karapoola,
Chester Rebeiro,
Unnati Parekh,
Kamakoti Veezhinathan,
Towards Identifying Early Indicators of a Malware Infection
Proceedings of the 2019 ACM Asia Conference on Computer and Communications
Security, AsiaCCS 2019, Auckland, New Zealand, July 09-12, 2019,
679–681,
2019.
Prasanna Karthik Vairam,
Gargi Mitra,
Vignesh Manoharan,
Chester Rebeiro,
Byrav Ramamurthy,
Kamakoti Veezhinathan,
Towards Measuring Quality of Service in Untrusted Multi-Vendor Service
Function Chains: Balancing Security and Resource Consumption
2019 IEEE Conference on Computer Communications, INFOCOM 2019,
Paris, France, April 29 - May 2, 2019,
163–171,
2019.
Sourav Das,
R. Harikrishnan Unnithan,
Arjun Menon,
Chester Rebeiro,
Kamakoti Veezhinathan,
SHAKTI-MS: a RISC-V processor for memory safety in C
Proceedings of the 20th ACM SIGPLAN/SIGBED International Conference
on Languages, Compilers, and Tools for Embedded Systems, LCTES 2019,
Phoenix, AZ, USA, June 23-23, 2019,
19–32,
2019.
Gnanambikai Krishnakumar,
Chester Rebeiro,
MSMPX: Microarchitectural Extensions for Meltdown Safe Memory Protection
32nd IEEE International System-on-Chip Conference, SOCC 2019,
Singapore, September 3-6, 2019,
432–437,
2019.
Jithin Pavithran,
Milan Patnaik,
Chester Rebeiro,
D-TIME: Distributed Threadless Independent Malware Execution for
Runtime Obfuscation
13th USENIX Workshop on Offensive Technologies, WOOT 2019, Santa
Clara, CA, USA, August 12-13, 2019,
2019.
Keerthi K.,
Indrani Roy,
Aritra Hazra,
Chester Rebeiro,
Formal Verification for Security in IoT Devices
Security and Fault Tolerance in Internet of Things - Technology, Communications
and Computing,
179–200,
2019.
Muhammad Arsath K. F,
Vinod Ganesan,
Rahul Bodduna,
Chester Rebeiro,
PARAM: A Microprocessor Hardened for Power Side-Channel Attack
Resistance
CoRR,
abs/1911.08813,
2019.
Gowtham Kaki,
Swarn Priya,
K. C. Sivaramakrishnan,
Suresh Jagannathan,
Mergeable replicated data types
Proc. ACM Program. Lang.,
3,
OOPSLA,
154:1–154:29,
2019.
Gowtham Kaki,
K. C. Sivaramakrishnan,
Suresh Jagannathan,
Version Control Is for Your Data Too
3rd Summit on Advances in Programming Languages, SNAPL 2019, May
16-17, 2019, Providence, RI, USA,
8:1–8:18,
2019.
Milan Patnaik,
V. Kamakoti,
Vashek Matyas,
Vojtech Rehák,
PROLEMus: A Proactive Learning-Based MAC Protocol Against PUEA
and SSDF Attacks in Energy Constrained Cognitive Radio Networks
IEEE Trans. Cogn. Comm. & Networking,
5,
2,
400–412,
2019.
Patanjali SLPSK,
Prasanna Karthik Vairam,
Chester Rebeiro,
V. Kamakoti,
Karna: A Gate-Sizing based Security Aware EDA Flow for Improved
Power Side-Channel Attack Protection
Proceedings of the International Conference on Computer-Aided Design,
ICCAD 2019, Westminster, CO, USA, November 4-7, 2019,
1–8,
2019.
Sugandha Tiwari,
Neel Gala,
Chester Rebeiro,
V. Kamakoti,
PERI: A Posit Enabled RISC-V Core
CoRR,
abs/1908.01466,
2019.


Great Forest [am27], forest, in Mandoria, peasants: 101
Last updated Turn #148
Great Forest [am27], forest, in Mandoria, peasants: 101
------------------------------------------------------------------------
7: New noble [z1s], refugee, went east.
21: It has begun to rain.
22: New noble [d8r], refugee, arrived from the west.
24: New noble [d8r], refugee, went east.
Routes leaving Great Forest:
North, forest, to Great Forest [al27], 8 days
East, forest, to Great Forest [am28], 8 days
South, forest, to Great Forest [an27], 8 days
Garrison [en3j], garrison, uncontrolled, with four peasants
West, forest, to Great Forest [am26], 8 days
It is raining.
Seen here:
Stack of cyclops [dx2j], cyclops, number: 15
Mob [ee4y], angry peasants, number: 23, on guard
New noble [d8r], refugee


NYCAASC 2017 Workshops
<< Back to NYCAASC 2017Track 2
#Fight4AAS: Asian American Studies Now!
Room 375
Description: What is Asian American Studies (AAS), and why is it so important? This workshop will provide an overview of the struggle for Asian American Studies with a focus on the history of AAS at Cornell University and CUNY. The panelists will trace the organizing efforts for AAS on both campuses, from its inception to current student and faculty efforts. The panel will feature Cornell's Asian Pacific American Alliance (APAA) and the Coalition for the Revitalization of Asian American Studies at Hunter (CRAASH)'s campaigns for an Asian American Studies major and ways in which current students can help support both campaigns.
Speakers
Jeremiah Kim
Cornell APAA
Jeremiah Kim is a sophomore in the College of Arts and Sciences at Cornell University. His current plan is to graduate from Cornell with a major in English (concentrating on Minority, Third-World, and Indigenous literatures) and a minor in Asian American Studies. Jeremiah's crowning achievements include learning how to cook 된장찌개 (soybean paste stew) from Youtube celebrity Maangchi and writing a 25-page research paper exploring queer representation in Steven Universe.
Curtis Ho
Cornell APAA
Curtis Ho is currently suffering at Cornell University, studying Fine Arts. Curtis is doubly somewhat unqualified to be here, being Canadian and having never taken an AASP course. He enjoys eating ice cream, staying awake in class, and learning new American customs.
Alice Li
Cornell APAA
Alice is a Junior at Cornell University and is studying Operations Research and Information Engineering. She works at the Asian and Asian American Center and is a member of Asian Pacific Americans for Action at Cornell. She loves learning, reading, and traveling.
Kevin Park
CRAASH
Linda Luu
CRAASH
Linda Luu is a senior at Hunter College studying Sociology and Asian American Studies and is passionate about mental health in immigrant and refugee communities. She organizes as the President of the Coalition for the Revitalization of Asian American Studies at Hunter and founded Youth Radical Reading, Arts, and Discussion- a social justice education program for high school youth.
Eunnuri Yi
Cornell APAA
Eunnuri Yi is a freshman in the College of Arts and Sciences at Cornell University, majoring in Biological Sciences and hopefully also Comparative Literature. She has not yet taken an AAS course at Cornell, but spends most of her time between classes in the AAS Resource Center, writing last-minute Korean compositions and generally trying to get her act together. In her free time, Nuri enjoys making kimchi fried rice, scheming with her suitemates, and talking about plants.


pipiens mosquitoes saliva infectious virus Culex WNV viral Cx. RVFV day Rift Valley []. particles fever mosquito {border-style strains Nile infection number px;} #ffffff;} days West Med vector collected (Figure DIRs Trop dissemination Hyg test: transmission Maghreb able blood-meal competence disseminated exact strain Institut Pasteur Tunisia containing females infected mosquitoes. populations transmit (Fisherâ€™s Clone PFU/mL different exposure logPFU px; tested using {font-family .Â±. Algeria Dis Entomol Figure Morocco RVFV, TRs Vero [], capable estimated font-size incubation midgut pi, Aedes RVF RVFV. Soc Virus collection double; outbreaks present rate significant sites titer ÂµL A_AU DIR Pathol Tabarka Thus, anautogenous autogenous border-color border-width cells challenged developed ensure head high isolated likely maintained saliva. samples solid; squashes used vectors {font-style {font-weight â€" (AU) A_AN Aboveground Africa Exot Infect Morocco, Underground Urban avirulent blood bold cells. comparisons courier; deliver des detected difference distributed em; epizootic exposed feeding forced horses human mean p>.). period pi. presence pt;} required role salivation site, technique. transmitted varying viruses widely Â°C.


{{ partial "head.html" . }}
{{ partial "top.html" . }} {{ partial "nav.html" . }}
Challenge on Tweet Engagement Prediction
{{ .Content }}
i {{ partial "footer.html" . }}
{{ partial "scripts.html" . }}


management_layer.permission.decorator module¶
The permission module exposes a decorator that can be used to protect function calls by specifying the permissions required to execute the function.
-
management_layer.permission.decorator.
requester_has_role
(request_field: Union[int, str] = 0, body_field: Union[int, str] = None, target_user_id_field: Union[int, str] = None, target_invitation_id_field: Union[int, str] = None, role_id_field: Union[int, str] = None, domain_id_field: Union[int, str] = None, site_id_field: Union[int, str] = None, nocache: bool = False) → Callable[source]¶ This function is used as a decorator to protect functions that add and remove roles on domains and sites to users, e.g. ``` @requester_has_role() def usersiterole_create(request, body, **kwargs):
pass` The body must contain the user_id of the recipient, the role_id of the role that must be assigned and the site_id of the site for which the user will must get the role. `
@requester_has_role() def usersiterole_delete(request, user_id, site_id, role_id, **kwargs):pass``` The user making the request is inferred from the token passed with the request.
IMPORTANT: This decorator can be applied to both coroutines and normal functions AND it always changes the decorated function into a coroutine, meaning it must be called using await: ``` @requester_has_role() def doSomething(request, body):
pass# Call the function result = await doSomething(request, body) # Decorator change function to coroutine ```
Parameters: - request_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the request parameter.
- body_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the body parameter. The body parameter is a dictionary that can contain a user_id, role_id and either a site_id or domain_id, depending in the call.
- target_user_id_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the user_id field of the target user, i.e. the user for which a role must be set or removed.
- target_invitation_id_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the invitation_id field of the target invitation, i.e. the invitation for which a role must be set or removed.
- role_id_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the role_id field.
- domain_id_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the domain_id field.
- site_id_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the site_id field.
- nocache – Bypass the cache if True
Raises: Forbidden if the user does not have the role that is being invoked or revoked.
-
management_layer.permission.decorator.
require_permissions
(operator: Callable[..., bool], resource_permissions: Sequence[Tuple[Union[str, int], Union[str, int]]], nocache: bool = False, request_field: Union[int, str] = 0, target_user_field: Union[int, str] = None, allow_for_management_portal=False) → Callable[source]¶ This function is used as a decorator to restrict functions by specifying the permissions that a user requires to perform the action, e.g. ``` @require_permissions(all, [(“urn:ge:test:foo”, “write”)]) @require_permissions(any, [(“urn:ge:test:foo”, “read”),
(“urn:ge:test:bar”, “read”])- def doSomething(request, arg1, arg2):
- pass
` As can be seen from the example above, the decorator can be stacked. Note, however, that for performance reasons the least amount of decorators is preferred. `
# Logically correct, but suboptimal performance @require_permissions(all, [(“urn:ge:test:foo”, “write”)]) @require_permissions(all, [(“urn:ge:test:bar”, “write”)]) @require_permissions(all, [(“urn:ge:test:baz”, “write”)]) def badExample(request, arg1, arg2):pass# Logically equivalent to the decorators of example above and more efficient @require_permissions(all, [(“urn:ge:test:foo”, “write”),
(“urn:ge:test:bar”, “write”), (“urn:ge:test:baz”, “write”)])- def goodExample(request, arg1, arg2):
- pass
` This function requires the the user who made the request as well as the site from which the request originated (or is made on behalf of) in order to look up roles associated with the user. The user and site UUID values are read from the token associated with the request field passed to the decorated function. By default we use the first argument as the request field. This can be changed in the decorator, e.g. `
@require_permissions(all, [(“urn:ge:test:baz”, “write”)],request_field=2)- def example1(arg1, arg2, request):
- pass
- @require_permissions(all, [(“urn:ge:test:baz”, “write”)],
- request_field=”request”) # “request” in kwargs
- def example2(arg1, **kwargs):
- pass
IMPORTANT: This decorator can be applied to both coroutines and normal functions AND it always changes the decorated function into a coroutine, meaning it must be called using await: ``` @require_permissions(all, [(“urn:ge:test:foo”, “write”)]) def doSomething(request):
pass# Call the function result = await doSomething(request) # Decorator change function to coroutine ```
IMPORTANT: When a function call relates to a particular user, the user does not explicitly require permissions on that resource for it to be allowed. A user implicitly has access to anything directly related to his profile. ``` @require_permissions(all, [(“urn:ge:user”, “read”)], target_user_field=1) def read_user_data(request, user_id):
pass``` In the example above, if the user specified by the token in the request is the same user as the one identified by the function argument “user_id”, then the call is allowed.
IMPORTANT: The Management Portal may make requests on behalf of the other sites. To facilitate this, we look at the X-GE-Portal-Context header in the request:
- If the header is not present, the context to use is the “audience” of the requesting token.
- If the header is present and the “audience” of the requesting token is not the Management Portal, then return Forbidden.
- If the header is present and the “audience” of the the requesting token is the Management Portal, then use the context specified to look up the user’s permissions. (If the specified context does not exist, return BadRequest).
IMPORTANT: The Management Portal needs to be able to perform certain calls (list sites and domains, for instance) even if the user does not have explicit permissions to do this. For API calls like these, use the allow_for_manangement_portal flag, e.g. ``` @require_permissions(all, [(“urn:ge:access_control:domain”, “list”)],
allow_for_management_portal=True)- def domain_list(request, **kwargs):
- pass
Parameters: - operator – any or all
- resource_permissions – The resource permissions required
- nocache – Bypass the cache if True
- request_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the request parameter.
- target_user_field – An integer or string identifying either the positional argument or the name of the keyword argument identifying the target user parameter.
- allow_for_management_portal – A boolean flag indicating whether access is implied when the request is made by the management portal
Raises: Forbidden if the user does not have the required permissions.


This is bitcoinjs-gui, the open-source Bitcoin client in pure JavaScript.
The software is developed and supported by the BitcoinJS project.
Bitcoin is a decentralized, open-source payment network and currency. You can learn more about it on Bitcoin.org and WeUseCoins.com.


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| FirstPersonControl.js | 1.22% | 1/82 | 0% | 0/59 | 0% | 0/11 | 1.22% | 1/82 | |
| GestureMgr.js | 7.69% | 3/39 | 0% | 0/22 | 0% | 0/8 | 7.69% | 3/39 | |
| InfinitePlane.js | 18.06% | 13/72 | 0% | 0/12 | 25% | 1/4 | 18.06% | 13/72 | |
| OrbitControl.js | 1.23% | 3/243 | 0% | 0/110 | 0% | 0/42 | 1.23% | 3/243 | |
| Skybox.js | 88.89% | 24/27 | 50% | 4/8 | 77.78% | 7/9 | 88.89% | 24/27 | |
| Skydome.js | 76.92% | 20/26 | 50% | 4/8 | 62.5% | 5/8 | 76.92% | 20/26 |


Slurm¶
Description¶
This role provides slurm configuration for server, client and login nodes.
Instructions¶
IMPORTANT: first thing to do is to generate a new munge key file. To do so, go into files folder of the role and generate a new munge.key file using:
dd if=/dev/urandom bs=1 count=1024 > munge.key
We do not provide default munge key file, as it is considered a security risk.
Then, in the inventory addon folder (inventory/group_vars/all/addons) that should be created if not exist, add a slurm.yml file with the following content, tuned according to your needs:
slurm:
slurm_packaging: after_17 # Can be before_17 or after_17. If using BlueBanquise packages, use after_17. For OpenHPC 1.3, use before_17.
cluster_name: bluebanquise
control_machine: management1
MpiDefault: pmi2 # Optional
nodes_equipment_groups:
- equipment_typeC
To use this role for all 3 types of nodes, simply add a vars in the playbook when loading the role. Extra vars is slurm_profile.
For a controller (server), use:
- role: slurm
tags: slurm
vars:
slurm_profile: controller
For a compute node (client), use:
- role: slurm
tags: slurm
vars:
slurm_profile: node
And for a login (passive client), use:
- role: slurm
tags: slurm
vars:
slurm_profile: passive
To be done¶
slurmdbd + mariadb
static file
Changelog¶
1.0.2: Update role, remove munge key. Benoit Leveugle<EMAIL_ADDRESS>1.0.1: Documentation. Benoit Leveugle<EMAIL_ADDRESS>1.0.0: Role creation. Benoit Leveugle <benoit.leveugle@gmail.com>


APC close to victory in Bayelsa governorship election
by Oladeinde OlawoyinThe All Progressives Congress (APC) governorship candidate, David Lyon, has taken a significant lead in the ongoing Bayelsa State governorship election.
In the results announced thus far at the collation centre in Yenagoa on Saturday, Mr Lyon has won in four of the six local governments. The candidate of the Peoples Democratic Party, Duoye Diri, won in the other two.
The APC candidate has scored a total of 206,260 votes from the six local governments while the PDP candidate has 119,930 votes and thus trails Mr Lyon by 86,330 votes.
Bayelsa State consists of eight local government areas including Brass, Ekeremo, Kolokuma/Opokuma, Nembe, Ogbia, Sagbama, Southern Ijaw and Yenagoa. The six local governments whose results have been announced so far include Brass, Kolokuma, Nembe, Ogbia, Sagbama and Yenagoa.
The two remaining local governments whose results are yet to be announced are Southern Ijaw, the stronghold of the APC candidate, and Ekeremo LGA.
In the results collated so far, Mr Lyon defeated Mr Diri in Nembe by polling 83,041 votes. Mr Diri, on his part, polled 874 in the local government.
In Brass LGA, the APC candidate polled 23,831 votes while the PDP candidate polled 10, 410 votes.
In Kolokuma/Opokuma, the APC had 8, 934 votes while the
PDP had 15,360.
In Sagbama, Mr Diri of the PDP polled 60,339 votes to beat Mr Lyon who polled 7831.
In Ogbia, the PDP polled 13,763 votes while the APC polled 58,016 votes.
In Yenagoa, the APC candidate polled 24,607 votes while the PDP polled 19,184 votes.
Results from Ekeremo and Southern Ijaw were being awaited as at the time of filing this report.
A one-hour break was announced at the Collation Centre in Yenagoa.


Refreshed Mitsubishi Mirage hatch and G4 sedan debut in Thailand
Bring new front and rear fascias and interior upgrades
by Jonathon RamseyAfter Mitsubishi teased its global compact twins earlier this month, the Mirage hatchback and Attrage sedan — called the Mirage G4 here — greeted the public in Thailand. These appear to be cosmetic adjustments only, Mitsubishi mum so far on any powertrain changes. Both vehicles now wear the Dynamic Shield corporate face with "styling [that] sweeps round from the sides toward the middle of the nose in a protective embrace." At the edges of the red-trimmed grille strakes, restructured headlights now incorporate LEDs. In back, vehicle edges have been drawn more square and vertical. Below the revised taillights, the bumpers feature cutouts at their edges that house reflectors.
Interior revisions on all trims include soft-feel cloth for hand-rest areas like the door card, new designs for the front armrests, and a carbon fiber pattern for the gauge cluster background and the window switch panel. Higher trims can be optioned with new seat designs, solid-colored synthetic leather in the sedan, and a mix of fabric and synthetic leather in the hatch, each with complementary piping and stitching. Another new option will be Mitsubishi's Smartphone Display Audio infotainment with a seven-inch screen and compatibility with Android Auto and Apple CarPlay.
Both cars expand their color palettes with a White Diamond hue, and the hatchback adds Sand Yellow as well. Wheel designs get in on the upgrades, the hatch benefiting from a 15-inch two-tone, diamond-cut wheel, the sedan wheel coming in a solid silver finish. Assuming engines don't change when the redesigned bodywork goes on sale here, the 1.2-liter three-cylinder with 78 horsepower and 74 pound-feet of torque will be our only option, shifting through either a five-speed manual or a CVT.


Avdalovic leads N. Arizona over Benedictine Mesa 93-56
by The Associated PressFLAGSTAFF, Ariz. (AP) — Luke Avdalovic had 16 points to lead five Northern Arizona players in double figures as the Lumberjacks rolled past Benedictine Mesa 93-56 on Wednesday night.
Cameron Shelton added 14 points and seven rebounds for the Lumberjacks. Brooks DeBisschop had 13 points and eight rebounds, Bernie Andre scored 11 points with nine rebounds and Nik Mains had 10 points and four steals.
Austin Denham had 12 points and eight rebounds for the Redhawks. Tre Carolina added 12 points and Antowine Locke Jr. had 10 points and six rebounds.
Northern Arizona (2-1) matches up against South Dakota at home next Saturday.
___
For more AP college basketball coverage: https://apnews.com/Collegebasketball and http://twitter.com/AP_Top25
___
This was generated by Automated Insights, http://www.automatedinsights.com/ap, using data from STATS LLC, https://www.stats.com
The Associated Press


Share your shelter design openly
Contribute to the Open Shelter Database by sharing your shelter design as open data.
Other people will be able to find your shelter and use it for humanitarian sheltering.
{% extends "layout.html" %} {% block wrapper_start %}
Contribute to the Open Shelter Database by sharing your shelter design as open data.
Other people will be able to find your shelter and use it for humanitarian sheltering.
The Open Shelter Database provides you with the opportunity to share the design of your shelter solution in an open platform where worldwide experiences are gathered and organised to support humanitarian sheltering actors in the design of more efficient and effective interventions.
Adding your project will make critical technical information freely accessible worldwide. It will support agencies and even affected communities themselves in building back better, therefore enhancing the resilience of disaster-hit communities.
Step 1 of 7
Step 2 of 7
Step 3 of 7
Step 4 of 7
Step 5 of 7
Step 6 of 7
Step 7 of 7
Thank you for entering your shelter in the shelter database. Your shelter will be visible in the database after a short review by the administrator. We kindly request you to add additional data about your shelter, such as technical documentation and drawings, and different attributes. You can start to add more details about your shelter by clicking the button below, or by clicking on your name on the top right and choose 'your shelters'.


Publications
Overview
In preparation/under review
-
Zuidema W., Hupkes, D., Wiggins G., Scharf C. and Rohrmeier M. (under review). Formal models of Structure Building in Music, Language and Animal Song. for: Musical Animals book.
-
Nielsen A., Hupkes D., Kirby S. and Smith K. (in prep). The arbitrariness of the sign revisited: An examination of the roles of phonological similarity and task construction in an artificial language learning paradigm.
2016
-
Veldhoen S., Hupkes D. and Zuidema W. (2016). Diagnostic Classifiers: Revealing how Neural Networks Process Hierarchical Structure. Cognitive Computation: Integrating Neural and Symbolic Approaches, NIPS 2016.
[bibtex] [paper] [poster] -
Hupkes D. and Bod R. (2016). POS-tagging of Historical Dutch. In N. Calzolari, K. Choukri, T. Declerck, S. Goggi, M. Grobelnik, B. Maegaard, J. Mariani, H. Mazo, A. Moreno, J. Odijk and S. Piperidis (eds) Proceedings of the Tenth International Conference on Language Resources and Evaluation (LREC 2016).
[bibtex] [paper] -
Nielsen A., Hupkes D., Kirby S. and Smith K. (2016). The Arbitrariness Of The Sign Revisited: The Role Of Phonological Similarity. In S.G. Roberts, C. Cuskley, L. McCrohon, L. Barceló-Coblijn, O. Fehér & T. Verhoef (eds.) The Evolution of Language: Proceedings of the 11th International Conference (EVOLANG11). Available online: http://evolang.org/neworleans/papers/126.html
[bibtex]


This document contains “errors” - the output shouldn’t match what was intended, but it shouldn’t crash MMD.
This is a missing link reference [some text][missing] and ![missing image][missing2].


Presentation Seconds per Slide Max. Width Max. Height Auto-Fit History Store Search History (Up to 100 queries are saved.Let me know if there is an issue.) Clear Search History View All Favorites Issues or suggestions: GitHub


{{locate.items.counties}}
| Total Population | Median Age | White | Black | Hispanic | Asian |
|---|---|---|---|---|---|
| {{locate.items.population}} | {{locate.items.age}} | {{locate.race.white}} | {{locate.race.black}} | {{locate.race.hispanic}} | {{locate.race.asian}} |
| Median household income | Unemployment rate | Income below $10,000 | Income between $15,000-$25,000 | Income between $25,000-$100,000 | Income over $100,000 |
|---|---|---|---|---|---|
| {{locate.income.median}} | {{locate.income.unemploy}} | {{locate.income.poverty}} | {{locate.income.twenty}} | {{locate.income.hundred}} | {{locate.income.oneHundredPlus}} |


Home
Speakers
Sessions
Agenda
Community Event 6/23
Pluralsight Courses
More
Videos
News
Community Event 6/23
Pluralsight Courses
Follow us on:
login
Login
Forgot Password
Call For Speakers
Angular U
Pluralsight Courses
Course Author
Plurasight Course(s)
Dan Wahlin
Courses
John Papa
Courses
Douglas Crockford
Courses
Misko Hevery
Courses
Ward Bell
Courses
Andrew Connell
Courses
Joe Eames
Courses
Deborah Kurata
Courses
Lukas Ruebbelke
Courses
Peter Kellner
Courses
Justin Schwartzenberger
Courses
Kyle Simpson
Courses
Premiere Sponsor
Gold Sponsors
Silver Sponsors
Media Partners
Become a sponsor


@@include("partials/head.html") @@include("partials/header.html")
Have someone in mind as a potential guest for Query? Fill out the form below and I'll see if we can add them into the schedule. This can include yourself!
*I will not share this publicly. I just want to get a feel for how the business is doing.


I think I often use the technique of assuming the other person is a good person until proven otherwise. It mostly works out well, I don't often encounter issues with people when I have assumed they are a good person from the outset.
I did the formal listening exercise with my husband and it went well. We were both able to relay how each other was feeling and feel like the other understood the feelings and why we had them.
It was interesting. It's so easy to become completely selfish and forget that other people are trying to live in harmony with other people the same way you are, and not just thrown into th emix as hurdles/tests/support specifically for you to overcome. I think it was good to spend a few minutes thinking about them as their own "player one", and not just an NPC.
My husband and I were supposed to go to London in September 2015 to live, and had booked one way flights there. We ended enjoying our honeymoon so much that we purposefully missed our flight so that we could continue travelling through Latin America. My sister then got engaged and had a short engagement so we had to return to NZ for the wedding which was not in the plan. We decided to come to NZ for 6 months to work and save, and attend the wedding, and then move to London. We ended up settling here, buying a house and not going to London. Each year we were supposed to go to London to visit, but something always came up like no money, other family holidays, etc. We decided 2018 was they year we would go, and then we found out my husband's best friend was gettin married in London in 2019. My perspective: I wanted to put off the trip for one more year. We couldn't afford to go to London 2 years in a row, and since we would need to go in 2019 anyway I thought that was the better year to go. His perspective: We have been together for 8 years, married for 3 of those, and I still haven't been to London with him and seen where he grew up, or met a lot of his friends. Every time in the past that we had said we would go to London this year something had come up that prevented us going and he wasn't going to let that happen again. We are just going to have to figure out a way to be able to afford to go 2 years in a row.
I think it's very interesting but makes sense that we empathise more with those that we feel more similar to, both on a physical and mental level.


pzplUI For VSCode
Code faster with the new pzplUI extension for VSCode.
Download
How to install?
Go to the extensions panel
Click on the 3 dots over the search bar
Select install from VSIX
Select the downloaded file
???
Profit!


{% extends "global/Page.html" %} {% load otree static %} {% block title %} Round Decision {{ subsession.round_number }} {% endblock %} {% block styles %} {% endblock %} {% block content %} {% if round_number > 1 %}
You chose:
to pay {{ cost_high }} pts for Participant 2 to receive {{ benefit_high }} pts.
{% else %}to pay 0 pts for Participant 2 to receive 0 pts.
{% endif %}Participant 2({{ opponent_high_id }}) chose:
to pay {{ cost_high }} pts for you to receive {{ benefit_high }} pts.
{% else %}to pay 0 pts for you to receive 0 pts.
{% endif %}
You chose:
to pay {{ cost_low }} pts for Participant 3 to receive {{ benefit_low }} pts.
{% else %}to pay 0 pts for Participant 3 to receive 0 pts.
{% endif %}Participant 3({{ opponent_low_id }}) chose:
to pay {{ cost_low }} pts for you to receive {{ benefit_low }} pts
{% else %}to pay 0 pts for you to receive 0 pts
{% endif %}
Below are your two options for Task A and Task B, respectively. You need to make a choice in each task to continue.


Subutai was developed with the aim of disrupting, democratizing, and commoditizing Cloud and Internet of Things (IoT) services through the following products:
Open Source, container-based P2P Cloud and IoT software and firmware.
A marketplace to buy/sell/exchange/barter devices, cloud applications, and idle computer resources.
Power-efficient “green” broadband Cloud router and open hardware IoT gateway that serves as a plug-and-play cryptocurrency wallet and mining device.
As Internet and Cloud consumers can only currently purchase services from providers, Subutai acts as “the Airbnb of computing resources”, leveraging the power of peer economics to enable individual and business users to both buy and sell cloud services. Subutai is:
Subutai can be immediately applied across countless application areas in both commercial and private use. The platform is proven, mature (v6.0), solves real-world problems, and is ready to use today. Users are free to choose to utilize one, some, or all Subutai products; the Bazaar and Blockchain Router are optional.
Subutai brings Open Source P2P Cloud computing, IoT, and cryptocurrency mining to everyone. Conquer the Cloud!
Subutai™ Blockchain Router
Subutai originated as a multi-million dollar defense project for a new P2P Cloud computing platform that could reconfigure itself dynamically and securely across the Internet. After the project was completed, the client allowed the software to be open sourced, and, since 2013, our company, OptDyn, has been dedicated to make this software available to everybody.
Subutai creator and OptDyn CTO Alex Karasulu explains how the platform works, and the promise of P2P Cloud Computing:
Subutai lets anyone share socially (among peers), or commercially “rent” computer resources to create P2P cloud environments while also connecting whatever devices are around to them. In a nutshell, we simply call it "Peer-to-Peer (P2P) Cloud Computing". We think this is totally badassed mind explosion-inducing madness: that's why we named it after a badassed general. We think Subutai is going to conquer the world, and want you to join us in the "War Room" to help lead the campaign.
We've been coding up a storm using every advantage we can gain from the latest emerging technologies to make the jaw dropping magic happen. We're shocked and get goosebumps every time we see it working ourselves; we fire up our own clouds across developer machines because we just CAN. It's sick! Now it's time for us to share the magic with everyone else. Welcome to the P2P Cloud Computing Revolution!
We tried hard to use all the good stuff so many of you like and know about. We went with Snappy for the underlying package manager for our PeerOS. Snappy and an OSGi-based component architecture allows live transaction micro reboots with Over-the-Air updates so tenant environments keep running on peers without disruption. We use lightweight Linux containers and software defined networking with strong encryption and a boat load of security mechanisms to isolate and protect environments running across Subutai peers.
We don't want to reinvent the wheel. However some components just did not exist, we had no choice but to implement the IaaS basement due to P2P considerations. But we're working hard to adapt it to services you're used to at Amazon AWS. We've got Ceph and standard S3 like interfaces you can just drop into your environments.
We're doing great on the PaaS layer since we went with the best: the Google App Engine (GAE) programming model. We've integrated AppScale as a first-class citizen into Subutai. So write apps in Go, Java, PHP, or Python and drop ‘em into your Subutai P2P Cloud. With Subutai every GAE app you write becomes a P2P application: distribute it where and how you like --even across Google's own infrastructure. The choice is yours again. It's always nice to have choices.
And we’ve got Subutai Blueprints that specify general instructions for installing, updating and maintaining P2P distributed cloud applications. The Subutai P2P Cloud combines these instructions with load and resource availability information to optimally place infrastructure resources in P2P cloud environments and run distributed applications. P2P orchestration can occur perpetually to adapt to shifting conditions to keep applications running. Mobile devs: you got an Apache Usergrid Blueprint for MBaaS! Need we say more?
Using Subutai you can use your existing relationships (friends, family, colleagues, etc.) to build your own virtual data center and stuff whatever you like into it. The best thing about this is that you're free of "The Man", you're the boss, the head honcho. You own and control your own stuff!
Wanna make some coin, some extra money? You can sell resources on your laptop or desktops that are sitting around collecting dust. Put ‘em to use on your own peer. To help out we built a peer tracker, resource search engine, and a marketplace where you can trade or sell resources to your heart's content: Subutai Bazaar.
Running out of space for the family photos no one's willing to clean up? Create a distributed storage network across the machines of family members. Don't deal with mom trying to figure out how to send you photos of your kids again. Share with your own “dropbox” distributed across family and friends!
Some say the cloud reduces costs. That all depends on perspective and what era you compare the cloud to! We work in teams so we share resources for building collaborative private infrastructures: lots of distributed startups can use Subutai.
If you've ever rapidly downloaded files via Torrent, you've already experienced the power gained by P2P technology for file sharing. The files download much faster right? That's because separate parts of the file are downloaded in parallel from different peers instead of downloading the whole file from a single server that everyone pulls from. The cumulative bandwidth of all peers speed up the download without causing traffic congestion at a single server. Torrent peers participate in a single public swarm for P2P file sharing.
Imagine being able to use P2P technologies to share more than just files, but also to share any hardware resource (RAM, CPU, DISK, NET), with ONLY those peers you trust. You may create virtual cloud environments connected to devices with resources shared across several peers on your own swarm. The ability to share any hardware resource allows P2P cloud environments to gain resources and grow beyond what's available locally at a single peer. Unimaginable services start to seem possible when one considers the limitless potential of P2P cloud computing.


---
layout: blogpost
title: Weekend Excursions - First month in Europe
comments: true
date: 5th October 2016
pc: Silva, Prayaag, Gaurav, Sagar, Pabitra, Manish, Alap, Kavitha, Rama
---
Preface
Travelogue of weekend excursions taken during first month of exchange semester at RWTH Aachen, Germany (September 2016-17)
It was the last weekend of this month. We decided to make a short trip to Kelmis, the neighbouring Belgian town, before our bus pass expired at the end of the month. Taking a direct bus from Aachen Busof, we reached Kelmis late in the afternoon and walked around a small beautiful lake surrounded by forest.
A hiking trail led through the forest. Google maps showed a place called ‘Rocher du Casino’ at the end of the trail. Everyone got excited at the prospect of going in a casino and we started walking along the picturesque trail. The weather was perfect too, cool breeze and sunshine!
When we reached the location pointed by google maps, we were in for a great surprise! Instead of a 'casino', there was a rock climbing arena. ‘Rocher du Casino’ (French) means ‘The Rock Casino’ and apparantly, the name of that small lake was ‘Casino’ . We were astonished to see how effortlessly the rock-climbers were climbing the huge cliff. Initially, the more experienced would climb up and fit safety clamps along the way. Then the others would follow one by one.
When returning back to the town, we took a detour along the trail and got to see some stunning panoramas.
The next location on our list was a museum in Kelmis. Unfortunately, it was closed at that time. Luckily, we got to see a football match between the local teams at a field nearby.
After the match was over, the sky got covered with clouds and it started to drizzle. So, we decided to call it a day and boarded the bus back to Aachen. This refreshing short trip took our european country count to ‘3’: Germany, Netherlands and now ‘Belgium’ (well, technically the Drielandenpunt is sufficient to 'visit' these 3 countries..)!


lpoptions
Section: Apple Inc. (1)Updated: CUPS
Index Return to Main Contents
NAME
lpoptions - display or set printer options and defaultsSYNOPSIS
lpoptions [ -E ] [ -U username ] [ -h server[:port] ] -d destination[/instance] [ -o option[=value] ] ... [ -o option[=value] ]lpoptions [ -E ] [ -U username ] [ -h server[:port] ] [ -p destination[/instance] ] -l
lpoptions [ -E ] [ -U username ] [ -h server[:port] ] [ -o option[=value] ] ... [ -o option[=value] ] [ -p destination[/instance] ] -r option
lpoptions [ -E ] [ -U username ] [ -h server[:port] ] -x destination[/instance]
DESCRIPTION
lpoptions displays or sets printer options and defaults. lpoptions shows the default printer options when run with no arguments. Other options include:- -E
-
Enables encryption when communicating with the CUPS server. - -U username
-
Uses an alternate username. - -d destination[/instance]
-
Sets the user default printer to destination. If instance is supplied then that particular instance is used. This option overrides the system default printer for the current user. - -h server[:port]
-
Uses an alternate server. - -l
-
Lists the printer specific options and their current settings. - -o option[=value]
-
Specifies a new option for the named destination. - -p destination[/instance]
-
Sets the destination and instance, if specified, for any options that follow. If the named instance does not exist then it is created. - -r option
-
Removes the specified option for the named destination. - -x destination[/instance]
-
Removes the options for the named destination and instance, if specified. If the named instance does not exist then this does nothing.
If no options are specified using the -o option, then the current options for the named printer are reported on the standard output.
Options set with the lpoptions command are used by the lp(1) and lpr(1) commands when submitting jobs.
ROOT ACCOUNT OPTIONS
When run by the root user, lpoptions gets and sets default options and instances for all users in the /etc/cups/lpoptions file.COMPATIBILITY
The lpoptions command is unique to CUPS.FILES
~/.cups/lpoptions - user defaults and instances created by non-root users./etc/cups/lpoptions - system-wide defaults and instances created by the root user.
SEE ALSO
cancel(1), lp(1), lpadmin(8), lpr(1),http://localhost:631/help
COPYRIGHT
Copyright 2007-2009 by Apple Inc.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:05 GMT, December 24, 2015