Version: 0.1.2 (Dec 17, 2011)
Agility is a Model-View-Controller (MVC) library for client-side Javascript with some specific design principles:
The overall goal is to improve code maintainability without sacrificing productivity. It is inspired by the principles behind Ruby on Rails and jQuery.
Agility's programming model is framed around the concept of self-contained MVC objects, where each object can be the prototype of, as well as the container of other MVC objects. This level of abstraction should encompass most applications.
See the home page for a quick overview of its syntax and usage.
One might wonder, since DOM-querying/Ajax libraries like jQuery make it so easy to whip up a dynamic web app, why bother with an additional layer of complexity?
For those who have built a complex web app "organically", i.e. purely through DOM querying and manual Ajax calls, the answer is immediate: although you were able to get that app up to speed so quickly, you probably dread maintaining and relearning that intertwined code, and wish you had known better!
For those who haven't, some things you will likely end up doing with a pure jQuery-esque solution include: storing data in the DOM; querying the DOM to find your data; defining global callbacks to DOM events e.g. click/input change; having those callbacks neatly package your data to be sent to the server; retrieving data from the server and inserting them in the DOM with the right format and event handlers; etc.
Though that's all fine initially, sooner or later you will start running into maintainability problems: storing data in the DOM is very brittle, e.g. changing an id/class or restructuring the DOM requires revisiting the code just about everywhere; DOM elements that are logically related and need to be always in sync require manual updates in all callbacks associated with them; global callbacks lead to name collisions and hence cumbersome function names, as well as difficulties in finding just what function is responsible for doing X or Y; defining functions that package data for, or present data after Ajax calls is unnecessarily repetitive; etc.
One established answer to these problems is the Model-View-Controller approach, where your app is organized in "large" objects each having different parts responsible for managing content (Model), format/style (View), and behavior (Controller). For example, a series of DOM input elements such as Name, Address, Phone, etc, related to the abstract concept of "person" become part of an object "person", whose model contains the raw data, view contains the HTML/CSS presentation, and controller contains the actions that will be called in response to events in the former two.
MVC libraries like Agility typically offer built-in model, view, and controller methods that encompass most use case scenarios, so you don't have to reinvent the wheel or repeat yourself. That way all functions, formatting, and data related to an abstract concept (e.g. "person") are all in one place, the DOM is always in sync with the data, and the data is always ready to be sent to/retrieved from the server in one call.
In response to the difficulties above, in the last few years several superb libraries have been introduced to bring MVC (or a variant thereof) to the browser. Although they do a good job of refactoring apps in terms of content, format, and behavior - and hence lead to more maintainable code - they do so at the expense of development speed: Most are fairly verbose, require a considerable amount of repetition, and/or require large library includes.
Agility borrows some useful concepts from the above frameworks, and makes rapid development a core part of its design principles. It's "write less, do more" with maintainability, if you will.
Here are some of the features that Agility.js has aggregated into a single framework:
Agility's architecture follows one of the simplest MVC patterns: users define Controller functions, which make direct calls to, and handle events from Models and Views. The diagram below illustrates this.
So for example, when a user clicks on a DOM element, an event signal is sent from the View to any Controller functions listening to it, and these functions in turn can make direct calls to Model and View functions.
Additionally, as illustrated below, every Agility object can serve as a container of other Agility objects. This is a natural abstraction for most applications, including simple lists, interactive tables, picture/video catalogs, etc, where each individual item might contain enough functionality (e.g. edit/remove buttons, mouse hover behavior, etc) to deserve its own MVC object. And because Agility objects are lightweight in memory (through pervasive use of prototypes), this comes at little performance cost.
Agility.js depends on a recent version of jQuery (tested with 1.6.x, Zepto support coming soon). Other than that dependency, a single
Typically the
of your HTML will be empty, and will be populated programmatically by adding Agility objects to the global object $$.document
.
Here's the full source of a "hello world" example:
<!DOCTYPE html>   <meta http-equiv="Content-type" content="text/html; charset=utf-8"> <title>Agility Hello World</title>
The above template has been used for all examples throughout this documentation.
Agility is framed around the notion of all-in-one MVC objects, or simply "Agility objects". Such objects are created through the factory function $$()
, either from scratch (by passing model, view, and/or controller initializers) or from a prototype object (by specifying an existing Agility object):
// Create object from scratch: var proto = $$({}, '
'); // Create object from prototype object: var obj = $$(proto, {name:'Joe Doe'}); $$.document.append(obj);
Refer to the examples in the home page and elsewhere in this document for several different uses of the factory function, and the factory function reference for syntax details.
Agility offers painless two-way bindings to keep Models and Views in sync. Binding a given DOM element to a model property is as simple as specifying a data-bind
attribute for the desired element:
// Two-way input binding (text) var obj = $$({name:'Joe Doe'}, '
<input type="text" data-bind="name"/> You typed:
'); $$.document.append(obj);
// Two-way input binding (search) var obj = $$({query:'Type of query'}, '
<input type="search" data-bind="name"/> Instant model change:
'); $$.document.append(obj);
You can also bind models to DOM element attributes in addition to the element HTML content using the following syntax for data-bind
:
// data-bind syntax [model_var] [, attribute1=model_var1 [, attribute2=model_var2] ... ]
where the first (single) argument is the model variable to be bound to the DOM element HTML content, and the subsequent comma-separated pairs specify the binding of a DOM element attribute to a model variable, like so:
// Bind model 'content' to element's HTML content, and model 'myStyle' to element's style attribute var msg = $$({content:'Greetings!', myStyle:'color:red'}, '
'); $$.document.append(msg);
More complex bindings are also supported for other input elements:
// Two-way input binding (radio) var obj = $$( {opt:'opt-a'}, "
 \ <input type='radio' name='test' value='opt-a' data-bind='opt'>a</input> \ <input type='radio' name='test' value='opt-b' data-bind='opt'>b</input> \ You selected:  \
" ); $$.document.append(obj);
// Two-way input binding (checkbox) var obj = $$( {a:false, b:true}, "
 \ <input type='checkbox' name='test' data-bind='a'/> checked:
 \ <input type='checkbox' name='test' data-bind='b'/> checked:
 \
" ); $$.document.append(obj);
// Two-way input binding (select) var obj = $$( {opt:'opt-a'}, "
 \ <select data-bind='opt'> \ <option value='opt-a'>Option A</option>\ <option value='opt-b'>Option B</option>\ </select> \ You selected:  \
" ); $$.document.append(obj);
Agility's views require the specification of format
(HTML), and encourage the use of style
(CSS) in-object. This leads to better object reusability and maintainability: there is no need to fish out HTML/CSS parts from different files to reuse an existing object in a new project, and no need to maintain ids/classes throughout separate files. Content, style, and behavior are all contained in one object.
Formats are specified through an HTML string, containing one (and only one) root element that wraps all other elements, so the first two examples below are not valid:
// INVALID CODE!! (missing root view element) var obj = $$({}, 'hey there'); $$.document.append(obj); // INVALID CODE!! (more than one root elements) var obj = $$({}, '
hey there
 <button>OK</button>'); $$.document.append(obj); // Valid code var obj = $$({}, '
