WebSiteName
Home
Page 1
Page 1-1
Page 1-2
Page 1-3
Page 2
Page 3
Daily Emotion Analysis
Sign up
Sign up
Sign up


Upholstery cleaned by The Ultimate Clean can restore the beauty and extend the life span of your favorite piece of furniture.
We are certified and educated to current industry standards and for your peace of mind we carry full current insurance policies and police clearances
We make sure the fabric is colour fast and assess any tears or deterioration.
An essential step in Upholstery cleaning, we use a purpose designed hand piece on a powerful vacuum system to remove hairs and fine soil from the upholstery before cleaning.
A cleaning agent is applied to the upholstery to assist the breakdown of oils which accumulate from our skin and even the oil from your pet’s fur.
A pre-treatment is not enough to completely break down the oils in the fabric. We hand scrub the fabric with a horse hair brush or microfiber glove designed specifically for cleaning your family’s Upholstery.
Our powerful hot truck-mount upholstery cleaner is then used to flush out the dirt and cleaning agents from your upholstery achieving tempreatures around 130oC. Extra drying passes are performed for quick drying.
We can apply an Anti-Soiling protector on the furniture after cleaning. This helps to repel the oils on the skin and helps the upholstery stay cleaner for longer!
Our air mover is placed into position to help with the drying process after cleaning.
Our new air movers dry your tiles within minutes allowing you can walk on them immediately.


Since NG-Europe 2014 and the announcement of Angular2 , a lots of change have been made...
The core is still "Angular"
Keep only the good parts of the original Framework
A lot of people was discourage by the change
The AngularTeam work hard to improve Migration Path
An extension of Javascript should have been the reference language
But Google/Microsoft teams-up to improve TypeScript
It's True but the AngularTeam have something to help the migration...
No It will be supported during two years after the release of Angular2
And your app won't stop working after this...
AngularJS is a macro-framework with :
Help to conserve SOLID principle in application
angular.module('myApp', [])
.constant('Engine', function(){}).
.constant('Tires', function(){}).
.service('Car', Car);
function Car(Engine, Tires){...};
Car.$inject('Engine', 'Tires');
In ES2015
import { Inject } from 'angular2/core';
class Car {
constructor(@Inject(Engine) engine, @Inject(Tires) tires) {}
}
In TypeScript
class Car {
constructor(engine: Engine, tires: Tires) {}
}
So it's just a Map<Token, Provider>
import { Injector } from 'angular2/core';
...
let injector = Injector.resolveAndCreate([
Car,
Engine,
Tires
]);
let car = injector.get(Car);
import { Injector, provide } from 'angular2/core';
...
let injector = Injector.resolveAndCreate([
provide(Car, {useClass: Car}),
provide(Engine, {useClass: Engine}),
provide(Tires, {useClass: Tires})
]);
import { Injector, provide } from 'angular2/core';
...
let injector = Injector.resolveAndCreate([
Car, // Class as a Provider
provide(Car, {useClass: Car}), // Full description of Provider, allow aliases
provide(Car, {
useFactory : (engine, tire) => new Car(engine, tire),
deps : ['Engine', 'Tire']
}), // Provide Car from Factory
provide(Tire, {useValue: "Tire"}), // Use Value
SuperEngine,
provide(Engine, {useExisting : SuperEngine }), // Use Alias
]);
Singleton only inside the same injectors
import { Injector } from 'angular2/core';
let injector = Injector.resolveAndCreate([Engine]);
let childInjector = injector.resolveAndCreateChild([Engine]);
injector.get(Engine) === injector.get(Engine);
injector.get(Engine) !== childInjector.get(Engine);
Zones are simply an Execution context for Javascript
Zones are simply an Execution context for Javascript
It helps to handle asynchronous code in JS
Extract from Dart Lang, alternative to Domains in NodeJS
function cf(name) { return function() { console.log(name); } };
var a = cf('a'), b = cf('b'), c = cf('c'), d = cf('d');
a();
setTimeout(b, 0);
setTimeout(c, 0);
d();
Results to
a
d
b
c
All the async tasks are added to the event queue and executed when other tasks are finished
start();
a();
setTimeout(b, 0);
setTimeout(c, 0);
d();
stop();
Results :
// Start
a
d
// Stop
b // Missed
c // Missed
Let's consider a framework, for example AngularJS with this:
var $rootScope;
zone
.fork({
afterTask : function() {
$rootScope.$digest();
}
})
.run(function() {
angular.bootstrap(document, aModule);
$rootScope = angular
.element(document)
.injector()
.get('$rootScope');
});
A polifyll for ES2017 (?) module loader
In AngularJS (it's so 2009...)
angular.module('FooModule', [
'BarModule',
'anotherModule'
]);
In ES2015 & SystemJS
import { BarModule } from './Bar.comp';
import { AnotherComp } from './another.comp';
Simple to maintain !
Angular2 is fully modular
Reduce the size of the app depending of what your app need
No... you can use what you want
Born in 2006 and help a lot of Web developers...
Good fallback to do more in a complicated world
let firstClass = document.querySelector('.some-class');
let allOfClass = document.querySelectorAll('.some-class');
let elem = document.querySelector('#some-element');
elem.classList.add('some-class'); // Add class
elem.classList.remove('some-other-class'); // Remove class
elem.classList.toggle('some-other-class') // ...toggle...
elem.classList.contains('some-third-class') // Does it have some class ?
Same thing on inline style...
elem.style.color; // Get a CSS attribute
elem.style.color = 'rebeccapurple'; // Set a CSS attribute
elem.style.minHeight; // Get a CSS attribute
elem.style.minHeight = '200px'; // Set a CSS attribute
let elem = document.querySelector('#some-element');
elem.addEventListener('click', () => console.log('clicked'), false);
elem.addEventListener('customEvent', anotherFunction, false);
let elem = document.querySelector('#some-element');
let parent = elem.parentNode;
let childs = elem.childNodes;
let specificChild = elem.querySelector('anotherClass');
let specificChilds = elem.querySelectorAll('anotherClass');
var TodoComp = ng
.Component({
selector: 'todo',
templateUrl: '../partials/todo.html'
})
.Class({
constructor: function (heroService, routeParams) {}
select(todo){...}
});
But, it isn't as fun as evolved JS
@Component({
selector: 'todo',
templateUrl: '../partials/todo.html'
})
export class TodoComp {
constructor(
private heroService: HeroService,
private routeParams: RouteParams
){}
select(todo){...}
}
All is about Component
EVERYWHERE !
Template + Controller (+ optional RouteConfig)

My title is {{ title }}

No more ng-x directives
Instead, we use standard HTML for property binding

Your favorite hero is: {{ vm.favoriteHero }}

becomes...

Your favorite hero is: {{ favoriteHero }}

Really no more ng-x directives
Again, we use standard HTML for event binding
<input ng-click="vm.send(foo)">Click me !</input>
becomes...
<input (click)="send($event)">Click me !</input>
It disappears, so we have to do it manually
<input [value]="hero.firstName"
(input)="hero.firstName=$event.target.value" >
The API evolves to introduce a syntax for the two-way binding in latest Alpha
<input [(ngModel)]="hero.firstname">
This syntax is a mix between property and event bindings
All the directive inducing a dom modification outside of the current element are called Structural Directive

condition is true and ngIf is true.

{{movie.name}}

But Why ?
<template>

A super template !

</template>
This template isn't rendered by the browser but can be used

A super template !

<template [ngIf]="condition">

A super template !

</template>
So, the * is just a syntaxic sugar
And we can write our own Structural Directive !
We can define a template variable associated to a dom element
<video #player src="foo.mp4"></video>
<button (click)="player.play()"></button>
Still holding all the logic of the component
And compared to Angular1, a component is a tiny "App"
import { Component } from 'angular2/core';
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1>`
})
export class TodoComp {
public title : String = 'A super presentation !!';
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1>`
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){} // DI in constructor
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1>`,
providers : [ MyService ] // Do you remember the injector part ?
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){} // DI in constructor
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
@Component({
selector: 'todo',
template: `

