--- ---
Gets the internal State object API
Gets the internal API for a registered state.
Note: the internal StateObject API is subject to change without notice
Abstract state indicator
An abstract state can never be directly activated. Use an abstract state to provide inherited properties (url, resolve, data, etc) to children states.
An inherited property to store state data
This is a spot for you to store inherited state metadata.
Child states' data
object will prototypally inherit from their parent state.
This is a good spot to put metadata such as requiresAuth
.
Note: because prototypal inheritance is used, changes to parent data
objects reflect in the child data
objects.
Care should be taken if you are using hasOwnProperty
on the data
object.
Properties from parent objects will return false for hasOwnProperty
.
Marks all the state's parameters as dynamic
.
All parameters on the state will use this value for dynamic
as a default.
Individual parameters may override this default using ParamDeclaration.dynamic in the params block.
Note: this value overrides the dynamic
value on a custom parameter type (ParamTypeDefinition.dynamic).
A function used to lazy load code
The lazyLoad
function is invoked before the state is activated.
The transition waits while the code is loading.
The function should load the code that is required to activate the state. For example, it may load a component class, or some service code. The function must return a promise which resolves when loading is complete.
For example, this code lazy loads a service before the abc
state is activated:
.state('abc', {
lazyLoad: (transition, state) => import('./abcService')
}
The abcService
file is imported and loaded
(it is assumed that the abcService
file knows how to register itself as a service).
The lazyLoad
function is invoked if a transition is going to enter the state.
The function is invoked before the transition starts (using an onBefore
transition hook).
The function is only invoked once; while the lazyLoad
function is loading code, it will not be invoked again.
For example, if the user double clicks a ui-sref, lazyLoad
is only invoked once even though there were two transition attempts.
Instead, the existing lazy load promise is re-used.
When the promise resolves successfully, the lazyLoad
property is deleted from the state declaration.
If the promise resolves to a LazyLoadResult which has an array of states
, those states are registered.
The original transition is retried (this time without the lazyLoad
property present).
If the lazyLoad
function fails, then the transition also fails.
The failed transition (and the lazyLoad
function) could potentially be retried by the user.
State definitions can also be lazy loaded. This might be desirable when building large, multi-module applications.
To lazy load state definitions, a Future State should be registered as a placeholder. When the state definitions are lazy loaded, the Future State is deregistered.
A future state can act as a placeholder for a single state, or for an entire module of states and substates. A future state should have:
name
which ends in .**
.
A future state's name
property acts as a wildcard Glob.
It matches any state name that starts with the name
(including child states that are not yet loaded).url
prefix.
A future state's url
property acts as a wildcard.
UI-Router matches all paths that begin with the url
.
It effectively appends .*
to the internal regular expression.
When the prefix matches, the future state will begin loading.lazyLoad
function.
This function should should return a Promise to lazy load the code for one or more StateDeclaration objects.
It should return a LazyLoadResult.
Generally, one of the lazy loaded states should have the same name as the future state.
The new state will then replace the future state placeholder in the registry.For in depth information on lazy loading and Future States, see the Lazy Loading Guide.
// This child state is a lazy loaded future state
// The `lazyLoad` function loads the final state definition
{
name: 'parent.**',
url: '/parent',
lazyLoad: () => import('./lazy.states.js')
}
This file is lazy loaded. It exports an array of states.
import {ChildComponent} from "./child.component.js";
import {ParentComponent} from "./parent.component.js";
// This fully defined state replaces the future state
let parentState = {
// the name should match the future state
name: 'parent',
url: '/parent/:parentId',
component: ParentComponent,
resolve: {
parentData: ($transition$, ParentService) =>
ParentService.get($transition$.params().parentId)
}
}
let childState = {
name: 'parent.child',
url: '/child/:childId',
params: {
childId: "default"
},
resolve: {
childData: ($transition$, ChildService) =>
ChildService.get($transition$.params().childId)
}
};
// This array of states will be registered by the lazyLoad hook
let lazyLoadResults = {
states: [ parentState, childState ]
};
export default lazyLoadResults;
The state name (required)
A unique state name, e.g. "home"
, "about"
, "contacts"
.
To create a parent/child state use a dot, e.g. "about.sales"
, "home.newest"
.
Note: [State] objects require unique names. The name is used like an id.
A Transition Hook called with the state is being entered. See: IHookRegistry.onEnter
.state({
name: 'mystate',
onEnter: function(trans, state) {
console.log("Entering " + state.name);
}
});
Note: The above onEnter
on the state declaration is effectively sugar for:
transitionService.onEnter({ entering: 'mystate' }, function(trans, state) {
console.log("Entering " + state.name);
});
A Transition Hook called with the state is being exited. See: IHookRegistry.onExit
.state({
name: 'mystate',
onExit: function(trans, state) {
console.log("Leaving " + state.name);
}
});
Note: The above onRetain
on the state declaration is effectively sugar for:
transitionService.onExit({ exiting: 'mystate' }, function(trans, state) {
console.log("Leaving " + state.name);
});
A TransitionStateHookFn called with the state is being retained/kept. See: IHookRegistry.onRetain
.state({
name: 'mystate',
onRetain: function(trans, state) {
console.log(state.name + " is still active!");
}
});
Note: The above onRetain
on the state declaration is effectively sugar for:
transitionService.onRetain({ retained: 'mystate' }, function(trans, state) {
console.log(state.name + " is still active!");
});
Params configuration
An object which optionally configures parameters declared in the url, or defines additional non-url parameters. For each parameter being configured, add a ParamDeclaration keyed to the name of the parameter.
params: {
param1: {
type: "int",
array: true,
value: []
},
param2: {
value: "index"
}
}
The parent state
Normally, a state's parent is implied from the state's name, e.g., "parentstate.childstate"
.
Alternatively, you can explicitly set the parent state using this property.
This allows shorter state names, e.g., Child
instead of `Child
When using this property, the state's name should not have any dots in it.
var parentstate = {
name: 'parentstate'
}
var childstate = {
name: 'childstate',
parent: 'parentstate'
// or use a JS var which is the parent StateDeclaration, i.e.:
// parent: parentstate
}
Synchronously or asynchronously redirects Transitions to a different state/params
If this property is defined, a Transition directly to this state will be redirected based on the property's value.
If the value is a string
, the Transition is redirected to the state named by the string.
If the property is an object with a state
and/or params
property,
the Transition is redirected to the named state
and/or params
.
If the value is a TargetState the Transition is redirected to the TargetState
If the property is a function:
Note: redirectTo
is processed as an onStart
hook, before LAZY
resolves.
If your redirect function relies on resolve data, get the Transition.injector and get a
promise for the resolve data using UIInjector.getAsync.
// a string
.state('A', {
redirectTo: 'A.B'
})
// a {state, params} object
.state('C', {
redirectTo: { state: 'C.D', params: { foo: 'index' } }
})
// a fn
.state('E', {
redirectTo: () => "A"
})
// a fn conditionally returning a {state, params}
.state('F', {
redirectTo: (trans) => {
if (trans.params().foo < 10)
return { state: 'F', params: { foo: 10 } };
}
})
// a fn returning a promise for a redirect
.state('G', {
redirectTo: (trans) => {
let svc = trans.injector().get('SomeAsyncService')
let promise = svc.getAsyncRedirectTo(trans.params.foo);
return promise;
}
})
// a fn that fetches resolve data
.state('G', {
redirectTo: (trans) => {
// getAsync tells the resolve to load
let resolvePromise = trans.injector().getAsync('SomeResolve')
return resolvePromise.then(resolveData => resolveData === 'login' ? 'login' : null);
}
})
Marks all query parameters as ParamDeclaration.dynamic
Resolve - a mechanism to asynchronously fetch data, participating in the Transition lifecycle
The resolve:
property defines data (or other dependencies) to be fetched asynchronously when the state is being entered.
After the data is fetched, it may be used in views, transition hooks or other resolves that belong to this state.
The data may also be used in any views or resolves that belong to nested states.
Each array element should be a ResolvableLiteral object.
The user
resolve injects the current Transition
and the UserService
(using its token, which is a string).
The [[ResolvableLiteral.resolvePolicy]] sets how the resolve is processed.
The user
data, fetched asynchronously, can then be used in a view.
var state = {
name: 'user',
url: '/user/:userId
resolve: [
{
token: 'user',
policy: { when: 'EAGER' },
deps: ['UserService', Transition],
resolveFn: (userSvc, trans) => userSvc.fetchUser(trans.params().userId) },
}
]
}
Note: an Angular 2 style useFactory
provider literal
may also be used. See ProviderLike.
resolve: [
{ provide: 'token', useFactory: (http) => http.get('/'), deps: [ Http ] },
]
The resolve
property may be an object where:
This style is based on AngularJS injectable functions, but can be used with any UI-Router implementation. If your code will be minified, the function should be "annotated" in the AngularJS manner.
resolve: {
// If you inject `myStateDependency` into a controller, you'll get "abc"
myStateDependency: function() {
return "abc";
},
// Dependencies are annotated in "Inline Array Annotation"
myAsyncData: ['$http', '$transition$' function($http, $transition$) {
// Return a promise (async) for the data
return $http.get("/foos/" + $transition$.params().foo);
}]
}
Note: You cannot specify a policy for each Resolvable, nor can you use non-string
tokens when using the object style resolve:
block.
Since a resolve function can return a promise, the router will delay entering the state until the promises are ready. If any of the promises are rejected, the Transition is aborted with an Error.
By default, resolves for a state are fetched just before that state is entered.
Note that only states which are being entered during the Transition
have their resolves fetched.
States that are "retained" do not have their resolves re-fetched.
If you are currently in a parent state parent
and are transitioning to a child state parent.child
, the
previously resolved data for state parent
can be injected into parent.child
without delay.
Any resolved data for parent.child
is retained until parent.child
is exited, e.g., by transitioning back to the parent
state.
Because of this scoping and lifecycle, resolves are a great place to fetch your application's primary data.
During a transition, Resolve data can be injected into:
ui-view
tag)Resolve functions usually have dependencies on some other API(s).
The dependencies are usually declared and injected into the resolve function.
A common pattern is to inject a custom service such as UserService
.
The resolve then delegates to a service method, such as UserService.list()
;
UIRouter
: The UIRouter instance which has references to all the UI-Router services.Transition
: The current Transition object; information and API about the current transition, such as
"to" and "from" State Parameters and transition options.'$transition$'
: A string alias for the Transition
injectable'$state$'
: For onEnter
/onExit
/onRetain
, the state being entered/exited/retained.// Injecting a resolve into another resolve
resolve: [
// Define a resolve 'allusers' which delegates to the UserService.list()
// which returns a promise (async) for all the users
{ provide: 'allusers', useFactory: (UserService) => UserService.list(), deps: [UserService] },
// Define a resolve 'user' which depends on the allusers resolve.
// This resolve function is not called until 'allusers' is ready.
{ provide: 'user', (allusers, trans) => _.find(allusers, trans.params().userId, deps: ['allusers', Transition] }
}
Sets the resolve policy defaults for all resolves on this state
This should be an ResolvePolicy object.
It can contain the following optional keys/values:
when
: (optional) defines when the resolve is fetched. Accepted values: "LAZY" or "EAGER"async
: (optional) if the transition waits for the resolve. Accepted values: "WAIT", "NOWAIT", CustomAsyncPolicySee ResolvePolicy for more details.
The url fragment for the state
A URL fragment (with optional parameters) which is used to match the browser location with this state.
This fragment will be appended to the parent state's URL in order to build up the overall URL for this state. See UrlMatcher for details on acceptable patterns.
Named views
An optional object which defines multiple views, or explicitly targets specific named ui-views.
What is a view config
What is a ui-view
Shorthand controller/template
Incompatible with ^
Examples:
Targets three named ui-views in the parent state's template
views: {
header: {
controller: "headerCtrl",
templateUrl: "header.html"
}, body: {
controller: "bodyCtrl",
templateUrl: "body.html"
}, footer: {
controller: "footCtrl",
templateUrl: "footer.html"
}
}
Generated using TypeDoc
The StateDeclaration object is used to define a state or nested state.
Note: Each implementation of UI-Router (for a specific framework) extends this interface as necessary.
Example:
// StateDeclaration object var foldersState = { name: 'folders', url: '/folders', component: FoldersComponent, resolve: { allfolders: function(FolderService) { return FolderService.list(); } }, } registry.register(foldersState);


Write in HTML file
Create your component with the styles (scoped or not) and scripts, embedded in a single pure HTML file.
No Virtual DOM
Easy listens to each property (made available by the instance) in the application, when the property changes, it updates the element.
Reuse elements
Easy gives you the opportunity to reuse elements already defined in the application, as if it were a copy and paste.
What's Easy.js? Is a javascript library for building user interfaces, and helps in the web applications development, providing a synchronous interaction between user interfaces and Javascript data. In some ways and commands, it is very similar to Vue.js and Angular.js, but it handles things differently!
Hello World Example
To begin showing some data in the UI is simple as you can see now... Some directives can be similar to Vue but, believe us, there are diferentes by the inside.
Simple Sum Example
Let's Two Way Data Bind now...
We are using dynamic data property definition e-def. In this type of binding when some value changes, it updates the specific field in the element, it means that your element will be always the same.
Todo List Example
Let's make a TODO List App
You can manage your list as you expect, and they are reactives to changes.
Want to Learn more?
Get StartedReleased under the MIT License
Copyright © 2019-Present, Afonso Matumona


HAIRSPRAY, THE LAST EMPEROR, THE UNBEARABLE LIGHTNESS OF BEING [Spoilers] Three Quickie Reviews by Jeff Meyer Copyright 1988 Jeff Meyer
Quick three film reviews, so I can start up on the Seattle Film Festival (yes, here we go again -- a pre-festival report will be out before the Thursday night starting gun).
HAIRSPRAY:
Not much to say other than very entertaining film and a few comments:
Never thought I'd see the day when I'd take my parents to see a John Waters film. And they'd enjoy it as much as I did, if not more...
Noticed the poster as I went out -- this film is the first film in years that had everyone who had the entire solarsphere of critics behind it. Siskel & Ebert, Reed, NEW YORK TIMES, the L.A. paper, TIME, NEWSWEEK, VILLAGE VOICE, and (I believe) a favorable quote from Kael. When did this last happen? GONE WITH THE WIND? (Waters would love that on his ad -- "The first film to gather universal praise since GONE WITH THE WIND!").
Basically, this is the same as one of those Kurt Russell Disney films where the school outcasts have good things happen to them with a minimum of struggle in a Happy Environment. Except that these people are outcast which ol' Walt would never have approved of (let's face it -- Kurt Russell an outcast? ESCAPE FROM NEW YORK, maybe, but he had Adrienne Barbeau...). And, more importantly, Water's never loses his spoofing, satirical bite -- in fact, it runs concurrently with the starry-eyed plot, neither stealing cycles from the other.
A solid $4.50 film. Take the kids, they'll love it (the 10-year-olds in the audience were really enjoying it, and I'd deem everything in this film wholesome for 10-year-olds, or even 6-year-olds).
THE LAST EMPEROR:
So this is what all the hoopla is about. Well, it's a good film; my main observation would be that the best part of the thing was John Lone's performance as the Emperor, and that's the one thing the film didn't get nominated for (which keeps my opinion of the awards at it's previously low level). Nice ending, but rather bloodless for an epic. You can either do an epic without involving interesting characters intelligently or ridiculously, but it needs to be pervaded with an overpowering sense of the Larger-than-Life.  ZHIVAGO.
Again, a nice ending. $2.50 film, see it on Economy Hour.
 It's one of those love stories which follows the lives of several characters over a period of years. It works, but it has drawbacks. Daniel Day Lewis (what *has* this man played in before? His face looks very familiar -- oh, wait, I know, MY BEAUTIFUL LAUNDRETTE) and the actress who plays his lover tend to be rather hollow through much of the film. The actress who plays his wife, though, comes off very well, and damn near saves the film during the last half-hour. Good parts: their early encounters, the invasion of Czechoslovakia, their return, the move to the farm (I have great affection for merry older rural people. And pigs.) Bad points: Day and his character's lover's affairs, the photo-session scene.
Two Points: Why is this film considered more "sexually honest" than others? I keep hearing that from all sorts of newspaper reviews.  They squeal more realistically during intercourse in this film? I guess film journalists live fairly Bohemian lives...
Second one has a spoiler at end...
And... do you think that the Czech couple really die in the end? Or is it that Day's character, in his typically egocentric manner, is day-dreaming about his lover's reaction to news of their death? I go for the former, but either way, it's a damn inventive way to end the film, and very satisfying.
Moriarty, aka Jeff Meyer INTERNET<EMAIL_ADDRESS>Manual UUCP: {uw-beaver, sun, microsoft}!fluke!moriarty
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Modules and classes in Ruby may seem very similar at first, as they can both be used to group methods and variables. While they both serve the purpose of operating in concert with other Ruby classes and objects to define and share their functionality, one of the easiest differences to remember to keep them straight is that a class can be instantiated while a module cannot. What this means is that since a class is a group of methods and variables that "model" a group of similar objects, you can instantiate a class &em; create an "instance" of it &em; which gives you a new object with all of the properties of that class that you can then add to and customize to suit that particular object. With a module, you cannot instantiate a new object from it, you can simply reference it in a class to extend the functionality of that module to the class. Where it gets even trickier is that classes can be part of a module's code. However, in order to include the functionality of a module within a class, the module file has to be linked to the class using either "load," "include", "require," or "extend." So what is a module useful for if you can't create new objects from it? A module is a series of methods and variables defined within a file separate from a single class so that the module's properties can be shared across multiple classes. A good example of why you might want to use a module would be something that changes the behavior of all classes it affects depending on what the method stored in it returns &em; an authentication, for instance. This common use of modules &em; to extend and mix in properties of a module as if it were actually a superclass of the class its affecting &em; is therefore called a mixin for a very good reason.


MPI defines a timer. A timer is specified even though it is not ``message-passing,'' because timing parallel programs is important in ``performance debugging'' and because existing timers (both in POSIX 1003.1-1988 and 1003.4D 14.1 and in Fortran 90) are either inconvenient or do not provide adequate access to high resolution timers. See also Section Functions and Macros .
double MPI_Wtime(void)
DOUBLE PRECISION MPI_Wtime()
DOUBLE PRECISION MPI_WTIME()
MPI_WTIME returns a floating-point number of seconds,
representing elapsed wall-clock time since some time in
the past.
The ``time in the past'' is guaranteed not to change during the life of the process. The user is responsible for converting large numbers of seconds to other units if they are preferred.
This function is portable (it returns seconds, not ``ticks''), it allows high-resolution, and carries no unnecessary baggage. One would use it like this:
{ double starttime, endtime; starttime = MPI_Wtime(); .... stuff to be timed ... endtime = MPI_Wtime(); printf("That took %f seconds\n",endtime-starttime); }The times returned are local to the node that called them. There is no requirement that different nodes return ``the same time.'' (But see also the discussion of MPI_WTIME_IS_GLOBAL in Section Clock Synchronization ).
double MPI_Wtick(void)
DOUBLE PRECISION MPI_Wtick()
DOUBLE PRECISION MPI_WTICK()
MPI_WTICK returns the resolution of
MPI_WTIME in seconds. That is, it
returns, as a double precision value, the number of seconds between successive
clock ticks.
For example, if the clock is implemented by the hardware as a counter that is
incremented every millisecond, the value returned by MPI_WTICK
should be 10-3.


Shopping Cart
Product
Price
Quantity
Subtotal
Product A
$10
$0
Product B
$20
$0
Product C
$15
$0
Total
0
$0
Update


LOGRESOLVE
Section: logresolve (8)Updated: 2005-06-29
Index Return to Main Contents
NAME
logresolve - Resolve IP-addresses to hostnames in Apache log filesSYNOPSIS
logresolve [ -s filename ] [ -c ] < access_log > access_log.new
SUMMARY
logresolve is a post-processing program to resolve IP-addresses in Apache's access logfiles. To minimize impact on your nameserver, logresolve has its very own internal hash-table cache. This means that each IP number will only be looked up the first time it is found in the log file.
Takes an Apache log file on standard input. The IP addresses must be the first thing on each line and must be separated from the remainder of the line by a space.
OPTIONS
- -s filename
- Specifies a filename to record statistics.
- -c
-
This causes logresolve to apply some DNS checks: after finding the hostname from the IP address, it looks up the IP addresses for the hostname and checks that one of these matches the original address.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:05 GMT, December 24, 2015


{% load static %}
Guest House is located on the oppposite side of SVNIT main gate on Surat-Dumas road.It has 12 fully furnshed rooms along with telephone lines and Television.
Skip waiting in long queues. Order from anywhere and munch on food as soon as you reach canteen.
Guest House is located on the oppposite side of SVNIT main gate on Surat-Dumas road.It has 12 fully furnshed rooms along with telephone lines and Television.


Registration
Nobel Commons
4:30 – 5:30 PM
Opening Ceremonies
Auditorium
5:45 – 6:30 PM
Committee Session 1
Committee Rooms
6:45 – 9:30 PM
Committee Session 2
Committee Rooms
9:00 – 12:30 PM
Lunch (Staggered by Committee in 30 minute intervals)
All MS Committees
HS Crisis and Specialized Committees
HS General Assemblies
Cafeteria
12:00 – 1:30 PM
11:30 – 12:00 PM
12:00 – 12:30 PM
12:30– 1:00 PM
Committee Session 3
Committee Rooms
12:30 – 2:00 PM
Closing Ceremonies
Auditorium
2:30 – 3:30 PM


{% extends "patterns/base_page.html" %} {% load wagtailcore_tags wagtailimages_tags %} {% block content %} {# Title and Filters #} {% include "patterns/molecules/title-block/title-block.html" with item=page tags=related_services %} {# Events #}
There are no upcoming events.
Check back soon as we add them regularly!


- Professional Scrum Master 1
Summary
I continually strive to improve myself as a software craftsman. Software Craftsman is way to be in the day to day work. My objective is to develop clean code, improve code quality and avoid manual steps which are source of confusion and error prone.
I have been working in several mid to large size projects. On each projects, I have been involved in introducing or enhancing unit testing, build process, continuous integration mechanisms.
I am really focused on how things are done in term of software architecture, components deployment and automation. I do not like big monolithic softwares with hard coupled dependencies. On each projects I have been working on, I try to break dependencies and isolate what MUST be isolated.
The biggest problem I met is not really the technical part, but the human one. Generally, people do not like changes. And doing work as they always did is something hard to change in mind. I DO my best as a SCRUM Master.
See also :
Personal project :
This project implies following technologies :
- ElasticSearch
- node.js + REST Api definition
- nginx setup
- Backbone.js
Main Skills:
- Human relationships
- Competitive C/C++ skills (multithreading, Design Patterns, Boost, Metaprogramming, STL/Boost)
- C#, Powershell, Notes Api, WCF
- Node.js / Python / Erlang
- Competitive Linux skills
- Distributed application development with middleware such as Corba, RMI, NServiceBus
- Financial IT: Financial Kit, FIX, Equities Markets, Black-Scholes Pricing Model, Financial Valuation
- Embedded Systems develoment (QNX)
- Aware with Web Development (Ajax, Xhtml, Javascript)
Professional experiences
Senior Software Engineer
- Develop reliable micro services for everything related to money @Uber (onboarding, checkout, transaction history)
- Drive reliability engineering for the services my team owns (monitoring, alerting, on call actions)
- Responsible for defining technical specifications in agreement with my team composed of 8 backend engineers
- Provide software engineering guidelines for more junior team members.
- Mentor junior engineers
Head Of Development
- Leading by example. Continuously supporting team members (Training, Coaching, Certification, ...)
- Managing on-site teams of 16 people (developers, QA and SRE)
- Managing remote teams in Minsk, Belarus (developers, QA)
- Maintain online service scaling up to 100 million api calls per year
- Move services to AWS
- Technical mentorship to the teams
- Responsbile for technical support to our partners
- Migration to micro service architecture (Spring::Boot, Kafka, Prometheus, gRPC, REST)
Senior C++/.net Software Engineer - Scrum Master
- Develop and maintain new architecture of c++ and .net code
- Continuous {Integration, Delivery} repsonsible on TFS / Gitlab
Team Leader ; Software Craftman ; Senior Software Engineer - C++11 / 14
- Third Party Integration Team Leader
- Container deployment : Docker / Kubernetes / Swarm
- Ceph distributed storage
- C++11 / 14 development
Scrum Master - C++/.net Senior Software Engineer
- Technical Leader
- We are providing tools for IT monitoring, forecasting, reporting on various platforms: Microsoft Exchange, IBM Domino, BlackBerry, IBM Sametime, Microsoft Sharepoint.
- Certified Scrum master for
- Made transition from Team Foundation Server to Git
- Manage a 6 people team based on agile methods (SCRUM)
- Member of GSX Research & Development team
- Provide monitoring tool for Company IT department.
- In charge of R&D, technical decisions for product enhancements, technical architecture.
- Develop monitoring components on messaging tool such as Domino, Exchange, Sametime, Blackberry Enterprise server, Sharepoint
- Maintain code stream of all the 4 products of the company based on Team Foundation Server with nightly builds and automatic merge between the different branches.
- Design / Develop satellite softwares for internal usage based on Angular.js / Bootstrap technologies.
- Rally Software hacker (http://www.rallydev.com/)
C++/Corba Architect
- Part of the Research & Development team of Wall Street Systems in Sophia Antipolis.
- Development of C++ CORBA components such as financial instruments for Front Office business.
- I am currently learning financial industry such as Equities, Edge Funds, Front Office instruments...
- Setup & Development of the Apache ESB ActiveMQ. Usage of the C++ api to communicate with the ESB.
- Involved in the rewrite of the UI using the .NET WPF Api.
Software Architect
- I was involved in a project managing records in "Credit Bureaux" databases of Experian products.
- I architectured and developped base software components to make this development reusable for all the Experian projects via configuration file in XML.
- This developement was done using Ruby scripting language and databases were : Oracle, DB2 and MSSQL.
Software Engineer Contractor
- IT consultant working for different customers on Sophia Antipolis, Nice, France.
Embedded Software Engineer/Software Architect
- 11 months mission in Visteon Technologies in order to develop a 3D application on auto radio using
OpenGL ES
- Charge of all the development life cycle : specifications, design, development ;
- a C++ project taking as input a collada file and generating C data structures running on Windows ;
- a C++ Qnx project which use the datas generated
- The target embedded platform is an ARM9 CPU with a coral jade GPU (from Fujitsu)
-
In charge of another project at Visteon :
- Development of a video player on this target using the open source library ffmpeg.
- QNX
- ARM9, Jade Fujitsu
- C++, Multithread, FCollada
- OpenGL ES, GF
Embedded Software Engineer/Software Architect
- 6 months mission in a company specialized in transit transport development ;
- Development of a C++ application which enables the priority at crossroad for the bus, tramways ... ;
- All the development designed on Linux (IPC communication, multithreads, ...) ;
- To enable the priority, there was a module communicating on the serial port via a radio modem with the crossroad. The implemented protocol is called DIASER linked with a GPS receiver.
- Linux
- Shared memory, processes, threads, serial input/output
- ARM optimization
- GPS, Sirf2 chip
- DIASER protocol
- Trac, Subversion
Embedded Software Engineer
- Hardware architecture :
- 1 TMS470 hosting the main Operating system (a micro real time os) and the engine code (description below) ;
- 1 FPGA with 2D accelerations hosting widget library ;
- the 2 cpu's were connected through a SPI bus
- Development of a GUI auto radio system based on a XML description whose XML schema was defined by BMW ;
- Simple Process :
- XML description stored in a SQLite database from a C# tool ;
- SQLite database used to generate C datas meta model ( written in C# too) ;
- Design and development of a generic engine using datas generated before ;
C++/Tuxedo Software Engineer
- First consulting work in a huge company leader in the flights reservation called Amadeus ;
- worked in the rental car team ;
- Development of a scalable networking application written in C++ on HP-UX in order to replace the transactional server : Tuxedo ;
- database Oracle development ;
- technical leader for software production
- Linux, HP-UX
- C++, Python, Unit Testing
- BEA Tuxedo
Intern Software Engineer
- 7 months internship working on a network monitoring software ;
- Web supervision module development based on the HTTP SSL/TLS protocols :
- web pages reception,
- NTLM authentication, Basic, Digest,
- SOCKS(4/5), SSL and Http Proxies,
- Integration of a javascript interpreter : mozilla SpiderMonkey,
- All has been developped in .Net C++/Visual Basic. All the work was based upon the .Net C++/VBA interoperability.
- UML analyze (use cases, class diagram, sequence diagram).
- .Net platform, C++
- Web protocols
Intern Software Engineer
- 3 months internship ;
- Worked on an open source project called Efficient. An e-business project in association between the European Parliament and the Vietnamien Parliament.
- Module development :
- from an activity diagram with the differents actors, I had to research how I could have generated the whole code for one "articial" actor in a B2B transaction.
- Linux
- Java, Web Services, Axis
- XML, XSLT
Degrees
Graduate Engineering School specialized in Distributed Applications
- With honours
- Engineering metodologies : Project Management, Project Life Cycle
- Programming Paradigm :
- Erlang : Parallel Programming
- C++ : Meta Programming
- Constraint Programming
- Databases :
- Relation databases : Oracle, PostgreSQL
- Object Oriented databases : O2
- Middlewares : Corba, J2EE (Ejb, Servlets, Jsp)
Master's degree in Computer Science
- With honours
- Computational Complexity Theory
- Algorithmic Theory :
- data structures
- greedy algorithms
- dynamic programming
- linear programming (simplex algorithm), flow algorithm
BSc in Computer Science
- With honours
- Corba middleware
- Network programming on Unix
- 3D Programming
Two-year University degree in mathematics
- With honours
- Topology
- Probability
- Mathematical Algebra
- Mathematical analysis
References
OpenId Overview
- Article about OpenID specification ;
- Howto to put in place an OpenId complete server ;
- Tutorial on how to use API to use OpenId on our website
DBus Overview
- Article about freedesktop.org technology called DBus ;
- Overview of DBus GLib and python bindings ;
- Skeleton \& Stubs overview ;
- Protocol explanations
Drylm.org
- Founder
- System/Network Administrator : mail (postfix), subversion, apache
- Development group creation
Dreamcast Development Article
- Article about development on Dreamcast
- Cross Compiler setup
- Kallisti Os tips :
- how to play music,
- how to render fonts, bitmaps,
- how to manage controllers,
- how to debug.
D.C.S.I (not yet translated)
- Dreamcast Game Development,
- C++, Kallisti Os


Step 1 :- The first step is to build our Docker File. Use vim and create a Docker File with the following information.
From ubuntu
RUN apt-get update
RUN apt-get install –y apache2
RUN apt-get install –y apache2-utils
RUN apt-get clean
EXPOSE 80 CMD [“apache2ctl”, “-D”, “FOREGROUND”]
The following points need to be noted about the above statements.
We are first creating our image to be from the Ubuntu base image. Next, we are going to use the RUN command to update all the packages on the Ubuntu system.
Next, we use the RUN command to install apache2 on our image. Next, we use the RUN command to install the necessary utility apache2 packages on our image.
Next, we use the RUN command to clean any unnecessary files from the system. The EXPOSE command is used to expose port 80 of Apache in the container to the Docker host.
Finally, the CMD command is used to run apache2 in the background.
Step 2 :- Run the Docker build command to build the Docker file. It can be done using the following command.
sudo docker build –t=”mywebserver”
We are tagging our image as mywebserver. Once the image is built, you will get a successful message that the file has been built.
Step 3 :- Now that the web server file has been built, it’s now time to create a container from the image. We can do this with the Docker run command.
sudo docker run –d –p 80:80 mywebserver
The following points need to be noted about the above command :-
The port number exposed by the container is 80. Hence with the –p command, we are mapping the same port number to the 80 port number on our localhost.
The –d option is used to run the container in detached mode. This is so that the container can run in the background.
If you go to port 80 of the Docker host in your web browser, you will now see that Apache is up and running as shown in the image.


Master Gwinter:
I cannot teach you. Consider you chosen profession, and find the right Master for you.


Clean Coding
Source: Jonathan Fulton
A few years ago at VideoBlocks we had a major code quality problem: “spaghetti” logic in most files, tons of duplication, no tests and more. Writing new features and even minor bug fixes required a couple of Tums at best and entire bottles of Pepto-Bismol and Scotch far too often. Our WTFs per minute were sky-high.
Today, the overall quality of our codebases are significantly better thanks in large part to a deliberate effort to improve code quality. A couple ago when we identified the problem, we read Robert Martin’s Clean Code as a team and did our best to implement his recommendations and even introduced “clean code” as a core cultural tenant for the engineering team. I highly recommend doing both as you start scaling. Implementing “clean code” practices appropriately will double productivity in the long run (at a bare minimum) and significantly improve moral on the engineering team. Who wants to be in the room on the right given the choice?
Out of all the ideas we implemented from Clean Code and other sources, five provided at least 80% of the gains in productivity and team happiness.
- “If it isn’t tested, it’s broken”
Write lots of tests, especially unit tests, or you’ll regret it. - Choose meaningful names
Use short and precise names for variables, classes, and functions. - Classes and functions should be small and obey the Single Responsibility Principle (SRP)
Functions should be no more than 4 lines and classes no more than 100 lines. Yep, you read that correctly. They should also do one and only one thing. - Functions should have no side effects
Side effects (e.g., modifying an input argument) are evil. Make sure not to have them in your code. Specify this explicitly in the function contracts where possible (e.g., pass in native types or objects that have no setters)
Let’s walk through each one in detail so you can understand and start applying them in your day-to-day life on an engineering team.
1. “If it isn’t tested, it’s broken”
I started regularly repeating this sentence to our engineers as we encountered bugs that should’ve been caught by (nonexistent) tests. You too will prove the quote true again and again unless you build a culture of testing. Write a lot of tests, especially unit tests. Think very hard about integration tests and make sure you have a sufficient number in place to cover your core business functionality. Remember, if there’s not test coverage for a piece of code you’ll likely break it in the future without realizing it until your customers find the bug.
Repeat “if it isn’t tested, it’s broken” to your team over and over until the message sinks in. Practice what you preach, whether you’re a brand new software engineer straight out of school or a grizzled veteran.
2. Choose meaningful names
There are two hard problems in Computer Science: cache invalidation and naming things.
You may have heard this quote before and it couldn’t be more relevant to your day-to-day life on an engineering team. If you and your team aren’t good at naming things in your code, it will become an unmaintainable nightmare and you won’t get anything done. You’ll lose your best developers and your company will soon go out of business.
Seriously though, friends don’t let friends use bad variable names like data, foobar, or myNumber and they most certainly don’t let them name classes things like SomethingManager. Make sure your names are short and precise, but when in conflict favor precision. Strongly optimize around developer efficiency and make it easy to find files via “find by name” IDE shortcuts. Enforce good naming stringently with code reviews.
3. Classes and functions should be small and obey the Single Responsibility Principle (SRP)
Small and SRP go together like a chicken and an egg, a virtuous cycle of deliciousness. Let’s start with small.
What does “small” mean for functions? No more than 4 lines of code. Yep, you read that correctly, 4 lines. You’re probably closing the tab right now but you really shouldn’t. It seems somewhat arbitrary and small and you’ve probably never written code like that in your life. However, 4-line functions force you to think hard and pick a lot of really good names for sub-functions that make your code self-documenting. Additionally, they mean you can’t use nested IF statements that force you to do mental gymnastics to understand all the code paths.
Let’s walk through an example together. Node has an npm module called “build-url” which is used for doing exactly what it’s name suggests: it builds URLs. You can find the link to the source file we’re going to look at here. Below is the relevant code.
Notice that this function is 35 lines long. It’s not too hard to understand but it could be significantly easier to reason about if we apply our “small” principle to factor out helper functions. Here’s the updated and improved version.
You’ll notice that while we didn’t adhere strictly to the 4 lines per function rule, we did create several functions that are relatively “small”. Each one does exactly one task that’s easy to understand based on it’s name. You could even unit test each of these smaller functions independently if you wanted, as opposed to only being able to test the one large buildUrl function. You may also notice that this methodology produces slightly more code, 55 lines instead of 35. That’s perfectly acceptable because those 55 lines are a lot more maintainable and easier to read the the 35 lines.
How do you write code like this? I personally find it easiest to write the list of steps down that you need to accomplish the task you’re hoping to do. Each of these steps might be a good candidate for a sub/helper function. For instance, we could describe the buildUrl function as follows:
- Initialize our base url and options
- Add the path (if any)
- Add the query parameters (if any)
- Add the hash (if any)
Notice how each of these steps translates almost directly into a sub-function. Once you get in the habit, you’ll eventually write all of your code using this top-down approach where you create a list of steps, stub the functions, and continue recursively like this into each of the sub-functions creating a list of steps, stubbing, and so on.
Moving on to our related concept, the Single Responsibility Principle. What does this mean? Quoting directly from Wikipedia:
The Single Responsibility Principle (SRP) is a computer programming principle that states that every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class. All its services should be narrowly aligned with that responsibility.
Robert Martin in Clean Code provides a parallel definition:
The SRP states that a class or module should one, and only one, reason to change.
Let’s say we’re building a system that needs to a certain type of report and display it. A naive approach might be to build a single module/class that stores the report data as well as the logic for displaying the report. However, that violates SRP because there are two high level reasons to modify the class. First, if the report fields change, we’ll need to update it. Second, if the report visualization requirements change, we’ll need to update the class. Therefore instead of a single class to store both the data and the logic for rendering the data, we should split those concepts and areas of ownership into two different classes, say ReportData and ReportDataRenderer or something similar.
4.  Check out the example below. Can you spot the side effect?
The function as named is designed to look up a user by email/password combination, a standard operation for any web application. However, it also has a hidden side effect that you do not know about as the function consumer without reading the implementation code: it logs the user in, which creates a login token, adds it to the database, and sends a cookie back to our user with the value so they’re subsequently “logged in”.
There are many things wrong with this.
First, the function contract/interface is not easily understood without reading the implementation code. Even if the login side-effect is documented, though, it’s still not ideal. Engineers tend to use intellisense in modern IDEs so won’t think they need to read the documentation based on the simple function name. They’ll tend to use the function solely to fetch the user object, failing to realize that they’re adding a cookie to the request which can lead to all sorts of fun hard-to-find bugs.
Second, testing the function is fairly challenging given all the dependencies. Verifying that you can look a user up by email/password requires mocking out an HTTP response as well as handling the writes to the login token table.
Third, the tight coupling between user lookup and login inevitably won’t satisfy all use cases in the future, where you’ll likely need to look up a user or login a user independently. In other words, it’s not “future proof”.
In summary, make sure to remember and apply these four “clean code” principles to dramatically improve your team’s productivity:
- “If it isn’t tested, it’s broken”
- Choose meaningful names
- Classes and functions should be small and obey the Single Responsibility Principle (SRP)
- Functions should have no side effects


Unsettled API - An API allowing raw sockets to be used with proactor More...
Classes | |
| struct | pn_raw_buffer_t |
| A descriptor used to represent a single raw buffer in memory. More... | |
Typedefs | |
| typedef struct pn_raw_connection_t | pn_raw_connection_t |
| A raw network connection used with the proactor. | |
Functions | |
| PNP_EXTERN pn_raw_connection_t * | pn_raw_connection (void) |
| Create a new raw connection for use with the Proactor. More... | |
| PNP_EXTERN const struct pn_netaddr_t * | pn_raw_connection_local_addr (pn_raw_connection_t *connection) |
| Get the local address of a raw connection. More... | |
| PNP_EXTERN const struct pn_netaddr_t * | pn_raw_connection_remote_addr (pn_raw_connection_t *connection) |
| Get the local address of a raw connection. More... | |
| PNP_EXTERN void | pn_raw_connection_close (pn_raw_connection_t *connection) |
| Close a raw connection. More... | |
| PNP_EXTERN void | pn_raw_connection_read_close (pn_raw_connection_t *connection) |
| Shutdown a raw connection for reading. More... | |
| PNP_EXTERN void | pn_raw_connection_write_close (pn_raw_connection_t *connection) |
| Shutdown a raw connection for writing. More... | |
| PNP_EXTERN size_t | pn_raw_connection_read_buffers_capacity (pn_raw_connection_t *connection) |
| Query the raw connection for how many more read buffers it can be given. | |
| PNP_EXTERN size_t | pn_raw_connection_write_buffers_capacity (pn_raw_connection_t *connection) |
| Query the raw connection for how many more write buffers it can be given. | |
| PNP_EXTERN size_t | pn_raw_connection_give_read_buffers (pn_raw_connection_t *connection, pn_raw_buffer_t const *buffers, size_t num) |
| Give the raw connection buffers to use for reading from the underlying socket. More... | |
| PNP_EXTERN size_t | pn_raw_connection_take_read_buffers (pn_raw_connection_t *connection, pn_raw_buffer_t *buffers, size_t num) |
| Fetch buffers with bytes read from the raw socket. More... | |
| PNP_EXTERN size_t | pn_raw_connection_write_buffers (pn_raw_connection_t *connection, pn_raw_buffer_t const *buffers, size_t num) |
| Give the raw connection buffers to write to the underlying socket. More... | |
| PNP_EXTERN size_t | pn_raw_connection_take_written_buffers (pn_raw_connection_t *connection, pn_raw_buffer_t *buffers, size_t num) |
| Return a buffer chain with buffers that have all been written to the raw socket. More... | |
| PNP_EXTERN bool | pn_raw_connection_is_read_closed (pn_raw_connection_t *connection) |
Is connection closed for read? More... | |
| PNP_EXTERN bool | pn_raw_connection_is_write_closed (pn_raw_connection_t *connection) |
Is connection closed for write? More... | |
| PNP_EXTERN void | pn_raw_connection_wake (pn_raw_connection_t *connection) |
Return a PN_RAW_CONNECTION_WAKE event for connection as soon as possible. More... | |
| PNP_EXTERN pn_condition_t * | pn_raw_connection_condition (pn_raw_connection_t *connection) |
| Get additional information about a raw connection error. More... | |
| PNP_EXTERN void * | pn_raw_connection_get_context (pn_raw_connection_t *connection) |
| Get the application context associated with this raw connection. More... | |
| PNP_EXTERN void | pn_raw_connection_set_context (pn_raw_connection_t *connection, void *context) |
| Set a new application context for a raw connection. More... | |
| PNP_EXTERN pn_record_t * | pn_raw_connection_attachments (pn_raw_connection_t *connection) |
| Get the attachments that are associated with a raw connection. | |
| PNP_EXTERN pn_raw_connection_t * | pn_event_raw_connection (pn_event_t *event) |
| Return the raw connection associated with an event. More... | |
Unsettled API - An API allowing raw sockets to be used with proactor
| struct pn_raw_buffer_t |
A descriptor used to represent a single raw buffer in memory.
| Class Members | ||
|---|---|---|
| uintptr_t | context | Used to associate arbitrary application data with this raw buffer. |
| char * | bytes | Pointer to the start of the raw buffer, if this is null then no buffer is represented. |
| uint32_t | capacity | Count of available bytes starting at bytes. |
| uint32_t | size | Number of bytes read or to be written starting at offset. |
| uint32_t | offset | First byte in the buffer to be read or written. |
| PNP_EXTERN pn_raw_connection_t* pn_raw_connection | ( | void | ) |
Create a new raw connection for use with the Proactor.
See pn_proactor_raw_connect and pn_listener_raw_accept.
| PNP_EXTERN const struct pn_netaddr_t* pn_raw_connection_local_addr | ( | pn_raw_connection_t * | connection | ) |
Get the local address of a raw connection.
Return NULL
if not available. Pointer is invalid after the transport closes (PN_RAW_CONNECTION_DISCONNECTED event is handled)
| PNP_EXTERN const struct pn_netaddr_t* pn_raw_connection_remote_addr | ( | pn_raw_connection_t * | connection | ) |
Get the local address of a raw connection.
Return NULL
if not available. Pointer is invalid after the transport closes (PN_RAW_CONNECTION_DISCONNECTED event is handled)
| PNP_EXTERN void pn_raw_connection_close | ( | pn_raw_connection_t * | connection | ) |
Close a raw connection.
This will flush any buffers to be written; close the underlying socket and release all buffers held by the raw connection.
It will cause PN_RAW_CONNECTION_READ and PN_RAW_CONNECTION_WRITTEN to be emitted so the application can clean up buffers given to the raw connection. After that a PN_RAW_CONNECTION_DISCONNECTED event will be emitted to allow the application to clean up any other state held by the raw connection.
| PNP_EXTERN void pn_raw_connection_read_close | ( | pn_raw_connection_t * | connection | ) |
Shutdown a raw connection for reading.
This will close the underlying socket for reading and release all empty read buffers held by the raw connection.
It will cause PN_RAW_CONNECTION_READ to be emitted so the application can clean up buffers given to the raw connection. Note that these buffers may still also contain data read from the socket but not yet consumed by the application.
If pn_raw_connection_write_close() has already been called then PN_RAW_CONNECTION_DISCONNECTED will then also be emitted.
In order to fully close a raw connection the application will need to either call pn_raw_connection_close() or pn_raw_connection_write_close() after it calls pn_raw_connection_read_close().
| PNP_EXTERN void pn_raw_connection_write_close | ( | pn_raw_connection_t * | connection | ) |
Shutdown a raw connection for writing.
This will flush any buffers to be written to the socket; close the underlying socket for writing and release all write buffers held by the raw connection.
It will cause PN_RAW_CONNECTION_WRITTEN to be emitted so the application can clean up write buffers given to the raw connection.
If pn_raw_connection_read_close() has already been called then PN_RAW_CONNECTION_DISCONNECTED will then also be emitted.
In order to fully close a raw connection the application will need to either call pn_raw_connection_close() or pn_raw_connection_read_close() after it calls pn_raw_connection_write_close().
| PNP_EXTERN size_t pn_raw_connection_give_read_buffers | ( | pn_raw_connection_t * | connection, |
| pn_raw_buffer_t const * | buffers, | ||
| size_t | num | ||
| ) |
Give the raw connection buffers to use for reading from the underlying socket.
If the raw socket has no read buffers then the application will never receive a PN_RAW_CONNECTION_READ event.
A PN_RAW_CONNECTION_NEED_READ_BUFFERS event will be generated immediately after the PN_RAW_CONNECTION_CONNECTED event if there are no read buffers. It will also be generated whenever the raw connection runs out of read buffers. In both these cases the event will not be generated again until pn_raw_connection_give_read_buffers is called.
| PNP_EXTERN size_t pn_raw_connection_take_read_buffers | ( | pn_raw_connection_t * | connection, |
| pn_raw_buffer_t * | buffers, | ||
| size_t | num | ||
| ) |
Fetch buffers with bytes read from the raw socket.
The buffers will be placed in the buffers array in the order in which they were read. So the first buffer in the array will contain the first bytes read; the second buffer the next bytes etc.
| [out] | buffers | pointer to an array of pn_raw_buffer_t structures which will be filled in with the read buffer information |
| [in] | num | the number of buffers allocated in the passed in array of buffers |
| PNP_EXTERN size_t pn_raw_connection_write_buffers | ( | pn_raw_connection_t * | connection, |
| pn_raw_buffer_t const * | buffers, | ||
| size_t | num | ||
| ) |
Give the raw connection buffers to write to the underlying socket.
The buffers will be written to the connection in the order that they are passed in. That is the first buffer in the array of buffers passed will be the first buffer written to the connection; the second buffer passed in will be the second written etc.
A PN_RAW_CONNECTION_WRITTEN event will be generated once the buffers have been written to the socket until this point the buffers must not be accessed at all (written or even read).
A PN_RAW_CONNECTION_NEED_WRITE_BUFFERS event will be generated immediately after the PN_RAW_CONNECTION_CONNECTED event if there are no write buffers. It will also be generated whenever the raw connection finishes writing all the write buffers. In both these cases the event will not be generated again until pn_raw_connection_write_buffers is called.
| PNP_EXTERN size_t pn_raw_connection_take_written_buffers | ( | pn_raw_connection_t * | connection, |
| pn_raw_buffer_t * | buffers, | ||
| size_t | num | ||
| ) |
Return a buffer chain with buffers that have all been written to the raw socket.
| [out] | buffers | pointer to an array of pn_raw_buffer_t structures which will be filled in with the written buffer information |
| [in] | num | the number of buffers allocated in the passed in array of buffers |
| PNP_EXTERN bool pn_raw_connection_is_read_closed | ( | pn_raw_connection_t * | connection | ) |
Is connection
closed for read?
| PNP_EXTERN bool pn_raw_connection_is_write_closed | ( | pn_raw_connection_t * | connection | ) |
Is connection
closed for write?
| PNP_EXTERN void pn_raw_connection_wake | ( | pn_raw_connection_t * | connection | ) |
Return a PN_RAW_CONNECTION_WAKE event for connection
as soon as possible.
At least one wake event will be returned, serialized with other Proactor events for the same raw connection. Wakes can be "coalesced" - if several pn_raw_connection_wake() calls happen close together, there may be only one PN_RAW_CONNECTION_WAKE event that occurs after all of them.
| PNP_EXTERN pn_condition_t* pn_raw_connection_condition | ( | pn_raw_connection_t * | connection | ) |
Get additional information about a raw connection error.
There is a raw connection error if the PN_RAW_CONNECTION_DISCONNECTED event is received and the pn_condition_t associated is non null (
The value returned is only valid until the end of handler for the PN_RAW_CONNECTION_DISCONNECTED event.
| PNP_EXTERN void* pn_raw_connection_get_context | ( | pn_raw_connection_t * | connection | ) |
Get the application context associated with this raw connection.
The application context for a raw connection may be set using pn_raw_connection_set_context.
| [in] | connection | the raw connection whose context is to be returned. |
| PNP_EXTERN void pn_raw_connection_set_context | ( | pn_raw_connection_t * | connection, |
| void * | context | ||
| ) |
Set a new application context for a raw connection.
The application context for a raw connection may be retrieved using pn_raw_connection_get_context.
| [in] | connection | the raw connection object |
| [in] | context | the application context |
| PNP_EXTERN pn_raw_connection_t* pn_event_raw_connection | ( | pn_event_t * | event | ) |
Return the raw connection associated with an event.


Here you can find friends or stalk strangers
The Dog Social network dose not take any responsibility for the informtion found


Cloud Vision V1 API - Class Google::Protobuf::FieldMask (v0.6.4)
Reference documentation and code samples for the Cloud Vision V1 API class Google::Protobuf::FieldMask.
FieldMask
represents a set of symbolic field paths, for example:
paths: "f.a"
paths: "f.b.d"
Here f
represents a field in some root message, a
and b
fields in the message found in f
, and d
a field found in the
message in f.b
.
Field masks are used to specify a subset of fields that should be returned by a get operation or modified by an update operation. Field masks also have a custom JSON encoding (see below).
Field Masks in Projections
When used in the context of a projection, a response message or sub-message is filtered by the API to only contain those fields as specified in the mask. For example, if the mask in the previous example is applied to a response message as follows:
f {
a : 22
b {
d : 1
x : 2
}
y : 13
}
z: 8
The result will not contain specific values for fields x,y and z (their value will be set to the default, and omitted in proto text output):
f {
a : 22
b {
d : 1
}
}
A repeated field is not allowed except at the last position of a paths string.
If a FieldMask object is not present in a get operation, the operation applies to all fields (as if a FieldMask of all fields had been specified).
Note that a field mask does not necessarily apply to the top-level response message. In case of a REST get operation, the field mask applies directly to the response, but in case of a REST list operation, the mask instead applies to each individual message in the returned resource list. In case of a REST custom method, other definitions may be used. Where the mask applies will be clearly documented together with its declaration in the API. In any case, the effect on the returned resource/resources is required behavior for APIs.
Field Masks in Update Operations
A field mask in update operations specifies which fields of the targeted resource are going to be updated. The API is required to only change the values of the fields as specified in the mask and leave the others untouched. If a resource is passed in to describe the updated values, the API ignores the values of all fields not covered by the mask.
If a repeated field is specified for an update operation, new values will
be appended to the existing repeated field in the target resource. Note that
a repeated field is only allowed in the last position of a paths
string.
If a sub-message is specified in the last position of the field mask for an update operation, then new value will be merged into the existing sub-message in the target resource.
For example, given the target message:
f {
b {
d: 1
x: 2
}
c: [1]
}
And an update message:
f {
b {
d: 10
}
c: [2]
}
then if the field mask is:
paths: ["f.b", "f.c"]
then the result will be:
f {
b {
d: 10
x: 2
}
c: [1, 2]
}
An implementation may provide options to override this default behavior for repeated and message fields.
In order to reset a field's value to the default, the field must be in the mask and set to the default value in the provided resource. Hence, in order to reset all fields of a resource, provide a default instance of the resource and set all fields in the mask, or do not provide a mask as described below.
If a field mask is not present on update, the operation applies to all fields (as if a field mask of all fields has been specified). Note that in the presence of schema evolution, this may mean that fields the client does not know and has therefore not filled into the request will be reset to their default. If this is unwanted behavior, a specific service may require a client to always specify a field mask, producing an error if not.
As with get operations, the location of the resource which describes the updated values in the request message depends on the operation kind. In any case, the effect of the field mask is required to be honored by the API.
Considerations for HTTP REST
The HTTP kind of an update operation which uses a field mask must be set to PATCH instead of PUT in order to satisfy HTTP semantics (PUT must only be used for full updates).
JSON Encoding of Field Masks
In JSON, a field mask is encoded as a single string where paths are separated by a comma. Fields name in each path are converted to/from lower-camel naming conventions.
As an example, consider the following message declarations:
message Profile {
User user = 1;
Photo photo = 2;
}
message User {
string display_name = 1;
string address = 2;
}
In proto a field mask for Profile
may look as such:
mask {
paths: "user.display_name"
paths: "photo"
}
In JSON, the same mask is represented as below:
{
mask: "user.displayName,photo"
}
Field Masks and Oneof Fields
Field masks treat fields in oneofs just as regular fields. Consider the following message:
message SampleMessage {
oneof test_oneof {
string name = 4;
SubMessage sub_message = 9;
}
}
The field mask can be:
mask {
paths: "name"
}
Or:
mask {
paths: "sub_message"
}
Note that oneof type names ("test_oneof" in this case) cannot be used in paths.
Field Mask Verification
The implementation of any API method which has a FieldMask type field in the
request should verify the included field paths, and return an
INVALID_ARGUMENT
error if any path is unmappable.
Inherits
- Object
Extended By
- Google::Protobuf::MessageExts::ClassMethods
Includes
- Google::Protobuf::MessageExts
Methods
#paths
def paths() -> ::Array<::String>
- (::Array<::String>) — The set of field mask paths.
#paths=
def paths=(value) -> ::Array<::String>
- value (::Array<::String>) — The set of field mask paths.
- (::Array<::String>) — The set of field mask paths.


How awesome is it that you can have Hyperledger Burrow's Ethereum VM smart contract engine running as chaincode inside Hyperledger Fabric? Let us know!


asdasdasdasd sadsadsadsa
asdsadsadsa dsad sad sada sd
dasd dsd sadasd
sadsdasdsadasdsadsadd
adssadasdasdsadasdsad sa dsadsa da dsa
Yukon, still commonly referred to as "The Yukon Territory", is the westernmost of Canada's three northern territories. The Yukon's major appeal is its nearly pristine nature. Tourism relies heavily on this and there are many organised outfitters and guides available to hunters and anglers and nature lovers of all sorts.


{% extends "wagtailadmin/base.html" %} {% load wagtailadmin_tags i18n staticfiles sendinblue %} {% block extra_css %} {{ block.super }} {% endblock %} {% block titletag %}SendInBlue{% endblock %} {% block content %} {% get_current_language as LANGUAGE_CODE %} {% include 'wagtailadmin/shared/header.html' with title='SendInBlue' icon='fa-envelope' %} {% trans 'Welcome' %} {% trans 'You have not yet configured your SendInBlue account' %} {% blocktrans with atag=sendinblue_link|safe %}If you haven't done so yet, you must create an account on {{ atag }}.{% endblocktrans %} {% trans 'Go to the SendInBlue settings' %} {% trans 'Create a SendInBlue account' %} {% endblock %}
{% trans 'You have not yet configured your SendInBlue account' %}
{% blocktrans with atag=sendinblue_link|safe %}If you haven't done so yet, you must create an account on {{ atag }}.{% endblocktrans %}


This is a short experience report on Modafinil taken from the prospective of someone who suffers with chronic anxiety.
I started suffering with tiredness and lethargy and was looking for something to aid mental focus. I knew Modafinil was a stimulant type drug but I wasn't quite prepared for just how stimulating.
I took 100mg in the morning after a light breakfast. The only other substance I took was caffeine from tea (very strong tea I might add).
within about 30-40 minutes I felt the effects of it which built up gradually and lasted over 10 hours. I felt very agitated and jittery, just as though I had drunk too much caffeine (I can normally only tolerate one cup of tea). I was very on edge all morning, the slightest noise would make me jump.
I was able to do work and found I could focus better, but the physical effects and anxiety was quite unpleasant for me. By physical effects, I mean body tension and extra stress. I felt a tightness in my chest, pains in my neck and shoulders. It was almost like border-line anxiety attack. My mood was also negatively affected. I felt slightly bad tempered and easily angered by things.
In short, although the drug did help my concentration and productivity, I wouldn't recommend it all for anyone suffers with anxiety or stress. It's just not worth it and may make the symptoms worse.
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.


Generates Rd files from R source code with comments. The main features of the default syntax are that (1) docs are defined in comments near the relevant code, (2) function argument names are not repeated in comments, and (3) examples are defined in R code, not comments. It is also easy to define a new syntax.
| Version: | 2013.9.3 |
| Depends: | methods, utils, R (≥ 2.9) |
| Published: | 2013-09-03 |
| Author: | Toby Dylan Hocking [aut, cre], Keith Ponting [aut], Thomas Wutzler [aut], Philippe Grosjean [aut], Markus Müller [aut], R Core Team [ctb, cph] |
| Maintainer: | Toby Dylan Hocking <toby at sg.cs.titech.ac.jp> |
| License: | GPL-2 | GPL-3 |
| URL: | http://inlinedocs.r-forge.r-project.org |
| NeedsCompilation: | no |
| Citation: | inlinedocs citation info |
| Materials: | NEWS |
| CRAN checks: | inlinedocs results |
| Reference manual: | inlinedocs.pdf |
| Package source: | inlinedocs_2013.9.3.tar.gz |
| Windows binaries: | r-devel: inlinedocs_2013.9.3.zip, r-release: inlinedocs_2013.9.3.zip, r-oldrel: inlinedocs_2013.9.3.zip |
| OS X binaries: | r-release: inlinedocs_2013.9.3.tgz, r-oldrel: inlinedocs_2013.9.3.tgz |
| Old sources: | inlinedocs archive |
| Reverse suggests: | directlabels |
Please use the canonical form https://CRAN.R-project.org/package=inlinedocs to link to this page.


We appreciate your support in helping to protect endangered species. Please complete the form below to support one of our wonderful aminals.
,


Certain circumstances and owing to the claims of duty or the obligation.
Certain circumstances and owing to the claims of duty or the obligation.
Certain circumstances and owing to the claims of duty or the obligation.
Certain circumstances and owing to the claims of duty or the obligation.
Certain circumstances and owing to the claims of duty or the obligation.
Certain circumstances and owing to the claims of duty or the obligation.
At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi.


To contact me please:
Call or Text:<PHONE_NUMBER>9
Email<EMAIL_ADDRESS>Or please complete the enquiry form below and I will be in contact as soon as possible.


Pymatgen-db is a database add-on for the Python Materials Genomics (pymatgen) materials analysis library. It enables the creation of Materials Project-style MongoDB databases for management of materials data. A query engine is also provided to enable the easy translation of MongoDB docs to useful pymatgen objects for analysis purposes.
Pymatgen-db also provides a clean and intuitive web ui (the Materials Genomics UI) for exploring Mongo collections. While the design originates for the purpose of exploring collections generated using pymatgen-db, it can be used to explore any Mongo database and collection.
There are also validation tools that can quickly and flexibly check a variety of constraints on Mongo collections.
The version at the Python Package Index (PyPI) is always the latest stable release that will be hopefully, be relatively bug-free. The easiest way to install pymatgen on any system is to use easy_install or pip, as follows:
easy_install pymatgen-db
or:
pip install pymatgen-db
The bleeding edge developmental version is at the pymatgen-db’s Github repo. The developmental version is likely to be more buggy, but may contain new features. The Github version include test files as well for complete unit testing. After cloning the source, you can type:
python setup.py install
or to install the package in developmental mode:
python setup.py develop
All required python dependencies should be automatically taken care of if you install pymatgen-db using easy_install or pip. Otherwise, these packages should be available on PyPI.
A powerful command-line script (mgdb) provides most of the access to many of the features in pymatgen-db, including db initialization, insertion of data, running the materials genomics ui, etc. To see all options available, type:
mgdb --help
The first step is to install and setup MongoDB on a server of your choice. The MongoDB manual is an excellent place to start. For the purposes of testing out the tools here, you may simply download the binary distributions corresponding to your OS from the MongoDB website, and then running the following commands:
# For Mac and Linux OS.
mkdir test_db && mongod --dbpath test_db
This will create a test database and start the Mongo daemon. Once you are done with testing, you can simply press Ctrl-C to stop the server and delete the “test_db” folder.
Note
Running a Mongo server this way is insecure as Mongo does not enable authentication by default. Please refer to the MongoDB manual when setting up your production database.
After your server is up, you should create a database config file by running the following command:
mgdb init -c db.json
This will prompt you for a few parameters to create a database config file, which will make it much easier to use mgdb in future. Note that the config file name can be anything of your choice, but using “db.json” will allow you to use mgdb without explicitly specifying the filename in future. If you are just testing using the test database, simply hit Enter to accept the defaults for all settings.
For more advanced use of the “db.json” config file (e.g., specifying aliases, defaults, etc., please refer to the following sample.
To insert an entire directory of runs (where the topmost directory is “dir_name”) into the database, use the following command:
# Note that "-c db.json" may be omitted if the config filename is the
# current directory under the default filename of db.json.
mgdb insert -c db.json dir_name
A sample run has been provided for download for testing purposes. Unzip the file and run the above command in the directory.
A simple web interface has been provided to assist in the querying and viewing of results. This web interface can be started by running:
mgdb runserver -c db.json
This will run the web server at http://<IP_ADDRESS>:8000. Go to this address in your browser and you should see something like the figure below. Most queries can be performed using the web ui. Two options for presenting results are provided - a table format which is easier for comparing data, and a tree format which makes it much easier to explore highly nested trees of data.
The Materials Genomics UI also implements a RESTful interface to the database. Two main methods are implemented now. A simple GET request that provides the ability to delve into a document. For example:
http://<IP_ADDRESS>:8000/rest/14/output
returns the “output” key of task_id 14 as a JSON.
A more advanced POST request provides the ability to make advanced queries. This is the basis upon which the Materials Genomics UI is built. For example, posting:
{criteria: "criteria as json string",
properties: "list of properties as json string"}
to:
http://<IP_ADDRESS>:8000/rest/query
would return the query as a JSON response.
Sometimes, more fine-grained querying is needed (e.g., for subsequent postprocessing and analysis).
The mgdb script allows you to make simple queries from the command line:
# Query for the task id and energy per atom of all calculations with
# formula Li2O. Note that the criteria has to be specified in the form of
# a json string. Note that "-c db.json" may be omitted if the config
# filename is the current directory under the default filename of db.json.
mgdb query -c db.json --crit '{"pretty_formula": "Li2O"}' --props task_id energy_per_atom
The format of the configuration file db.json is given on this page.
For more advanced queries, you can use the matgendb.query_engine.QueryEngine class for which a default alias is provided at the root package. Some examples are as follows:
>>> from matgendb import QueryEngine
>>> qe = QueryEngine()
#Print the task id and formula of all entries in the database.
>>> for r in qe.query(properties=["pretty_formula", "task_id"]):
... print "{task_id} - {pretty_formula}".format(**r)
...
12 - Li2O
# Get a pymatgen Structure from the task_id.
>>> structure = qe.get_structure_from_id(12)
# Get pymatgen ComputedEntries using a criteria.
>>> entries = qe.get_entries({})
The language follows very closely to pymongo/MongoDB syntax, except that QueryEngine provides useful aliases for commonly used fields as well as translation to commonly used pymatgen objects like Structure and ComputedEntries.
Currently, pymatgen-db is written with standard VASP runs in mind. However, it is perfectly extensible to any kind of data, e.g., other kinds of VASP runs (bandstructure, NEB, etc.) or just any form of data in general. Developers looking to adapt pymatgen-db for other purposes should look at the matgendb.creator.VaspToDbTaskDrone class as an example and write similar drones for their needs. The matgendb.query_engine.QueryEngine can generally be applied to any Mongo collection, with suitable specification of aliases if desired.
The API docs are generated using Sphinx auto-doc and outlines the purpose of all modules and classes, and the expected argument and returned objects for most methods. They are available at the link below.
If you use pymatgen and pymatgen-db in your research, please consider citing the following work:
Shyue Ping Ong, William Davidson Richards, Anubhav Jain, Geoffroy Hautier, Michael Kocher, Shreyas Cholia, Dan Gunter, Vincent Chevrier, Kristin A. Persson, Gerbrand Ceder. Python Materials Genomics (pymatgen) : A Robust, Open-Source Python Library for Materials Analysis. Computational Materials Science, 2013, 68, 314-319. doi:10.1016/j.commatsci.2012.10.028
Pymatgen-db is released under the MIT License. The terms of the license are as follows:
The MIT License (MIT)
Copyright (c) 2011-2012 MIT & LBNL
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software")
, to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.


Objects and arrays - code challenge
Create new list-ul inside the div 'result', which contains all cars (li) from person with name entered in search box. Persons are given in app.js in myObjects
Person name:
Create/Update new HTML


Policies.CD_UCB module¶
The CD-UCB generic policy policies for non-stationary bandits.
Reference: [[“A Change-Detection based Framework for Piecewise-stationary Multi-Armed Bandit Problem”. F. Liu, J. Lee and N. Shroff. arXiv preprint arXiv:1711.03539, 2017]](https://arxiv.org/pdf/1711.03539)
It runs on top of a simple policy, e.g.,
UCB
, andUCBLCB_IndexPolicy
is a wrapper:>>> policy = UCBLCB_IndexPolicy(nbArms, UCB) >>> # use policy as usual, with policy.startGame(), r = policy.choice(), policy.getReward(arm, r)
It uses an additional \(\mathcal{O}(\tau_\max)\) memory for a game of maximum stationary length \(\tau_\max\).
Warning
It can only work on basic index policy based on empirical averages (and an exploration bias), like UCB
, and cannot work on any Bayesian policy (for which we would have to remember all previous observations in order to reset the history with a small history)!
-
Policies.CD_UCB.
VERBOSE
= False¶ Whether to be verbose when doing the change detection algorithm.
-
Policies.CD_UCB.
PROBA_RANDOM_EXPLORATION
= 0.1¶ Default probability of random exploration \(\alpha\).
-
Policies.CD_UCB.
PER_ARM_RESTART
= True¶ Should we reset one arm empirical average or all? Default is
True
, it’s usually more efficient!
-
Policies.CD_UCB.
FULL_RESTART_WHEN_REFRESH
= False¶ Should we fully restart the algorithm or simply reset one arm empirical average? Default is
False
, it’s usually more efficient!
-
Policies.CD_UCB.
EPSILON
= 0.05¶ Precision of the test. For CUSUM/PHT, \(\varepsilon\) is the drift correction threshold (see algorithm).
-
Policies.CD_UCB.
LAMBDA
= 1¶ Default value of \(\lambda\).
-
Policies.CD_UCB.
MIN_NUMBER_OF_OBSERVATION_BETWEEN_CHANGE_POINT
= 50¶ Hypothesis on the speed of changes: between two change points, there is at least \(M * K\) time steps, where K is the number of arms, and M is this constant.
-
Policies.CD_UCB.
LAZY_DETECT_CHANGE_ONLY_X_STEPS
= 10¶ XXX Be lazy and try to detect changes only X steps, where X is small like 10 for instance. It is a simple but efficient way to speed up CD tests, see https://github.com/SMPyBandits/SMPyBandits/issues/173 Default value is 0, to not use this feature, and 10 should speed up the test by x10.
-
class
Policies.CD_UCB.
CD_IndexPolicy
(nbArms, full_restart_when_refresh=False, per_arm_restart=True, epsilon=0.05, proba_random_exploration=None, lazy_detect_change_only_x_steps=10, *args, **kwargs)[source]¶ Bases:
Policies.BaseWrapperPolicy.BaseWrapperPolicy
The CD-UCB generic policy for non-stationary bandits, from [[“A Change-Detection based Framework for Piecewise-stationary Multi-Armed Bandit Problem”. F. Liu, J. Lee and N. Shroff. arXiv preprint arXiv:1711.03539, 2017]](https://arxiv.org/pdf/1711.03539).
-
__init__
(nbArms, full_restart_when_refresh=False, per_arm_restart=True, epsilon=0.05, proba_random_exploration=None, lazy_detect_change_only_x_steps=10, *args, **kwargs)[source]¶ New policy.
-
epsilon
= None¶ Parameter \(\varepsilon\) for the test.
-
lazy_detect_change_only_x_steps
= None¶ Be lazy and try to detect changes only X steps, where X is small like 10 for instance.
-
proba_random_exploration
= None¶ What they call \(\alpha\) in their paper: the probability of uniform exploration at each time.
-
all_rewards
= None¶ Keep in memory all the rewards obtained since the last restart on that arm.
-
last_pulls
= None¶ Keep in memory the number times since last restart. Start with -1 (never seen)
-
last_restart_times
= None¶ Keep in memory the times of last restarts (for each arm).
-
number_of_restart
= None¶ Keep in memory the number of restarts.
-
choice
()[source]¶ With a probability \(\alpha\), play uniformly at random, otherwise, pass the call to
choice()
of the underlying policy.
-
choiceWithRank
(rank=1)[source]¶ With a probability \(\alpha\), play uniformly at random, otherwise, pass the call to
choiceWithRank()
of the underlying policy.
-
getReward
(arm, reward)[source]¶ Give a reward: increase t, pulls, and update cumulated sum of rewards and update small history (sliding window) for that arm (normalized in [0, 1]).
Reset the whole empirical average if the change detection algorithm says so, with method
detect_change()
, for this arm at this current time step.
Warning
This is computationally costly, so an easy way to speed up this step is to use
lazy_detect_change_only_x_steps
\(= \mathrm{Step_t}\) for a small value (e.g., 10), so not test for all \(t\in\mathbb{N}^*\) but only \(s\in\mathbb{N}^*, s % \mathrm{Step_t} = 0\) (e.g., one out of every 10 steps).Warning
If the \(detect_change\) method also returns an estimate of the position of the change-point, \(\hat{tau}\), then it is used to reset the memory of the changing arm and keep the observations from \(\hat{tau}+1\).
-
detect_change
(arm, verbose=False)[source]¶ Try to detect a change in the current arm.
Warning
This is not implemented for the generic CD algorithm, it has to be implement by a child of the class
CD_IndexPolicy
.
-
__module__
= 'Policies.CD_UCB'¶
-
-
class
Policies.CD_UCB.
SlidingWindowRestart_IndexPolicy
(nbArms, full_restart_when_refresh=False, per_arm_restart=True, epsilon=0.05, proba_random_exploration=None, lazy_detect_change_only_x_steps=10, *args, **kwargs)[source]¶ Bases:
Policies.CD_UCB.CD_IndexPolicy
A more generic implementation is the
Policies.SlidingWindowRestart
class.Warning
I have no idea if what I wrote is correct or not!
-
detect_change
(arm, verbose=False)[source]¶ Try to detect a change in the current arm.
Warning
This one is simply using a sliding-window of fixed size = 100. A more generic implementation is the
Policies.SlidingWindowRestart
class.
-
__module__
= 'Policies.CD_UCB'¶
-
-
Policies.CD_UCB.
LAZY_TRY_VALUE_S_ONLY_X_STEPS
= 10¶ XXX Be lazy and try to detect changes for \(s\) taking steps of size
steps_s
. Default is to havesteps_s=1
, but only usingsteps_s=2
should already speed up by 2. It is a simple but efficient way to speed up GLR tests, see https://github.com/SMPyBandits/SMPyBandits/issues/173 Default value is 1, to not use this feature, and 10 should speed up the test by x10.
-
Policies.CD_UCB.
USE_LOCALIZATION
= True¶ Default value of
use_localization
for policies. All the experiments I tried showed that the localization always helps improving learning, so the default value is set to True.
-
class
Policies.CD_UCB.
UCBLCB_IndexPolicy
(nbArms, delta=None, delta0=1.0, lazy_try_value_s_only_x_steps=10, use_localization=True, *args, **kwargs)[source]¶ Bases:
Policies.CD_UCB.CD_IndexPolicy
The UCBLCB-UCB generic policy for non-stationary bandits, from [[Improved Changepoint Detection for Piecewise i.i.d Bandits, by S. Mukherjee & O.-A. Maillard, preprint 2018](https://subhojyoti.github.io/pdf/aistats_2019.pdf)].
Warning
This is still experimental! See https://github.com/SMPyBandits/SMPyBandits/issues/177
-
__init__
(nbArms, delta=None, delta0=1.0, lazy_try_value_s_only_x_steps=10, use_localization=True, *args, **kwargs)[source]¶ New policy.
-
proba_random_exploration
= None¶ What they call \(\alpha\) in their paper: the probability of uniform exploration at each time.
-
lazy_try_value_s_only_x_steps
= None¶ Be lazy and try to detect changes for \(s\) taking steps of size
steps_s
.
-
use_localization
= None¶ experiment to use localization of the break-point, ie, restart memory of arm by keeping observations s+1…n instead of just the last one
-
__module__
= 'Policies.CD_UCB'¶
-
delta
(t)[source]¶ Use \(\delta = \delta_0\) if it was given as an argument to the policy, or \(\frac{\delta_0}{t}\) as the confidence level of UCB/LCB test (default is \(\delta_0=1\)).
Warning
It is unclear (in the article) whether \(t\) is the time since the last restart or the total time?
-
detect_change
(arm, verbose=False)[source]¶ Detect a change in the current arm, using the two-sided UCB-LCB algorithm [Mukherjee & Maillard, 2018].
Let \(\hat{\mu}_{i,t:t'}\) the empirical mean of rewards obtained for arm i from time \(t\) to \(t'\), and \(N_{i,t:t'}\) the number of samples.
Let \(S_{i,t:t'} = \sqrt{\frac{\log(4 t^2 / \delta)}{2 N_{i,t:t'}}}\) the length of the confidence interval.
- When we have data starting at \(t_0=0\) (since last restart) and up-to current time \(t\), for each arm i,
- For each intermediate time steps \(t' \in [t_0, t)\),
Compute \(LCB_{\text{before}} = \hat{\mu}_{i,t_0:t'} - S_{i,t_0:t'}\),
Compute \(UCB_{\text{before}} = \hat{\mu}_{i,t_0:t'} + S_{i,t_0:t'}\),
Compute \(LCB_{\text{after}} = \hat{\mu}_{i,t'+1:t} - S_{i,t'+1:t}\),
Compute \(UCB_{\text{after}} = \hat{\mu}_{i,t'+1:t} + S_{i,t'+1:t}\),
If \(UCB_{\text{before}} < LCB_{\text{after}}\) or \(UCB_{\text{after}} < LCB_{\text{before}}\), then restart.
-


BidiChecker Options
Expected page directionality:
LTR
RTL
Suppress by severity:
From level
Off
Check Page
Bookmarklet link (
what's this?
) that runs BidiChecker with these settings:
BidiChecker


I'm Ciprian, a curious digital designer
specialising in
helping businesses earn
people's attention and grow.
I create compelling advertisements and
websites
that make you look good and
make them look twice.
Why businesses trust me
To make a difference isn't only winning attention, but also telling the story behind your work through magnetic content.
I put "Make it really good" ahead of "Do it quick". It's the many details that invite your customers to jump into your story.
I spend time to understand not only your content but also the context, in order to build trust and sell your lemonade.
Selected projects
For their special annual event "La Semaine
Belge",
Radio Rectangle needed a new logo.
The result
had to inspire new, old and
belgian off the wall.
TEDx events bring innovative ideas to
people
worldwide. I designed the site for
TEDxUNamur,
growing the audience to
thousands in 2016.
Ecology movers and shakers got together
at the
University of Namur for the Doctor
Honoris Causa
awards. The event needed
a strong visual identity.
I help meaningful companies by making
their story visible
through the jungle to
grow their notoriety and sales.
How I can help your business:


{% extends "documentation/documentation_base.html" %} {% block content %}
Submit any transaction that have occurred through the various MLSB sponsor kik bots
{{route.kiktransaction}}
Permission: Kik
Parameter| Field | Type | Description |
|---|---|---|
| amount | int | The amount of the transaction |
| kik | str | The player's kik user name |
| sponsor | str | The name of the sponsor for the transaction |
| Status Code | Response Object | Status |
|---|---|---|
| 200 | True | Successful |
| {{errors.PlayerNotSubscribed.status_code}} | -- | {{errors.PlayerNotSubscribed.message}} |
| {{errors.SponsorDoesNotExist.status_code}} | -- | {{errors.SponsorDoesNotExist.message}} |


WSF/Perl API
Member Classes
WSClient
Constructor
Methods
request
send
WSMessage
Constructor
Methods
WSFault
Constructor
Members
code
reason
role
detail
xml
WSPolicy
Constructor
Policy Options
WSSecurityToken
Constructor
Security API
WSPolicy Class
WSSecurityToken Class
WSClient and WSService Options for Security
WS-SecurityPolicy File Example
Reliable Messaging API
WSClient Options
WSMessage Options


Class: Aws::IAM::Types::VirtualMFADevice
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb |
Overview
Contains information about a virtual MFA device.
Constant Summary
Instance Attribute Summary
-
#base_32_string_seed ⇒ String
rw
The base32 seed defined as specified in [RFC3548][1].
-
#enable_date ⇒ Time
rw
The date and time on which the virtual MFA device was enabled.
-
#qr_code_png ⇒ String
rw
A QR code PNG image that encodes
otpauth://totp/$virtualMFADeviceName@$AccountName?secret=$Base32String
where$virtualMFADeviceName
is one of the create call arguments. -
#serial_number ⇒ String
rw
The serial number associated with
VirtualMFADevice
. -
#tags ⇒ Array<Types::Tag>
rw
A list of tags that are attached to the virtual MFA device.
-
#user ⇒ Types::User
rw
The IAM user associated with this virtual MFA device.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#base_32_string_seed ⇒ String
(rw)
The base32 seed defined as specified in RFC3548. The
Base32StringSeed
is base32-encoded.
# File 'gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb', line 11934
class VirtualMFADevice < Struct.new( :serial_number, :base_32_string_seed, :qr_code_png, :user, :enable_date, : ) SENSITIVE = [:base_32_string_seed, :qr_code_png] include Aws::Structure end
#enable_date ⇒ Time
(rw)
The date and time on which the virtual MFA device was enabled.
# File 'gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb', line 11934
class VirtualMFADevice < Struct.new( :serial_number, :base_32_string_seed, :qr_code_png, :user, :enable_date, : ) SENSITIVE = [:base_32_string_seed, :qr_code_png] include Aws::Structure end
#qr_code_png ⇒ String
(rw)
A QR code PNG image that encodes
otpauth://totp/$virtualMFADeviceName@$AccountName?secret=$Base32String
where $virtualMFADeviceName
is one of the create call arguments.
AccountName
is the user name if set (otherwise, the account ID
otherwise), and Base32String
is the seed in base32 format. The
Base32String
value is base64-encoded.
# File 'gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb', line 11934
class VirtualMFADevice < Struct.new( :serial_number, :base_32_string_seed, :qr_code_png, :user, :enable_date, : ) SENSITIVE = [:base_32_string_seed, :qr_code_png] include Aws::Structure end
#serial_number ⇒ String
(rw)
The serial number associated with VirtualMFADevice
.
# File 'gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb', line 11934
class VirtualMFADevice < Struct.new( :serial_number, :base_32_string_seed, :qr_code_png, :user, :enable_date, : ) SENSITIVE = [:base_32_string_seed, :qr_code_png] include Aws::Structure end
#tags ⇒ Array
<Types::Tag> (rw)
A list of tags that are attached to the virtual MFA device. For more
information about tagging, see Tagging ::Aws::IAM
resources in the
IAM User
Guide.
# File 'gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb', line 11934
class VirtualMFADevice < Struct.new( :serial_number, :base_32_string_seed, :qr_code_png, :user, :enable_date, : ) SENSITIVE = [:base_32_string_seed, :qr_code_png] include Aws::Structure end
#user ⇒ Types::User (rw)
The IAM user associated with this virtual MFA device.
# File 'gems/aws-sdk-iam/lib/aws-sdk-iam/types.rb', line 11934
class VirtualMFADevice < Struct.new( :serial_number, :base_32_string_seed, :qr_code_png, :user, :enable_date, : ) SENSITIVE = [:base_32_string_seed, :qr_code_png] include Aws::Structure end


Next: Open and Closed Streams, Previous: Abstract Classifications of Streams (Introduction to Streams), Up: Introduction to Streams
A stream, whether a character stream or a binary stream, can be an input stream (source of data), an output stream (sink for data), both, or (e.g., when ":direction :probe" is given to open) neither.
Figure 21–2 shows operators relating to input streams.
| clear-input | read-byte | read-from-string |
| listen | read-char | read-line |
| peek-char | read-char-no-hang | read-preserving-whitespace |
| read | read-delimited-list | unread-char |
Figure 21–2: Operators relating to Input Streams.
Figure 21–3 shows operators relating to output streams.
clear-output prin1 write finish-output prin1-to-string write-byte force-output princ write-char format princ-to-string write-line fresh-line print write-string pprint terpri write-to-string
Figure 21–3: Operators relating to Output Streams.
A stream that is both an input stream and an output stream is called a bidirectional stream . See the functions input-stream-p and output-stream-p.
Any of the operators listed in Figure~21–2 or Figure~21–3 can be used with bidirectional streams. In addition, Figure 21–4 shows a list of operators that relate specificaly to bidirectional streams.
y-or-n-p yes-or-no-p
Figure 21–4: Operators relating to Bidirectional Streams.


ngSPICE有三种BJT器件模型，采用下面的语句进行设置:
.model QMOD1 BJT level=2
上面的level
指定了模型的类型，可以是1，2，4三种
The bipolar junction transistor model in ngspice is an adaptation of the integral charge control model of Gummel and Poon. This modified Gummel-Poon model extends the original model to include several effects at high bias levels. The model automatically implifies to the simpler Ebers-Moll model when certain parameters are not specified. The parameter names used in the modified Gummel-Poon model have been chosen to be more easily understood by the program user, and to reflect better both physical and circuit design thinking.
The dc
model is defined by the parameters is
, bf
, nf
, ise
, ikf
, and ne
which determine the forward current gain characteristics, is
, br
,
nr
, isc
, ikr
, and nc
which determine the reverse current gain characteristics, and vaf
and var
which determine the output conductance for forward and reverse regions.
Level 1
model has among the standard temperature model a extension which is compatible with most foundry provided process design kits (see parameter table below tlev
).
Level 1 and 2
model includes substrate saturation current iss
. Three ohmic resistances rb
, rc
, and re
are included, where rb
can be high current dependent. Base charge storage
is modeled by forward and reverse transit times, tf
and tr
, the forward transit time tf
being bias dependent if desired, and nonlinear depletion layer capacitances which are determined by cje
,
vje
, and nje
for the B-E junction, cjc
, vjc
, and njc
for the B-C junction and cjs
, vjs
, and mjs
for the C-S (Collector-Substrate) junction.
Level 1 and 2
model defines a substrate capacitance that will be connected to device’s base or collector, to model lateral or vertical devices dependent from the parameter subs. The temperature dependence of the saturation currents, is
and iss
(for level 2
model), is determined by the energy-gap, eg
, and the saturation current temperature exponent, xti
.
Additionally base current temperature dependence is modeled by the beta temperature exponent xtb
in the new model. The values specified are assumed to have been measured at the temperature tnom
, which can be specified on
the .options
control line or overridden by a specification on the .model
line.
Level 4
model (VBIC) has the following improvements beyond the GP models: Improved Early effect modeling, Quasi-saturation modeling, Parasitic substrate transistor modeling, Parasitic fixed (oxide) capacitance modeling, Includes an avalanche
multiplication model, Improved temperature modeling, Base current is decoupled from collector current, Electrothermal modeling, Smooth, continuous mode.
The BJT parameters used in the modified Gummel-Poon model are listed below. The parameter names used in earlier versions of SPICE2 are still accepted.
| Name | Parameters | levers | Units | default | Example | Scale factor |
|---|---|---|---|---|---|---|
| SUBS | Substrate connection: 1 for vertical geometry, -1 for lateral geometry | level 2 only | 1 | |||
| IS | Transport saturation current | all | A | 1.0e-16 | 1.0e-15 | area |
| ISS | Reverse saturation current, substrate-to-collector for vertical device or substrate-to-base for lateral | level 2 only | A | 1.0e-16 | 1.0e-15 | area |
| BF | Ideal maximum forward beta. | all | 100 | 100 | ||
| NF | Forward current emission coefficient. | all | 1.0 | 1 | ||
| VAF(VA) | Forward Early voltage. | all | V | ∞ | 200 | |
| IKF | Corner for forward beta current roll-off. | all | A | ∞ | 0.01 | area |
| NKF | High current Beta rolloff exponent | all | 0.5 | 0.58 | ||
| ISE | B-E leakage saturation current. | all | A | 0 | 1e-13 | area |
| NE | B-E leakage emission coefficient | all | 1.5 | 2 | ||
| BR | Ideal maximum reverse beta. | all | 1 | 0.1 | ||
| NR | Reverse current emission coefficient. | all | 1 | 1 | ||
| VAR (VB) | Reverse Early voltage. V ¥ 20 | all | V | ∞ | 200 | |
| IKR | Corner for reverse beta high current roll-off. | all | A | ∞ | 0.01 | area |
| ISC | B-C leakage saturation current (area is "areab" for vertical devices and "areac" for lateral). | all | A | 0 | 1e-13 | area |