hey there
'); $$.document.append(obj);
Formats should always be specified upon object creation. Refer to the factory function for examples on how to initialize the format.
Specifying styles (CSS) in-object is optional, but again, it leads to better code reusability and maintainability. In-object CSS is implemented dynamically, so the object's style sheet is not introduced until the object is created.
To ensure CSS selectors apply only to the intended object, make sure all selectors are preceded by the root selector &
. (In future versions this might not be necessary anymore).
// ANTI-PATTERN!! (applies CSS style globally) var obj = $$({}, "
Please don't do this
", 'span { color:red; }'); $$.document.append(obj); // Correct: applies style locally var obj = $$({}, '
Do this
', '& span { color:blue; }'); $$.document.append(obj);
More complex formats and styles can be organized in multiple lines:
var obj = $$({ view: { format:'
\
Hello
\
World
\
', style:'& { border:5px solid green; color:white; }\ & div { padding:10px 20px; }\ & #hello { background:blue; }\ & #world { background:red; }' } }); $$.document.append(obj);
If your format
and/or style
are too large, it's probably time to split your object into more Agility objects. (Unless of course you are creating a mostly static page, in which case Agility is probably not the best solution).
There are two types of events in Agility: DOM events, and Agility events, and both are implicitly bound to controller functions by matching function and event names. User-defined controllers extend (i.e. are called in addition to) built-in controllers.
Usual DOM events such as click
, dblclick
, mouseenter
, etc are supported through jQuery's event API. Please consult jQuery's API for a list of events supported.
When binding to controller functions, DOM events are distinguished from Agility events by the presence of a jQuery selector using the syntax:
// DOM event syntax for controller functions 'event selector': function(){}
In addition to jQuery's selectors, the root selector &
is also supported to pick the root element of the view:
var button = $$({msg:'Click me'}, '<button data-bind="msg"/>', { 'click &': function() { this.model.set({msg:"I've been clicked!"}); } }); $$.document.append(button);
Agility events are fired by the object core, as well as Models and plugins. When binding to a controller function, they are never followed by a space:
// Agility event syntax for controller functions 'event': function(){} 'event:event_parameter': function(){}
Presently, the following Agility events are fired:
create
: Fired upon object creation.destroy
: Fired before object is destroyed.add
: Fired when a new Agility object is added to the object's container.remove
: Fired with an Agility object is removed from the object's container.change
: Fired when the model has changed.change:prop
: Fired when the property prop
in the model has changed.The example below defines both a DOM and a Model event handler:
var catcher = $$({msg:'Hover over me'}, '

', { 'mouseenter span': function() { this.model.set({msg:'Hovered!'}); }, 'change:msg': function() { this.view.$().append('
Model changed!
'); } }); $$.document.append(catcher);
Agility event bubbling
Like DOM events, Agility events automatically bubble to the containers of objects. However, bubbling events do not trigger event handlers on the parent objects by default. An event handler must declare that it is interested in receiving bubbled events by including the child:
prefix in its event specification:
var parent = $$({ controller: { 'child:testevent': function(){ alert('testevent fired in descendant'); } } });
Events can bubble up multiple levels. Only a single child:
prefix is required to catch an event in any descendant of an obect.
All user-defined controllers initialized by the factory function $$()
have their this
auto-proxied to the owner MVC object, for quick access and consistent behavior no matter what context:
var obj = $$({msg:'I only exist because of auto-proxying'}, '
', { 'myHandler': function(){ this.view.$().html( this.model.get('msg') ); } }); $$.document.append(obj); // Without auto-proxying the 'this' in myHandler would be 'window' setTimeout(obj.controller.myHandler, 100);
If necessary, properties from the original context should be passed to the controller function.
Agility adopts prototype-based (differential) inheritance. To create a new Agility object from an existing one, pass the latter as the prototype argument to the factory function; additional model, view, controller initializers are passed as usual:
var proto = $$({}, '
', '& {color:red}'); var obj = $$(proto, {msg:'Hey there!'}); $$.document.append(obj);
You can also bypass differential inheritance (which overrides existing methods) and instead extend controllers with the tilde (~
) syntax:
var proto = $$({}, '<button>Click me</button>', { 'click &': function(){ alert('First controller'); } }); var obj = $$(proto, {}, {}, { '~click &': function(){ alert('Second controller'); } }); $$.document.append(obj);
Since derived objects reuse as much of their ancestors as possible, you can create large numbers of descendants from a prototype without worrying about memory bloat due to redundant storage:
// Prototype of cell object with empty model var cell = $$({ model: {}, view: { format: '
', style: '& { float:left; width:50px; cursor:pointer; text-align:center; }\ &:hover { background:#ccf }' }, controller: { 'click &': function(){ this.destroy(); } } }); // Matrix of cell objects, all stemming from prototype above var matrix = $$({}, '
Click to erase number:

', { 'create': function(){ for (var i=0;i<500;i++) { // Inherits from cell var newCell = $$(cell, {num:i}); this.append(newCell, '#wrapper'); } } }); $$.document.append(matrix);
Model persistence, such as server-side and local HTML5 storage, is bundled with the library as the plugin persist. This is not included in the core so as to keep it as simple as possible.
Creates a new MVC object from the given model, view, and controller arguments, and optionally a prototype object.
Compact syntax:
$$([model [,view-format [,controller]]]) $$([model [,view-format [, view-style [,controller]]]]) $$([model [,view [,controller]]]) $$(prototype, [model [,view-format [,controller]]]) $$(prototype, [model [,view-format [, view-style [,controller]]]]) $$(prototype, [model [,view [,controller]]])
Verbose syntax:
$$([prototype,] [{ model: {...}, view: {...}, controller: {...}, user_defined_property: {...} }])
where:
model
: Javascript object containing the model key-value pairs;view-format
: String specifying HTML format of the view; view-style
: String specifying CSS style of the view;view
: Javascript object containing format
and/or style
properties;controller
: Javascript object containing named functions that match event types;prototype
: Agility object to serve as the prototype for new object;user_defined_property
: Any additional user-defined method/property for the object.Examples:
Different view initialization methods:
// One string: format var person1 = $$({name:'Foo Bar'}, '
'); // Two strings: format, style var person2 = $$({name:'Foo Bar'}, '
', '& { color:red; font-weight:bold; }'); // Object: format, style var person3 = $$( { name:'Foo Bar' }, { format: '
', style: '& { color:blue; }' } ); // Verbose var person4 = $$({ model: { name: 'Foo Bar' }, view: { format: '
', style: '& { color:green; font-style:italic; }' } }); $$.document.append(person1); $$.document.append(person2); $$.document.append(person3); $$.document.append(person4);
Specifying controller functions - compact:
var button = $$({}, '
<button>Click me</button>
', { 'click button': function(){ alert('You clicked me!'); } }); $$.document.append(button);
and verbose:
var dataHolder = $$({ model: { first:'Joe', last:'Doe' }, view: { format: '
Wait...
' }, controller: { 'change:first': function(){ alert('First name changed!'); } } }); $$.document.append(dataHolder); setTimeout(function(){ dataHolder.model.set({first:'Mary'}); }, 2000);
Binds function to event.
Syntax:
.bind(event, fn)
event
: String specifying event type. See events section for event syntax.fn
: function to be called upon event triggering.Returns:
Owner Agility object (for chainable calls).
Triggers event, optionally passing parameters to listeners.
Syntax:
.trigger(event [,params])
event
: String specifying event type. See events section for event syntax.params
: parameters to be passed to listeners as function arguments.Returns:
Owner Agility object (for chainable calls).
Erases self view, removes self from parent container.
Syntax:
.destroy()
Returns:
Nothing.
Returns the parent container to which the object has been added, or null if it has not yet been added to a container.
Syntax:
.parent()
Returns:
Parent Agility object.
The methods below are specific to the object container.
Adds an Agility object to the object's container, and appends its view to containing object's view.
Syntax:
.append(object [,selector])
object
: The Agility object to be added;selector
: A jQuery selector specifying where the object's root element should be appended in the object's view. Will append to root element if undefined.Returns:
Owner Agility object (for chainable calls).
Adds an Agility object to the object's container, and prepends its view to containing object's view.
Syntax:
.prepend(object [,selector])
object
: The Agility object to be added;selector
: A jQuery selector specifying where the object's root element should be prepended in the object's view. Will prepend to root element if undefined.Returns:
Owner Agility object (for chainable calls).
Adds an Agility object to the object's container, and inserts its view before given selector of containing object's view.
Syntax:
.before(object, selector)
object
: The Agility object to be added;selector
: jQuery selector before which the object's root element should be inserted.Returns:
Owner Agility object (for chainable calls).
Adds an Agility object to the object's container, and inserts its view after given selector of containing object's view.
Syntax:
.after(object, selector)
object
: The Agility object to be added;selector
: jQuery selector after which the object's root element should be inserted.Returns:
Owner Agility object (for chainable calls).
Removes an Agility object from the object's container. [This function should rarely be invoked by the user; call instead .destroy()
within the object to be removed].
Syntax:
.remove(id)
id
: id of the object to be removed (accessed via ._id
property).Returns:
Owner Agility object (for chainable calls).
Iterates over each Agility object in the object's container.
Syntax:
.each(fn)
where:
fn
: Function to be called within the context of each contained object. Access the object via this
.Returns:
Owner Agility object (for chainable calls).
Removes all Agility objects from object's container by issuing a .destroy()
for each contained object.
Syntax:
.empty()
Returns:
Owner Agility object (for chainable calls).
Returns number of objects within the object's container.
Syntax:
.size()
Returns:
Number of Agility objects in the object's container.
Sets the model data. If model already exists, it's extended.
Syntax:
.model.set(object [,params])
object
: The Javascript object containing the data, e.g. {name:'Joe Doe', birthday:'08/11/71'}
.params
: Use {silent:true}
to avoid firing a change
event; use {reset:true}
to overwrite model data (and not extend it).Returns:
Owner Agility object (for chainable calls).
Gets model data.
Syntax:
.model.get([property])
property
: Desired property, e.g. 'name'
.Returns:
Desired property content if property
is specified, or a Javascript object containing the entire model data if it's omitted.
Resets model to its original value (at object creation time).
Syntax:
.model.reset()
Returns:
Owner Agility object (for chainable calls).
Iterates over each model property.
Syntax:
.model.each(fn)
fn
: Function to be called with each model property, with arguments fn(key, value)
where key
is the property name, and value
is its content.Returns:
Owner Agility object (for chainable calls).
Gets number of model properties.
Syntax:
.model.size()
Returns:
Number of model properties.
Shortcut to jQuery object corresponding to root element or to given selector in the current view.
Syntax:
.view.$([selector])
selector
: jQuery selector for the desired DOM element in the object's view.Returns:
jQuery object of root element if no selector, jQuery object at given selector
otherwise, restricted to the current view's DOM.
Updates View's main jQuery object according to .view.format
. Automatically called upon creation.
Syntax:
.view.render()
Returns:
Owner Agility object (for chainable calls).
Applies CSS dynamically according to .view.style
. Automatically called upon creation.
Syntax:
.view.stylize()
Returns:
Owner Agility object (for chainable calls).
Synchronizes all view elements with model contents, according to established bindings. Automatically called upon creation.
Syntax:
.view.sync()
Returns:
Owner Agility object (for chainable calls).
Built-in controllers are intended for internal use and typically shouldn't be called by the user.
Please refer to the factory function and event types for syntax and usage examples of user-defined controllers.
Main Agility object representing the document's body.
Typically you just .append()
a new Agility object to it.
The plugin persist
lets you save and retrieve models to/from a storage server using a given adapter. Persistence is always manual, i.e. needs to be explicitly called by user.
All methods fire the generic events:
persist:start
: fired when starting a new request and no other requests are pending.persist:stop
: fired after all pending requests have stopped.persist:error
: fired when a persistence error has occurred.as well as the method-specific events:
persist:METHOD:success
: fired after METHOD
has successfully completed request.persist:METHOD:error
: fired if METHOD
gave rise to an error.Initializes persistence plugin, creates persistence methods for owner object.
Syntax:
.persist([adapter, params])
where:
adapter
: Function containing the implementation of the persistence algorithms.params
: Parameters to be passed to adapter: The id property name on the server side, {id:'id_name'}
(default is simply {id:'id'}
), and the collection name {collection:'collection_name'}
(required).If the adapter-params pair is not given, the only method that can be invoked is gather.
Returns:
Owner Agility object (for chainable calls).
Refreshes model from server, using the id in the model property id
.
Syntax:
.load()
Examples:
Loads model from server:
var person = $$({id:123}, '
Name:
').persist($$.adapter.restful, {collection:'people'}); $$.document.append(person); person.load();
Returns
Owner Agility object (for chainable calls), with updated model.
Updates model on the server if id
is present in the model, creates a new resource otherwise.
Syntax:
.save()
If the resource is to be created (i.e. model has no id
), the server is expected to send back the new id
either in the body, e.g.
{"id":123}
or in the Location
header as the new resource URL, e.g.:
Location: http://your-site.com/api/people/123
Agility will parse either to extract the new id
, and set the model accordingly. That way, further calls to .save()
will update the model on the server.
Examples:
Creates new model on server:
var person = $$({name:'Joe Doe'}, '
Name:
').persist($$.adapter.restful, {collection:'people'}); $$.document.append(person); person.save();
Updates model on server:
var person = $$({id:123, name:'Joe Doe'}, '
Name:
').persist($$.adapter.restful, {collection:'people'}); $$.document.append(person); person.save(); // will update, since 'id' exists
Returns
Owner Agility object (for chainable calls), with new model id
(if created new resource).
Erases model from server, using the id
given in the model.
Syntax:
.erase()
Returns
Owner Agility object (for chainable calls).
Loads a collection of models and appends/prepends into container, using given prototype.
Each gathered MVC object will be added to the container, appended/prepended to the view (depending on specified method), and will be a direct descendant of given prototype object. All persistence information, including collection name, should be initialized in the prototype object.
Syntax:
.gather(proto, method, [,selector] [,query])
where:
proto
: Prototypal Agility object with persist
already initialized.method
: String containing name of method to be invoked with each new Agility object to be added (e.g. 'append'
, 'prepend'
, 'before'
, 'after'
).selector
: jQuery selector indicating where the view of proto
should be appended. Will append to root element if omitted.query
: Javascript object containing parameters to be passed to the adapter for e.g. HTTP queries, like {orderBy:'name'}
.Examples:
Loads a collection of persons from server:
// Prototype var person = $$({}, '
').persist($$.adapter.restful, {collection:'people'}); // Container var people = $$({}, '
People:

').persist(); $$.document.append(people); people.gather(person, 'append', 'ul');
Same as above, with load button and "Loading..." Ajax message:
// Prototype var person = $$({}, '
').persist($$.adapter.restful, {collection:'people'}); // Container var people = $$({ model: {}, view: { format: '
\ Loading ...\ <button>Load people</button>

\ People:
\
', style: '& {position:relative}\ & span {position:absolute; top:0; right:0; padding:3px 6px; background:red; color:white; display:none; }' }, controller: { 'click button': function(){ this.empty(); this.gather(person, 'append', 'ul'); }, 'persist:start': function(){ this.view.$('span').show(); }, 'persist:stop': function(){ this.view.$('span').hide(); } } }).persist(); $$.document.append(people);
Returns
Owner Agility object (for chainable calls), with container filled with new proto
descendants.
RESTful adapter.
This adapter sends GET
, POST
, etc requests as per RESTful specs, and expects JSON responses.
The default base URL is api/
, but it can be overridden at initialization time with the parameter {baseUrl:'your_url/'}
passed to persist()
. The collection name and/or resource id
will be appended to form URLs like
api/resource api/resource/123


{{$index+1}}. {{story.subject | twolines}}
|
|---|
{{task.subject}}
|
{{task.description}}
| user | weekly | in progress | qa | done |
|---|---|---|---|---|
| MR |
test 1
MR
XY
test 2
test 3
MR
XY
test 4
|
|||
| XY |
ticket: {{drag_and_dropped}} into dropzone: {{target_id}} ticket user: {{user}} task field: {{dropped_field}} qa-user: {{qa_user}}


Four fab new food finds to add to your list when visiting Athens
by Gina LionatosWhen most people think of eating in Greece, they instantly conjure up images of juicy Souvlaki, charming fish tavernas and syrup-soaked traditional sweets. While these food stalwarts will never die, the Athens food scene is shaping itself into a food-force to be reckoned with. Here are the Athens food-finds we’re loving right now.
Alex the fresh pasta bar
Pasta lovers rejoice! This casual little kitchen in the heart of Kolonaki is run by young and talented chef Alex Vassilatos, whose passion for pasta comes to life in the beautifully made dishes on offer. Heroing Greek products like flour of Lemnos and Xinomizithra from Chania, the menu changes frequently to feature the best seasonal produce available from all over Greece. Warning: you’re guaranteed to want to try everything on the menu, so don’t go alone!
Alex the fresh pasta bar – 3 Dexamenis Square, Kolonaki (Open Wednesday – Sunday 14.00-22.00)
Hams & Clams
This stylish Oyster bar is ideally situated, overlooking the yachts of Marina Zeas in Piraeus. While Oysters aren’t something you often see on Greek menus, at Hams and Clams, you can enjoy freshly caught oysters, served both fresh and cooked (try the Bloody Mary oyster sfinaki). Also on offer are some fantastic fresh seafood dishes, like the tsipoura ceviche and the kritharato with crab meat. With an impressive wine list to match the food on offer, Hams & Clams offers the perfect Athenian afternoon by the water.
Hams & Clams – Limani, Marina Zeas, Piraeus (Open 13.00 – 01.00)
Maraboo Ice Cream
A welcome addition to the hip neighbourhood of Pagkrati, at Maraboo, the ice cream is made fresh each day and there is usually a line outside this cute little shop front (don’t worry, it moves fast!). With a rotation of interesting combinations (lavender and honey, Greek rice pudding) and more traditional flavours (milk chocolate, salted caramel) on offer, it’s time to check out this tiny spot with big flavours.
Maraboo Ice Cream – Archelaou 17, Pagkrati (Open 14.00-21.30 Mon – Fri, 12.00-21.30 Sat – Sun)
To Lokali
As the name suggests, this all-day hangout spot aims to create an atmosphere of the “local” (no matter where you’re from). Not quite a cafe, not quite a restaurant, not quite a bar, To Lokali has a varied offering, all of which focuses on big flavours served up in a cool, unpretentious environment. The day starts with brunch, rolls on with coffee and beers, continues with high-quality taverna-style food with a twist, and ends late with an intriguing cocktail list. Take your pick of the lush outdoor courtyard or the quirky interior featuring murals by local artist The Rabbit Knows. Simply put, however, you choose to spend your time here, you’ll feel like a local (and a pretty hip one at that).
To Lokali – Sarri 44, Psyrri (Open 10.00-03.00)


intermediate
The Bracket
Type class abstracts the ability to safely acquire, use, and then release a resource.
Essentially, it could be considered the functional programming equivalent to the well known imperative
try/catch/finally
structure.
Bracket
extends MonadError
.
It ensures that the acquired resource is released at the end after using it, even if the using action throws an error. That ensures that no errors are swallowed.
Another key point of Bracket
would be the ability to abstract over whether the resource is going to be used
synchronously or asynchronously.
Let’s say we want to work with a file. Let’s use a mock File
API to avoid messing with the real one here.
These methods would allow to open a File, close it and also read it’s content as a string.
import arrow.effects.IO
/**
* Mock File API.
*/
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
fun openFile(uri: String): IO<File> = IO { File(uri).open() }
fun closeFile(file: File): IO<Unit> = IO { file.close() }
fun fileToString(file: File): IO<String> = IO { file.toString() }
Note that we wrapped them into IO
. IO
is able to wrap any side effecting computation to make it pure. In a real world system, these operations would contain
side effects since they’d end up accessing the file system.
Read the IO
docs for more context on this.
Now, let’s say we want to open a file, do some work with it, and then close it. With Bracket
, we could make that
process look like this:
import arrow.effects.IO
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
fun openFile(uri: String): IO<File> = IO { File(uri).open() }
fun closeFile(file: File): IO<Unit> = IO { file.close() }
fun fileToString(file: File): IO<String> = IO { file.toString() }
fun main(args: Array<String>) {
//sampleStart
val safeComputation = openFile("data.json").bracket(
release = { file -> closeFile(file) },
use = { file -> fileToString(file) })
//sampleEnd
println(safeComputation)
}
This would ensure the file gets closed right after completing the use
operation, which would be fileToString(file)
here. If that operation throws an error, the file would also be closed.
Note that the result is still an IO.Async
operation, which means it’s still deferred (not executed yet).
We’ve mentioned that Bracket
is agnostic of whether the use
lambda is computed synchronously or asynchronously.
That’s because it’s able to run over any data type F
that can support synchronous and asynchronous
computations, like IO
or Observable
.
It basically targets what in Functional Programming is known as a “Higher Kind”.
There’s a complete section about this pattern in the docs.
Let’s learn more about how Bracket
can support this pattern as a Type class with a basic example showcasing this high level of abstraction technique.
import arrow.Kind
import arrow.effects.typeclasses.Bracket
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
class Program<F>(BF: Bracket<F, Throwable>) : Bracket<F, Throwable> by BF {
fun openFile(uri: String): Kind<F, File> = just(File(uri).open())
fun closeFile(file: File): Kind<F, Unit> = just(file.close())
fun fileToString(file: File): Kind<F, String> = just(file.toString())
}
This is basically the same program from previous examples, but defined over any F
data type that there is an instance
of Bracket
for. In other words, this program is constrained by the capabilities that Bracket
can provide.
We are also fixing the error type from Bracket<F, E>
to be Throwable
.
Let’s run the program for the three mentioned data types as an example of polymorphism now.
We can run the program for IO
:
import arrow.effects.IO
import arrow.effects.extensions.io.bracket.bracket
import arrow.Kind
import arrow.effects.typeclasses.Bracket
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
class Program<F>(BF: Bracket<F, Throwable>) : Bracket<F, Throwable> by BF {
fun openFile(uri: String): Kind<F, File> = just(File(uri).open())
fun closeFile(file: File): Kind<F, Unit> = just(file.close())
fun fileToString(file: File): Kind<F, String> = just(file.toString())
}
fun main(args: Array<String>) {
//sampleStart
val ioProgram = Program(IO.bracket())
val safeComputation = with (ioProgram) {
openFile("data.json").bracket(
release = { file -> closeFile(file) },
use = { file -> fileToString(file) })
}
//sampleEnd
println(safeComputation)
}
Let’s now run the same exact program also for ObservableK
:
import arrow.effects.rx2.ObservableK
import arrow.effects.rx2.extensions.observablek.bracket.bracket
import arrow.Kind
import arrow.effects.typeclasses.Bracket
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
class Program<F>(BF: Bracket<F, Throwable>) : Bracket<F, Throwable> by BF {
fun openFile(uri: String): Kind<F, File> = just(File(uri).open())
fun closeFile(file: File): Kind<F, Unit> = just(file.close())
fun fileToString(file: File): Kind<F, String> = just(file.toString())
}
fun main(args: Array<String>) {
//sampleStart
val observableProgram = Program(ObservableK.bracket())
val safeComputation = with (observableProgram) {
openFile("data.json").bracket(
release = { file -> closeFile(file) },
use = { file -> fileToString(file) })
}
//sampleEnd
println(safeComputation)
}
Note that we’re running the exact same program passing in two different data types. All of them can provide an
instance of Bracket
, which means that they can support asynchronous and synchronous computations.
This is the style you’d usually use in a Functional Program.
Requires passing release
and use
lambdas. It ensures acquiring, using and releasing the resource at the end.
fun <A, B> Kind<F, A>.bracket(release: (A) -> Kind<F, Unit>, use: (A) -> Kind<F, B>): Kind<F, B>
import arrow.effects.IO
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
fun openFile(uri: String): IO<File> = IO { File(uri).open() }
fun closeFile(file: File): IO<Unit> = IO { file.close() }
fun fileToString(file: File): IO<String> = IO { file.toString() }
fun main(args: Array<String>) {
//sampleStart
val safeComputation = openFile("data.json").bracket(
release = { file -> closeFile(file) },
use = { file -> fileToString(file) })
//sampleEnd
println(safeComputation)
}
It’s a generalized version of bracket()
which uses ExitCase
to distinguish between different exit cases when
releasing the acquired resource. ExitCase
can take the values Completed
, Canceled
, or Error(e)
. So depending
how the use
execution finalizes, the corresponding ExitCase
value will be passed to the release
lambda.
Requires passing release
and use
lambdas. It ensures acquiring, using and releasing the resource at the end.
fun <A, B> Kind<F, A>.bracketCase(release: (A, ExitCase<Throwable>) -> Kind<F, Unit>, use: (A) -> Kind<F, B>): Kind<F, B>
import arrow.effects.IO
import arrow.effects.typeclasses.ExitCase
class File(url: String) {
fun open(): File = this
fun close(): Unit {}
override fun toString(): String = "This file contains some interesting content!"
}
fun openFile(uri: String): IO<File> = IO { File(uri).open() }
fun closeFile(file: File): IO<Unit> = IO { file.close() }
fun fileToString(file: File): IO<String> = IO { file.toString() }
fun main(args: Array<String>) {
//sampleStart
val safeComputation = openFile("data.json").bracketCase(
release = { file, exitCase ->
when (exitCase) {
is ExitCase.Completed -> { /* do something */ }
is ExitCase.Canceled -> { /* do something */ }
is ExitCase.Error -> { /* do something */ }
}
closeFile(file)
},
use = { file ->
fileToString(file)
})
//sampleEnd
println(safeComputation)
}
For a full list of other useful combinators available in Bracket
see the Source
Arrow provides BracketLaws
in the form of test cases for internal
verification of lawful instances and third party apps creating their own Bracket instances.
Bracket
instancesArrow already provides Bracket instances for most common datatypes both in Arrow and the Kotlin stdlib. Oftentimes you may find the need to provide your own for unsupported datatypes.
You may create or automatically derive instances of Bracket
for your own datatypes which you will be able to use in
the context of abstract polymorphic code.
See Deriving and creating custom typeclass
| Module | Data types |
| arrow.data | EitherT, Kleisli, OptionT, StateT, WriterT |
| arrow.effects | IO |
| arrow.effects.reactor | FluxK, MonoK |
| arrow.effects.rx2 | FlowableK, MaybeK, ObservableK, SingleK |


| DOSE: T+ 0:00 |
15 mg |
oral |
Morphine |
(pill / tablet) |
| T+ 2:00 |
30 mg |
oral |
Morphine |
(pill / tablet) |
| T+ 3:00 |
105 mg |
oral |
Morphine |
(pill / tablet) |
Just thought I'd share my morphine experience from when I was a narcotic addict... I bought two sixty milligram morphine sustained release tablets and two fifteen milligram morphine immediate release tablets for $25 on Christmas day in 1999. I had been addicted to painkillers for two years, so I was extremely stoked to get my hands on so much morphine.
I took one IR 15mg. tab, expecting to get floored...two hours later, nothing. I then broke up the SR 60mg, and took half. A slight buzz in an hour. I thought, 'what the hell, this isn't working,' and took the rest. Whoa, damn! That definitely did the trick! It came on stronger and stronger, and I thought I had unwittingly taken a lethal dose. It finally plateaued at around four hours, but by that point I could hardly move or speak.
So, I experienced that blissful feeling for a good two days, and I wished it would never end. I can honestly say that morphine is the best of the pure opiate agonists - the euphoria is better than cocaine, sex, or skydiving. I once tried Pediagoric (tincture of opium), and a half a bottle of it was very similar.
However, it is dangerous, and it is extremely unwise to ingest that much morphine at once, unless you have a serious tolerance (I'm not talking 5-6 Percocets a day; more like 50-60... and Lortabs are candy for schoolkids...), a death wish, or a sitter who has IV Narcan and knows how to use it when you stop breathing. It also helps to get a narcotic dosage conversion table, which can be found in The Merck Manual or The Physician's Desk Reference.
Just for the record, right before I took those pills, I injected IV, two bags of what a then- 'chipper' friend called 'really good heroin...' I felt absolutely nothing, and he passed out off of one bag (He later died of an O.D. in a Krystal restaurant bathroom near Georgia Tech - opiates can kill you!). So, I cannot say it enough - just go burn a doob ... it is much safer and a lot more fun in the long run...
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Cylon.js (http://cylonjs.com) is a JavaScript framework for robotics, physical computing, and the Internet of Things (IoT).
This module provides an adaptor/driver for the Sphero robot from Orbotix (http://www.gosphero.com/). It uses the Sphero.js module (https://github.com/orbotix/sphero.js) from @orbotix thank you!
Want to use Ruby on robots? Check out our sister project Artoo (http://artoo.io)
Want to use the Go programming language to power your robots? Check out our sister project Gobot (http://gobot.io).
Install the module with:
$ npm install cylon cylon-sphero
Example of a simple program that makes the Sphero roll.
var Cylon = require('cylon');
Cylon.robot({
connections: {
sphero: { adaptor: 'sphero', port: '/dev/rfcomm0' }
},
devices: {
sphero: { driver: 'sphero' }
},
work: function(my) {
every((1).second(), function() {
my.sphero.roll(60, Math.floor(Math.random() * 360));
});
}
}).start();
In order to allow Cylon.js running on your Mac to access the Sphero, go to "Bluetooth > Open Bluetooth Preferences > Sharing Setup" and make sure that "Bluetooth Sharing" is checked.
Thank you to @kopipejst for the above connnection info.
First pair your computer and Sphero. You can do this using bluetooth preferences. (Sphero won't stay connected)
Find out serial port address by running this command:
ls /dev/tty.Sphero*
The port will look something like this:
/dev/tty.Sphero-BBP-AMP-SPP
Now you are ready to run the example code, be sure to update this line with the correct port:
connections: {
sphero: { adaptor: "sphero", port: "/dev/tty.Sphero-BBP-AMP-SPP" }
},
Connecting to the Sphero from Ubuntu or any other Linux-based OS can be done entirely from the command line using CylonJS CLI commands. Here are the steps.
Find the address of the Sphero, by using:
gort bluetooth scan
Pair to Sphero using this command (substituting the actual address of your Sphero):
gort bluetooth pair <address>
Connect to the Sphero using this command (substituting the actual address of your Sphero):
gort bluetooth connect <address>
You should be able to simply pair your Sphero using your normal system tray applet for Bluetooth, and then connect to the COM port that is bound to the device, such as COM3
.
The cylon-sphero module is currently compatible with Node.js versions 0.10.x thru 4.2.x.
You might want to calibrate the orientation of the Sphero so that it is pointed 'forward'. There are 2 functions that have been added to the Sphero driver to help with this.
Call startCalibration()
to put the Sphero into 'calibration mode' by turning on the tail LED and turning off the auto-stablization. You can now manually turn the Sphero to so the tail LED is pointed to the rear of the direction in which you want the Sphero to go.
Call finishCalibration()
to turn off 'calibration mode' by turning off the tail LED and turning back on the auto-stablization. Whichever direction that the tail LED was pointed, is now the rear direction for the Sphero.
We're busy adding documentation to our web site at http://cylonjs.com/ please check there as we continue to work on Cylon.js
Thank you!
For our contribution guidelines, please go to https://github.com/hybridgroup/cylon/blob/master/CONTRIBUTING.md .
For the release history, please go to https://github.com/hybridgroup/cylon-sphero/blob/master/RELEASES.md .
Copyright (c) 2013-2015 The Hybrid Group. Licensed under the Apache 2.0 license.


@Pattern
parameters and
returned from @Pattern
-annotated methods that do not match the specified pattern.
Example:
@Pattern("\\d\\d-\\d\\d\\d") String getId() {
return "1";
}
Use the Flag non compile-time constant expressions option to let the inspection report expressions with
an unknown value and offer to add a substitution (@Subst
) annotation.


{% extends "admin_app/admin_app_base.html" %} {% load staticfiles %} {% block body_block %}
| Suplier | Product | Amount | Route | Truck | Id |
|---|---|---|---|---|---|
| {{o.name_deliver}} | {{o.name_product}} | {{o.amount}}kg | {{o.id_route}} | {{t.id_truck}} | {{o.id}} |
| Client | Product | Amount | Route | Truck | Id |
|---|---|---|---|---|---|
| {{c.name_client}} | {{c.price}} | {{c.weigth}}kg | {% for r in routes_tomorrow%} {% for ri in r.routes_as_list%} {% if r.client and ri.1 == c.id%}{{r.id_route}} | {{r.id_truck.id_truck}} | {%endif%} {%endfor%} {%endfor%}{{c.id}} |


E
1)
sandy
A)
one who designs
H
2)
joyful
B)
to become short
B
3)
shorten
C)
without sleep
G
4)
goodness
D)
how polite someone is
D
5)
politely
E)
characterised by sand
A
6)
designer
F)
able to believe
F
7)
believable
G)
state of being good
C
8)
sleepless
H)
full of joy


If you have a JSON wallet file from geth or from the initial Ethereum crowd sale, you can decrypt it here. No information is shared with any server.
| JSON Wallet: | Drop JSON wallet file here |
|---|---|
| Password: | |
|
Unlock JSON Wallet
|
If you have a 12 word mnemonic phrase, you can generate your wallet here. No information is shared with any server.
| Mnemonic Phrase: | |
|---|---|
| Path: | |
|
Derive Wallet
|
| Private Key: | |
|---|---|
|
Load Raw Private Key
|
This is beta software, with no warranty. Use at your own risk.


Waikouaiti 'rapt' over funding grant
by Jessica WilsonThe Dunedin City Council grants subcommittee recently allocated $300,000 in funding to seven ‘‘place-based’’ community groups across the city.
The funding, which ranges from $31,000 to $55,000, will be used to help with the costs of building community connection and resilience for the next 12 months. In the coming weeks, reporters will highlight the programmes and projects the funding will support in your communities.
The series continues with Progress of Waikouaiti Area.
Employing a youth facilitator is the key objective for Progress of Waikouaiti Area (POWA) after receiving money from the Dunedin City Council.
The organisation received $39,600 from the council's annual $300,000 place-based grants fund.
POWA community worker Sonya Billyard said they were "rapt'' to get the money and most of it would be put towards progressing its latest initiative, an East Otago youth group.
"It's very early days. POWA and the local church council have come together and will oversee the project.''
They would help the group get"on their feet'' and become independent.
Primarily, the money will be used to employ a youth facilitator who will work about 10 hours per week, and to get the group up and running.
The group would likely operate after school two days a week for children aged between 6 and 13 years old.
Ms Billyard said it would be a place where they could spend time after school, and take part in activities and sports.
"Some kids are at a loss for things to do.''
It would run from the Waikouaiti Events Centre, which has a community garden, skate park, kitchen and auditorium.
"It's a prime spot for it.''
A survey was sent to children in the area of what they wanted and many requested a youth group be formed, she said.
The rest of the money would go to One Coast and community workers' wages.
POWA was also a recipient of last year's place-based funding which was used to start the community garden and support the One Coast transfer station development.
"The garden is becoming more independent now.
"It's on its feet and growing.''
POWA is a community organisation which aims to sustain processes which mobilise the community's strengths and resources in community-led action to the benefit of the area, its residents, families/whanau and environment.


Deductive Logic
by George William Joseph Stock, M.A.
Part 3: Chapter 4
Additional Information
- Year Published: 1888
- Language: English
- Country of Origin: England
- Source: Stock, G. W. J. (1888). Deductive Logic. Oxford, England; Pembroke College.
-
Readability:
- Flesch–Kincaid Level: 11.0
- Word Count: 1,016
- Genre: Informational
- Keywords: math, math history
- ✎ Cite This
Downloads
PART III.—OF INFERENCES
CHAPTER IV.
Of Conversion.
479. Conversion is an immediate inference grounded On the transposition of the subject and predicate of a proposition.
480. In this form of inference the antecedent is technically known as the Convertend, i.e. the proposition to be converted, and the consequent as the Converse, i.e. the proposition which has been converted.
481. In a loose sense of the term we may be said to have converted a proposition when we have merely transposed the subject and predicate, when, for instance, we turn the proposition ‘All A is B’ into ‘All B is A’ or ‘Some A is not B’ into ‘Some B is not A.’ But these propositions plainly do not follow from the former ones, and it is only with conversion as a form of inference—with Illative Conversion as it is called—that Logic is concerned.
482. For conversion as a form of inference two rules have been laid down—
(1) No term must be distributed in the converse which was not distributed in the convertend.
(2) The quality of the converse must be the same as that of the convertend.
483. The first of these rules is founded on the nature of things. A violation of it involves the fallacy of arguing from part of a term to the whole.
484. The second rule is merely a conventional one. We may make a valid inference in defiance of it: but such an inference will be seen presently to involve something more than mere conversion.
485. There are two kinds of conversion—
(1) Simple.
(2) Per Accidens or by Limitation.
486. We are said to have simply converted a proposition when the quantity remains the same as before.
487. We are said to have converted a proposition per accidens, or by limitation, when the rules for the distribution of terms necessitate a reduction in the original quantity of the proposition.
488.
A can only be converted per accidens.
E and I can be converted simply.
O cannot be converted at all.
489. The reason why A can only be converted per accidens is that, being affirmative, its predicate is undistributed ( 293). Since ‘All A is B’ does not mean more than ‘All A is some B,’ its proper converse is ‘Some B is A.’ For, if we endeavoured to elicit the inference, ‘All B is A,’ we should be distributing the term B in the converse, which was not distributed in the convertend. Hence we should be involved in the fallacy of arguing from the part to the whole. Because ‘All doctors are men’ it by no means follows that ‘All men are doctors.’
499. E and I admit of simple conversion, because the quantity of the subject and predicate is alike in each, both subject and predicate being distributed in E and undistributed in I.
/ No A is B.
E <
\’. No B is A.
/ Some A is B.
I <
\ .’. Some B is A.
491. The reason why O cannot be converted at all is that its subject is undistributed and that the proposition is negative. Now, when the proposition is converted, what was the subject becomes the predicate, and, as the proposition must still be negative, the former subject would now be distributed, since every negative proposition distributes its predicate. Hence we should necessarily have a term distributed in the converse which was not distributed in the convertend. From ‘Some men are not doctors,’ it plainly does not follow that ‘Some doctors are not men’; and, generally from ‘Some A is not B’ it cannot be inferred that ‘Some B is not A,’ since the proposition ‘Some A is not B’ admits of the interpretation that B is wholly contained in A.
[Illustration]
492. It may often happen as a matter of fact that in some given matter a proposition of the form ‘All B is A’ is true simultaneously with ‘All A is B.’ Thus it is as true to say that ‘All equiangular triangles are equilateral’ as that ‘All equilateral triangles are equiangular.’ Nevertheless we are not logically warranted in inferring the one from the other. Each has to be established on its separate evidence.
493. On the theory of the quantified predicate the difference between simple conversion and conversion by limitation disappears. For the quantity of a proposition is then no longer determined solely by reference to the quantity of its subject. ‘All A is some B’ is of no greater quantity than ‘Some B is all A,’ if both subject and predicate have an equal claim to be considered.
494. Some propositions occur in ordinary language in which the quantity of the predicate is determined. This is especially the case when the subject is a singular term. Such propositions admit of conversion by a mere transposition of their subject and predicate, even though they fall under the form of the A proposition, e.g.
Virtue is the condition of happiness. .’. The condition of happiness is virtue.
And again,
Virtue is a condition of happiness. .’. A condition of happiness is virtue.
In the one case the quantity of the predicate is determined by the form of the expression as distributed, in the other as undistributed.
495. Conversion offers a good illustration of the principle on which we have before insisted, namely, that in the ordinary form of proposition the subject is used in extension and the predicate in intension. For when by conversion we change the predicate into the subject, we are often obliged to attach a noun substantive to the predicate, in order that it may be taken in extension, instead of, as before, in intension, e.g.
Some mothers are unkind. .’.
Again,
Virtue is conducive to happiness. .’. One of the things which are conducive to happiness is virtue.


At the heart of our work are oral histories of jazz musicians. We are currently expanding our data sources to include other document types and music-related datasets.
In the first phase of the project — funded through an OCLC/ALISE Library and Information Science Research grant — we experimented with the actual content of interview transcripts, generating new triples based on data rather than converting existing metadata. The 50+ interview transcripts we’ve used to create LOD come from the Rutgers Institute for Jazz Studies Archives, Smithsonian Jazz Oral Histories, the Hamilton College Jazz Archive, UCLA’s Central Avenue Sounds series, and the University of Michigan’s Nathaniel C. Standifer Video Archive of Oral History. For a full list of transcripts, see our Data Sources page.
To create LOD, we developed a suite of tools: a transcript analyzer, a name mapping and curator tool, and a crowdsourcing tool. These tools operate together to find names mentioned during the interview in order to assign a positive identification to each, disambiguating names using online resources like DBpedia and VIAF. The transcript analyzer also recognizes the question and answer structure of the oral history. As people are mentioned by an interviewee, simple RDF triples between interviewee and persons mentioned are created in the form of knowsOf. These triples can then be mapped to the correlating block. For more on the transcript analyzer and Name Mapping tool, see our Tools page.
In the next step, the interview question and answer blocks are passed to Linked Jazz 52nd Street, our crowdsourcing tool. Volunteers are presented with these snippets of interview text and asked to assign more granular terms to describe the relationship between the interviewee and the person mentioned. These relationships include:
has met
is an acquaintance of
is a friend of
is a close friend of
is influenced by
is a mentor of
collaborated with:
was in a band together with
played with
was a member of the band of
toured with
was the bandleader for
In the last step of our data lifecycle, we pass the triples to a network visualization. At this moment, the visualization shows the knows of triples, not the triples generated by 52nd Street. It also displays images, videos, and short biographies of jazz musicians within the network. Although we have a much larger master list of musicians including names culled from sources like DBPedia, MusicBrainz, and more, only musicians who were mentioned in transcripts are included in the network visualization. The size of a person’s node reflects how many times they were mentioned in various oral history transcripts. More information about our source data and the data we’ve produced is available under the Data menu of this site.
Future Directions
We continue to explore the possibilities of applying LOD to the jazz domain and beyond. We plan to move the tools we have developed from prototype to full production so they can be adopted widely regardless of context or domain.
We are currently working with jazz archives from Carnegie Hall and Tulane University to integrate and enrich our RDF dataset with new semantic layers. We have been recently focusing on adding gender data to the dataset as a preliminary step towards a broader representation of women in jazz (Pattuelli, Hwang and Miller, 2016). More data additions are underway to represent various professional and social facets of the jazz community.
Learn more about ongoing projects from our publications and presentations, and from our Work In Progress posts.
you are interested in collaborating with us, please get in touch!


Big Rig Brewery versus Young Drivers
Fri Feb 28 10:30PM KRC Rink
| Team | 1st | 2nd | Final |
| Young Drivers | 0 | 2 | 2 |
| Big Rig Brewery | 2 | 1 | 3 |
Scoring Summary
| 13:10 | Big Rig Brewery | 9 Larry Tapp |
| 1:52 | Big Rig Brewery | 12 Bob McLean ( 16 Lloyd Cosman, 8 Cameron Palmer ) |
| 4:59 | Big Rig Brewery | 3 Shawn King ( 4 Larry Perron, 14 Rob Zellerer ) |
| 1:49 | Young Drivers | 11 Pat D'Allaire ( 6 Alan King, 13 Glen Vandermolen ) |
| 0:18 | Young Drivers | 8 Steve Lamarche ( 13 Glen Vandermolen ) |
Penalty Summary
| 2:02 | Young Drivers | 11 Pat D'Allaire Body Checking |
| No Penalties |
Young Drivers Player Statistics
| | Player | G | A | P | PIM |
| 13 | Glen Vandermolen | 0 | 2 | 2 | 0 |
| 11 | Pat D'Allaire | 1 | 0 | 1 | 2 |
| 8 | Steve Lamarche | 1 | 0 | 1 | 0 |
| 6 | Alan King | 0 | 1 | 1 | 0 |
| 15 | Bob Star | 0 | 0 | 0 | 0 |
| 5 | Brent Bradley | 0 | 0 | 0 | 0 |
| 3 | George Taronno | 0 | 0 | 0 | 0 |
| 31 | Jamie Duckett (G) | 0 | 0 | 0 | 0 |
| 12 | John McMaster | 0 | 0 | 0 | 0 |
| 10 | Mark Saikaley | 0 | 0 | 0 | 0 |
| 4 | Mike Hanner | 0 | 0 | 0 | 0 |
| 9 | Rob Blondin | 0 | 0 | 0 | 0 |
| 2 | Brian Hackey (SCRATCH) |
| 7 | Paul Kavanaugh (SCRATCH) |
Big Rig Brewery Player Statistics
| | Player | G | A | P | PIM |
| 12 | Bob McLean | 1 | 0 | 1 | 0 |
| 9 | Larry Tapp | 1 | 0 | 1 | 0 |
| 3 | Shawn King | 1 | 0 | 1 | 0 |
| 8 | Cameron Palmer | 0 | 1 | 1 | 0 |
| 4 | Larry Perron | 0 | 1 | 1 | 0 |
| 16 | Lloyd Cosman | 0 | 1 | 1 | 0 |
| 14 | Rob Zellerer | 0 | 1 | 1 | 0 |
| 6 | Jonathan Lapp | 0 | 0 | 0 | 0 |
| 1 | Oscar Giroux (G) | 0 | 0 | 0 | 0 |
| 7 | Rick Batty | 0 | 0 | 0 | 0 |
| 100 | Garry Stewart (SPARE) | 0 | 0 | 0 | 0 |
| 11 | Alan Palmer (SCRATCH) |
| 19 | Cliff Lefrense (SCRATCH) |
| 10 | Dean Kathron (SCRATCH) |
| 5 | Jake Duret (SCRATCH) |


Wednesday, October 15, 2003
I got an email today from John Reilly today asking me a question I get from time to time:
I got my signed copy of your book. It is a great read. You have information that a friend and I have been trying to dig out for weeks.
Which leads me to our question. How do you find out all those details? They are not to be found in the MSDN documentation, as far as we can tell. Do you just experiment, like we do? We have been unable to find any .NET training that is much more than how to use the IDE. Alan and I crave detail, meat, the stuff of your book. Seriously, how does one obtain this seemingly inside information? We are personally and professionally motivated weenies.
Now that I'm a Microsoft employee, I have access to not only the source for most of what I'm researching, but the architects and internal mailing lists populated by the developers on the project, so that really is "inside information." However, over the 8+ years that I was a contributing member of the Windows developer community, 99% of what I've done has not been based on inside information. So, before I had access to internal info, how did I figure stuff out if the docs don't answer my questions? I do the following, in order of decreasing frequency:


--- layout: default title: SwallowJs Firebase services documentation || Beta v0.29 permalink: /doc/services-firebase ---
Services is fully responsible for managing almost everything regarding your data, its interactions, as well as the evolution of information workflow.Understanding that this connects mainly with Firebase data system reliable for storing and syncing data in real time across all connected clients
Retrieve a node from Firebase server.
Retrieve a single resource from the Firebase server.
params.path
data
data.error
FirebaseService.findOne()
is used to
retrieve a model instance from the server.
Use findOne
like:
The return data should look like:
{% highlight html %} {author: "John Deauthor", body: "Conveniently harness fictionalized communities high-impact markets under whelm go.", title: "The post title ", node_id: "post_one"} {% endhighlight %}Retrieve multiple nodes from Firebase server.
Retrieve multiple resource from the Firebase server.
params.path
,
params.limit
data
data.error
FirebaseService.findAll()
is used to
retrieve a model instance from the server.
Use findAll
like:
The return data should look like:
{% highlight html %} { data: [ {author: "John Deauthor", body: "post body content.", title: "The post title ", node_id: "post_one"}, {author: "John Deauthor", body: "post body content.", title: "Another post title ", node_id: "post_two"}, {author: "John Deauthor", body: "post body content.", title: "Another post title ", node_id: "post_three"}, ] { {% endhighlight %}Save/update node to Firebase server.
Retrieve a single resource from the Firebase server.
params.path
,
params.data
data.error
saveData
to create an instance. FirebaseService.saveData()
is used to
retrieve a model instance from the server.
If saveData()
is called an instance is created in Firebase.
If updateData()
is update the instance created on Firebase base on
the node key in this case . -KT-kz68IJrOajjwg865


Push the button to run needed script. And open you browser's console
Script is ready. Open your browser's console


Chapter 18 Introduction
You can label chapter and section titles using {#label}
after them, e.g., we can reference Chapter 18. If you do not manually label them, there will be automatic labels anyway, e.g., Chapter 2.
Figures and tables with captions will be placed in figure
and table
environments, respectively.
Reference a figure by its code chunk label with the fig:
prefix, e.g., see Figure 18.1. Similarly, you can reference tables generated from knitr::kable()
, e.g., see Table 18.1.
| Sepal.Length | Sepal.Width | Petal.Length | Petal.Width | Species |
|---|---|---|---|---|
| 5.1 | 3.5 | 1.4 | 0.2 | setosa |
| 4.9 | 3.0 | 1.4 | 0.2 | setosa |
| 4.7 | 3.2 | 1.3 | 0.2 | setosa |
| 4.6 | 3.1 | 1.5 | 0.2 | setosa |
| 5.0 | 3.6 | 1.4 | 0.2 | setosa |
| 5.4 | 3.9 | 1.7 | 0.4 | setosa |
| 4.6 | 3.4 | 1.4 | 0.3 | setosa |
| 5.0 | 3.4 | 1.5 | 0.2 | setosa |
| 4.4 | 2.9 | 1.4 | 0.2 | setosa |
| 4.9 | 3.1 | 1.5 | 0.1 | setosa |
| 5.4 | 3.7 | 1.5 | 0.2 | setosa |
| 4.8 | 3.4 | 1.6 | 0.2 | setosa |
| 4.8 | 3.0 | 1.4 | 0.1 | setosa |
| 4.3 | 3.0 | 1.1 | 0.1 | setosa |
| 5.8 | 4.0 | 1.2 | 0.2 | setosa |
| 5.7 | 4.4 | 1.5 | 0.4 | setosa |
| 5.4 | 3.9 | 1.3 | 0.4 | setosa |
| 5.1 | 3.5 | 1.4 | 0.3 | setosa |
| 5.7 | 3.8 | 1.7 | 0.3 | setosa |
| 5.1 | 3.8 | 1.5 | 0.3 | setosa |
You can write citations, too. For example, we are using the bookdown package (Xie 2018) in this sample book, which was built on top of R Markdown and knitr (Xie 2015).
References
Xie, Yihui. 2018. Bookdown: Authoring Books and Technical Documents with R Markdown. https://CRAN.R-project.org/package=bookdown.
Xie, Yihui. 2015. Dynamic Documents with R and Knitr. 2nd ed. Boca Raton, Florida: Chapman; Hall/CRC. http://yihui.name/knitr/.


|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object java.util.AbstractMap<K,V> java.util.HashMap<K,V> java.util.LinkedHashMap<K,V>
public class LinkedHashMap<K,V>
Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)
This implementation spares its clients from the unspecified, generally
chaotic ordering provided by HashMap
(and Hashtable
),
without incurring the increased cost associated with TreeMap
. It
can be used to produce a copy of a map that has the same order as the
original, regardless of the original map's implementation:
void foo(Map m) { Map copy = new LinkedHashMap(m); ... }This technique is particularly useful if a module takes a map on input, copies it, and later returns results whose order is determined by that of the copy. (Clients generally appreciate having things returned in the same order they were presented.)
A special constructor
is
provided to create a linked hash map whose order of iteration is the order
in which its entries were last accessed, from least-recently accessed to
most-recently (access-order). This kind of map is well-suited to
building LRU caches. Invoking the put or get method
results in an access to the corresponding entry (assuming it exists after
the invocation completes). The putAll method generates one entry
access for each mapping in the specified map, in the order that key-value
mappings are provided by the specified map's entry set iterator. No
other methods generate entry accesses. In particular, operations on
collection-views do not affect the order of iteration of the backing
map.
The removeEldestEntry(Map.Entry)
method may be overridden to
impose a policy for removing stale mappings automatically when new mappings
are added to the map.
This class provides all of the optional Map operations, and permits null elements. Like HashMap, it provides constant-time performance for the basic operations (add, contains and remove), assuming the hash function disperses elements properly among the buckets. Performance is likely to be just slightly below that of HashMap, due to the added expense of maintaining the linked list, with one exception: Iteration over the collection-views of a LinkedHashMap requires time proportional to the size of the map, regardless of its capacity. Iteration over a HashMap is likely to be more expensive, requiring time proportional to its capacity.
A linked hash map has two parameters that affect its performance: initial capacity and load factor. They are defined precisely as for HashMap. Note, however, that the penalty for choosing an excessively high value for initial capacity is less severe for this class than for HashMap, as iteration times for this class are unaffected by capacity.
Note that this implementation is not synchronized. If multiple threads access a linked hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the map. If no such object exists, the map should be "wrapped" using the Collections.synchronizedMapmethod. This is best done at creation time, to prevent accidental unsynchronized access:
Map m = Collections.synchronizedMap(new LinkedHashMap(...));A structural modification is any operation that adds or deletes one or more mappings or, in the case of access-ordered linked hash maps, affects iteration order. In insertion-ordered linked hash maps, merely changing the value associated with a key that is already contained in the map is not a structural modification. In access-ordered linked hash maps, merely querying the map with get is a structural modification.)
The iterators returned by the iterator methods of the collections returned by all of this class's collection view methods are fail-fast: if the map is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the Iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.
Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.
This class is a member of the Java Collections Framework.
Object.hashCode()
,
Collection
,
Map
,
HashMap
,
TreeMap
,
Hashtable
,
Serialized Form| Constructor Summary | |
|---|---|
LinkedHashMap()
Constructs an empty insertion-ordered LinkedHashMap instance with a default capacity (16) and load factor (0.75). |
|
LinkedHashMap(int initialCapacity)
Constructs an empty insertion-ordered LinkedHashMap instance with the specified initial capacity and a default load factor (0.75). |
|
LinkedHashMap(int initialCapacity,
float loadFactor)
Constructs an empty insertion-ordered LinkedHashMap instance with the specified initial capacity and load factor. |
|
LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder)
Constructs an empty LinkedHashMap instance with the specified initial capacity, load factor and ordering mode. |
|
LinkedHashMap(Map<? extends K,? extends V> m)
Constructs an insertion-ordered LinkedHashMap instance with the same mappings as the specified map. |
| Method Summary | |
|---|---|
void |
clear()
Removes all mappings from this map. |
boolean |
containsValue(Object value)
Returns true if this map maps one or more keys to the specified value. |
V |
get(Object key)
Returns the value to which this map maps the specified key. |
protected boolean |
removeEldestEntry(Map.Entry<K,V> eldest)
Returns true if this map should remove its eldest entry. |
| Methods inherited from class java.util.HashMap |
|---|
clone, containsKey, entrySet, isEmpty, keySet, put, putAll, remove, size, values |
| Methods inherited from class java.util.AbstractMap |
|---|
equals, hashCode, toString |
| Methods inherited from class java.lang.Object |
|---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
| Methods inherited from interface java.util.Map |
|---|
containsKey, entrySet, equals, hashCode, isEmpty, keySet, put, putAll, remove, size, values |
| Constructor Detail |
|---|
public LinkedHashMap(int initialCapacity, float loadFactor)
initialCapacity
- the initial capacity.loadFactor
- the load factor.
IllegalArgumentException
- if the initial capacity is negative
or the load factor is nonpositive.public LinkedHashMap(int initialCapacity)
initialCapacity
- the initial capacity.
IllegalArgumentException
- if the initial capacity is negative.public LinkedHashMap()
public LinkedHashMap(Map<? extends K,? extends V> m)
m
- the map whose mappings are to be placed in this map.
NullPointerException
- if the specified map is null.public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
initialCapacity
- the initial capacity.loadFactor
- the load factor.accessOrder
- the ordering mode - true for
access-order, false for insertion-order.
IllegalArgumentException
- if the initial capacity is negative
or the load factor is nonpositive.| Method Detail |
|---|
public boolean containsValue(Object value)
containsValue
in interface Map<K,V>
containsValue
in class HashMap<K,V>
value
- value whose presence in this map is to be tested.
public V get(Object key)
get
in interface Map<K,V>
get
in class HashMap<K,V>
key
- key whose associated value is to be returned.
HashMap.put(Object, Object)
public void clear()
clear
in interface Map<K,V>
clear
in class HashMap<K,V>
protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
Sample use: this override will allow the map to grow up to 100 entries and then delete the eldest entry each time a new entry is added, maintaining a steady state of 100 entries.
private static final int MAX_ENTRIES = 100; protected boolean removeEldestEntry(Map.Entry eldest) { return size() > MAX_ENTRIES; }
This method typically does not modify the map in any way, instead allowing the map to modify itself as directed by its return value. It is permitted for this method to modify the map directly, but if it does so, it must return false (indicating that the map should not attempt any further modification). The effects of returning true after modifying the map from within this method are unspecified.
This implementation merely returns false (so that this map acts like a normal map - the eldest element is never removed).
eldest
- The least recently inserted entry in the map, or if
this is an access-ordered map, the least recently accessed
entry. This is the entry that will be removed it this
method returns true. If the map was empty prior
to the put or putAll invocation resulting
in this invocation, this will be the entry that was just
inserted; in other words, if the map contains a single
entry, the eldest entry is also the newest.
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


If you ever want to call any function without the use of appending '()' at the end of it then this libray will be useful.
count //instead of count()
someObject.getName // indtead of someObject.getName()
callWithName(name, function, options)
function showError(){
alert("Something went wrong");
}
callWithName("showError", showError);
//use like
showError;
//instead of
showError();
same can be done by passing the function annonymously
callWithName("showError", function(){
alert("Something went wrong");
});
context can also be passed
var obj = {a:1,b:2};
callWithName('printA', function(){console.log(obj.a)},{contenxt:obj});


Melanoma is a form of cancer that begins in the Melanocytes, the portion of the skin responsible for producing Melanin and controlling skin color. While Melanoma is the most rare form of Skin Cancer, accounting for less than 2 percent of all cases diagnosed per year, it is also the most deadly. Although it can almost always be cured if caught in its earlier stages, the aggressive nature of the disease makes the possibility for it to spread very high if not detected early on.
The issue of Melanoma is a pressing one, especially when once considers that diagnosal rates of this terrible disease have been steadily increasing in the United States for over 30 years. In fact, there are currently over 960,000 people living with Melanoma Skin Cancer in the United States right now. Additionally worth noting is that while Melanoma can occur in both younger and older people, the risk of contracting this disease increase with age.
One major difficulty with achieving an early treatement of Melanoma is the degree to which it can remain dormant for long periods of time. One way that this can happen is in the form of a skin mole. While the vast majority of moles will never turn into anything harmful, some still do, and it is this casual gap that researches are trying to close in the hopes that it will save lives through the early discovery of this disease.
Basal Cell Cardinoma is a form of Skin Cancer in which an uncontrolled growth develops in the skin's basal cells. It is the most common form of cancer in the United States. Thankfully, Basal Cell Cardinomas are nearly always a relatively unaggressive form of Skin Cancer and typically do not spread beyond the original tumor site. However, Basal Cell Cardinoma Skin Cancer that is left untreated can result in severe disfigurement.
Despite a steady increase in occurance in the United States over the past decade and a half, less than 1 percent of Basal Cell Cardinoma Skin Cancers prove to be fatal. The slow-moving nature of the cancer often affords doctors the opportunity to apply a wide variety of treatment techniques, which usually result in the elimination of the disease before it can inflict serious damage on the patient.
Squamous Cell Carcinoma is a form of Skin Cancer in which abnormal cells begin arising in the skin's upper layers. They are the second most common form of Skin Cancer, accounting for nearly 20 percent of all non-Melanoma Skin Cancers.
They are relatively easy to detect due to the scaly red patches and open sores that the disease often creates. This, in combination with the slow-moving nature of the cancer, means that less than 1 percent of all those afflicted will eventually die as a result of their disease. However, some progress still must be made in terms of preventing the diseaes in the first place, as the occurance of Squamous Cell Carinoma has gone up a whopping 200 percent in the past three decades in the United States.
The aggressive nature of Melanoma Skin Cancer means that the likelihood of it responding positively to chemotherapy treatements is often quite low. While it can sometimes shrink tumors by as much as 15 percent, this is usually not enough to improve the survival rate of the patient as a whole. Thankfully, the emergence of new drugs such as Vemurafenib and Ipilimumab have the potential to transform Skin Cancer treatements as we know them, giving hope to patients that have otherwise exhausted all other options.
There exists within about 50 percent of Melanomas a gene called BRAF that assists in cell growth. A Phase III clinical trial analyzed the impact of Vemurafenib targeting the BRAF gene and the resulting effect that this had on overall survival rates. What they found was extraordinary, with a 63 percent increase in overall survival rates in patients whose cancer was otheriwse untreated and considered inoperable.
A seperate Phase III clinical trial combined Ipilimumab with traditional chemotherapy treatements to isolate the effect that the drug had on the survival rates of Skin Cancer patients. The results were extremely encouraging, with a whopping 8.6 percent increase in three-year survival rates when compared to those that did not recieve Ipilimumab. The impact of this study becomes even more significant when one considers that the trial included over 500 patients with Melanoma that could not be surgically removed, thus presenting them with life-saving options that did not exist in years past.
It has been discovered that nearly all cases of Skin Cancer can be prevented long before they become life threatening. This is due to the visible nature of the disease, as it often makes itself present in the form of visible sores and harsh rashes. It is for this reason that there has been a recent movement to promote public education regarding these terrible cancers, as increased awareness will undoubtably save lives as people learn to check themselves for signs of Skin Cancer and take steps to prevent themselves from ever contracting it in the first place.
Physicians have recently developed a simple system that will hopefully aid in the early detection of Melanoma, the deadliest form of Skin Cancer. Called the ABCDE system, it involves the self-examination of moles for visible features that are consistent with what one would find in a case of Melanoma. This allows people to sort the normal from the irregular, and will hopefully assist in the protection of people against the threat of developing Skin Cancers.
Additionally, the increased understanding of the causes of Skin Cancer has afforded people the opportunity to take steps to prevent themselves from contracting Skin Cancer in the first place. For instance, the discovery of the role of UV rays in the development of Skin Cancer has prompted a movement to educate people on the harms of these rays, and the reasonable steps that they can take to avoid them.
Founded over 35 years ago, The Skin Cancer Foundation is currently the only international organization whose sole focus is improving the prevention and treatment of Skin Cancer. They are responsible for the distribution of millions of medically-reviewed pamphlets, posters, books, and newsletters annually, all of which contribute greatly to the goal of educating the public about the dangers of Skin Cancer.
The Skin Cancer Foundation has also been responsible for donating over 1.5 million dollars to over 150 boundary-pushing research projects. And as 90 percent of all funds are directed to the services that they provide, those who donate can rest assured that their money will be used to its full potential to fight Skin Cancers.
The importance of this life-saving foundation cannot be overstated. Every dollar directed towards The Skin Cancer Foundation advances the fight against Skin Cancer, and serves to provide hope to the thousands that struggle with this terrible disease every day. You can join them in their fight by clicking on the button below to donate.
The American Skin Association has spent the past two decades fighting against Skin Cancers through the application of research grants and public outreach programs. They seek to make sure that everyone, regardless of race, age, or social status, has the opportunity to recieve education regarding the dangers of skin diseases and what can be done to prevent them.
Their active approach in combating these deadly diseases has led them to donate over 7.9 million dollars in advanced dermatological reasearch, something that they argue is "the key to earlier diagnosis, less invasive therapies and, in time, prevention and cure." This money supported the work of 150 investigators, something which ensures that a broad range of research in regards to Skin Cancer is achieved.
They also boast an impressive degree of financial transparency, with audited financial statements and IRS Form 990 filings dated back as far as 2006 publically avaliable. Additionally, they provide a detailed expenses breakdown which enables all those who donate to scrutinize where their money is actually going to. You can help them further their mission to defeat Skin Cancers by clicking the button to donate below.
With recent advancements in online communications, it is now possible to join the fight against Skin Cancers without spending a single penny. This is the power of word of mouth, the power of sharing our thoughts and ideas to make a change. You can click on the buttons below to get started. Spread the word!


Options
public struct Options
Used to initate ZalandoCommerceAPI
.
Note: can be fully or partially filled with data from Info.plist
file.
More on wiki
-
Identifier of a client / business entity / app. Required for correct operation, provided after access granted. See more
Declaration
Swift
public let clientId: String
-
Identifier of a sales channel. Required for correct operation, provided after access granted. See more
Declaration
Swift
public let salesChannel: String
-
Switches between sandbox and production environment.
Declaration
Swift
public let useSandboxEnvironment: Bool
-
Sets language of the interface. Overrides sales channel default language.
Declaration
Swift
public let interfaceLanguage: String?
-
Sets config service URL. In regular cases it shouldn’t be changed.
Declaration
Swift
public let configurationURL: URL
-
Sets if recommendations are handled by the host app.
Declaration
Swift
public let useRecommendations: Bool
-
init(clientId:salesChannel:useSandboxEnvironment:interfaceLanguage:configurationURL:useRecommendations:infoBundle:)
Initializes options for
ZalandoCommerceAPI
.Note
Fallback flow:
- the value from init
- Info.plist
Options.Default
Parameters:
- clientId: See
Options.clientId
- salesChannel: - See
Options.salesChannel
- useSandboxEnvironment: - See
Options.useSandboxEnvironment
- interfaceLanguage: - See
Options.interfaceLanguage
- configurationURL: - See
Options.configurationURL
- useRecommendations: - See
Options.useRecommendations
- bundle: bundle to look for
Info.plist
file with Options keys.
Declaration
Swift
public init(clientId: String? = nil, salesChannel: String? = nil, useSandboxEnvironment: Bool? = nil, interfaceLanguage: String? = nil, configurationURL: URL? = nil, useRecommendations: Bool? = nil, infoBundle bundle: Bundle = Bundle.main)
Parameters
clientId
See
Options.clientId
salesChannel
See
SeeOptions.salesChannel
useSandboxEnvironment
See
SeeOptions.useSandboxEnvironment
interfaceLanguage
See
SeeOptions.interfaceLanguage
configurationURL
See
SeeOptions.configurationURL
useRecommendations
See
SeeOptions.useRecommendations
bundle
bundle to look for
Info.plist
file with Options keys.
-
Initializes options for
ZalandoCommerceAPI
.Note
Fallback flow:
- the value from init
- Info.plist
Options.Default
Parameters:
- clientId: See
Options.clientId
- salesChannel: - See
Options.salesChannel
- useSandboxEnvironment: - See
Options.useSandboxEnvironment
- interfaceLanguage: - See
Options.interfaceLanguage
- configurationURL: - See
Options.configurationURL
- useRecommendations: - See
Options.useRecommendations
- bundle: bundle to look for
Info.plist
file with Options keys.
Declaration
Swift
public var description: String


Here are some of the categories currently available. Click on the link to view corresponding set of 'awesome' automations


--- title: BeoLiving Intelligence Advanced User Guide layout: pagetoc toc: true ---
This guide provides:
Most of the BeoLiving Intelligence configuration and usage in ESSENTIAL mode is done through the BeoLiving App. This Smart Device application lets you customize your installation and control all devices on it. BeoLiving Intelligence also provides a web interface, which out of the box provides Network settings and User access control management. After upgrading your controller to BeoLiving Intelligence PRO, the web interface becomes the most important tool for installation, configuration and programming.
Admin Sign-in: An installer can access the BLI setup interface with the admin user, which has an unknown password by default. The Setup button function 2 (check Button Functions) can be used for setting the admin password to “admin” for 5 minutes, and the BLI will request a password update as soon as the web interface is accessed.
{% for adv_guide in site.bli_advanced_user_guide %} {% if adv_guide.title != "BeoLiving Intelligence Advanced User Guide" %}


Arithmetic constraints can be reified as e.g.:
| ?- X in 1..2, Y in 3..5, X#=<Y #<=> B. B = 1, X in 1..2, Y in 3..5
Linear arithmetic constraints, except equalities, maintain bound-consistency and their reified versions detect bound-entailment and -disentailment; see The Constraint System.
The following constraints are among the library constraints that general arithmetic constraints compile to. They express a relation between a sum or a scalar product and a value, using a dedicated algorithm, which avoids creating any temporary variables holding intermediate values. If you are computing a sum or a scalar product, it can be much more efficient to compute lists of coefficients and variables and post a single sum or scalar product constraint than to post a sequence of elementary constraints.
sum(
+Xs,
+RelOp,
?Value)
sum(
Xs)
RelOp Value.
Cannot be reified. Corresponds roughly to sumlist/2
in library(lists)
.
scalar_product(
+Coeffs,
+Xs,
+RelOp,
?Value)
scalar_product(
+Coeffs,
+Xs,
+RelOp,
?Value,
+Options)
sum(
Coeffs*Xs)
RelOp Value. Cannot be reified.
Options is a list that may include the following option. It can be used to control the level of consistency used by the constraint.
consistency(
Cons)
domain
#=
, and requires that any domain variables have finite bounds.
bound
value
The following constraints constrain a value to be the minimum (maximum) of a given list of values.
minimum(
?Value,
+Xs)
min_member/2
in library(lists)
.
maximum(
?Value,
+Xs)
max_member/2
in library(lists)
.


Jun 26 2018
Issue 42
Progressive Web Apps: A Technical Approach …
--- layout: default title: Offline First News root_path: ../ tab: news ---
Progressive Web Apps: A Technical Approach …
Progressive Progressive Web Apps …
Progressive Web Apps with Ionic and Firebase …
Get Started With Workbox For Webpack …
The rhythm of the stride, and other case studies …
Welcome to the world of Offline First in 2018 …
PWA Feature Detector …
As we build sites more heavily reliant on JavaScript, we sometimes pay …
Can You Afford It?: Real-world Web Performance Budgets …
Announcing Offline Camp Oregon …
Building a hybrid-rendered PWA …
A community-approved Progressive Web Apps logo …
Progressing the web …
Predictable, Progressive, Performant …
The making of Twitter Lite …
Go Offline First to Save the World …
Build your first progressive web app with React …
From AMP to Progressive Web App …
Announcing The Offline First Book …
Progressive Web Tetris …
Announcing Offline Camp Berlin …
The new mobile first: Why Offline First should be on every developer’s radar …
The Day the Internet Died …
What is Offline Camp? on Whenever Works …
The Apache CouchDB development community is proud to announce …
Why “Progressive Web Apps vs. native” is the wrong question …
The latest from Offline Camp …
About that ‘mobile’ in Accelerated Mobile Pages …
Instant Loading: Building offline-first Progressive Web Apps …
Wait! The Web Isn’t Dead After All …
Announcing Offline Camp …
Web Powered SMS Inbox with Service Worker …
Introducing Soundslice offline mode …
Alex from the Hoodie team with an overview of how minutes.io …
Don’t Wait for ServiceWorker: Adding Offline Support with One-Line …
The Web Platform Podcast did its 60th episode on “Offline First” …
A Deep Dive into Offline First with PouchDB and IBM Cloudant …
Taking Ember Offline …
An offline conference site, Google's offline SDK, offline Music-Sharing in Africa …
ThoughWorks Radar, Dropbox Sync API, the UX of Offline First …
Ola Gasidlo gave an "Offline First" talk at Conc.at …
Offline is not just another mobile feature …