{{ title }}

<emitter></emitter>
`,
providers : [ MyService ]
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){}
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
import { EmitterComponent } from "./emitter.component";
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1> <emitter></emitter>`,
directives : [ EmitterComponent ] // Inclusion of all subComp needed
providers : [ MyService ]
})
export class TodoComp {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){}
}
import { Component } from 'angular2/core';
import { MyService } from './myservice';
import { EmitterComponent } from "./emitter.component";
@Component({
selector: 'todo',
template: `<h1>{{ title }}</h1> <emitter></emitter>`,
directives : [ EmitterComponent ] // Inclusion of all subComp needed
providers : [ MyService ]
})
export class TodoComp implements OnInit {
public title : String = 'A super presentation !!';
constructor(private _myService : MyService){}
ngOnInit() { console.log('The Component is initialised'); }
}
No more headache with [pre|post]link and compile
We have now a component, but we want to communicate with other element
How could we do that without any DDO ?
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input() counterValue = 0;
}
<counter [counterValue]="10"></counter>
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input('start') counterValue = 0;
}
<counter [start]="10"></counter>
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input('start') counterValue = 0;
@Output() onChangeEmitter = new EventEmitter<Event>();
}
<counter [start]="10" (onChangeEmitter)="show($event)"></counter>
import {Component, Input} from 'angular2/core';
@Component({
selector: 'counter'
template: `...`
})
export class CounterCmp {
@Input('start') counterValue = 0;
@Output('onChange') onChangeEmitter = new EventEmitter<Event>();
}
<counter [start]="10" (onChange)="show($event)"></counter>
No more of
<foo bar="val"></foo>
<foo bar="{{ val }}"></foo>
<foo bar="val()"></foo>
<foo bar="val"></foo>


RevShare
Revenue Sharing Contract
Address
Password
Balance
Proportion %
Contract
ETH
Recipient A
ETH
Recipient B
ETH
Click to unlock and confirm owner accounts
Set Recipients
Pay Contract
Web
SEND
Coinbase Balance:
Mobile
Kill Contract
Kill


The Enumerable class is an extremely powerful one in Ruby. This class gives you several ways to iterate through a collection of items and temporarily hold them until you are ready to change the orginal collection or create a brand new collection.
The partition method will return an array containing items meeting the criteria you defined and a second array containing the items that did not meet your criteria. This can greatly simplify solutions that require you to divide one collection into many. Here's an example of how you might be doing this today without the partition method. In the example below we want to take a hash of names and ages and break them into two collections. One collection should contain the people with ages less than the one we define. The rest should go into a separate collection:
def group_method(name_age_hash, age)
below_age = name_age_hash.select { |k,v| v <= age}.to_a.compact
above_age = name_age_hash.select { |k,v| v > age}.to_a.compact
output = below_age, above_age
end
Note how we're repeating ourselves in the above example when trying to divide the array into two collections. We're also using a step to combine the two arrays at the end. Here's how you could do the same thing using the partition method:
def my_hash_splitting_method(source, age)
source.partition { |k,v| v <= age}.to_a
end
This will accomplish the same objective with much simpler and DRY code.