About
data-graft.js is a animation-friendly differential DOM template engine, self-contained and framework-agnostic.
Instead of stringing up bits of HTML markup, it works from a DOM template, operates on DOM nodes and never touches markup.
data-graft.js updates differentially - minimizing the number of changes to the presentation required to match the new data - and provides hooks to animate those changes.
Check out the catsagram demo and get the code for release 0.1.2: plain or minified
Using
Keep your template in the page - make it invisible with css:
Germinate the presentation graft with initial data and place its output:
graft = data-graft.germ({color:red}, document.getElementById('tpl_about'), {});
dest.appendChild(graft.output);
The 3rd argument to germ() is the context, more on that later.
Update the graft as data changes, this will differentially update its presentation in place:
graft.update({color:blue});
Templates
Templates are annotated DOM element trees:
- data-graft attributes describe how data is grafted with nodes
- id attributes are simply ignored and filtered out
- everything else is copied as is, including all other attributes, text nodes and comments
Templates are accessed in every update, so they need to stay around.
In the following examples d will refer to the data object matched with the element being discussed.
Grafting text
data-graft-text="key"
Use it on an element to place inside a node with text from key of d.
null or undefined will result in no text node at all.
Values
The value of key of d is often the value of the property key in d (d.key), but there are other possibilities:
- if key is the empty string, then the value will be d itself. this is particularly useful if d is already of a simple type
- composition is allowed: e.g.: the key could be a.b with value d.a.b
Functions
It's possible to evaluate a javascript function by prefixing the function name - which can be composite - with a colon (:).
data-graft.js will look for functions in the context object, that's one of the uses for the 3rd argument to germ().
The function to evaluate takes a single argument with d and is expected to return a string.
Currently it's not possible to compose functions with other functions or with property access (.).
Function example
With the following function defined inside context:
context = { f: function(d) { return d.a+ '_'+ d.b; } };
Grafting attribute values
data-graft--name="key"
Use it on an element to set the value of the attribute name to key of d. Note the double dash.
null or undefined will result in the attribute not being set at all.
Grafting conditionally on a property
data-graft-if="key"
data-graft-if allows for conditional presentation of part of a template.
The elements inside will be grafted if and only if key exists in d and d.key is not null or undefined.
d.key will be used as data to graft those elements.
Grafting each property
data-graft-each="prop"
Will graft a copy of the child template element with each (own) property of d.
Inside, prop refers to each property ID.
The copies are ordered by increasing value of the property ID.
data-graft-each can only handle a single child element though it can be arbitrarily complex.
Grafting an array
data-graft-for="key"
Will graft a copy of the child template with each element of the array d.
The copies are identified and ordered by increasing value of key of d, which must be unique for data-graft-for to work correctly.
data-graft-for can only handle a single child element though it can be arbitrarily complex.
Grafting simple array
You can sort and graft an array of a simple type by using the simple values themselves as keys.
But will only work correctly if there are no duplicates.
Grafting by index
You can use the _idx_ special key to graft by index.
The elements of the array will appear in the same order they are in the array, and replace whatever elements were there, rather than move up or down to accommodate changes.
Grafting where else
data-graft-else=""
data-graft-else is complementary to data-graft-if, data-graft-each and data-graft-for.
The elements inside will be grafted if nothing was grafted in the preceding data-graft-if, data-graft-each or data-graft-for.
Animation
data-graft.js operates differentially by design, and will insert, remove and change the minimum amount of elements it can in order to match changed data.
It will not animate any of these changes by itself, but rather provide hooks for application developers to implement their animations.
You can set animation hooks by mapping change handlers inside the context object. These can be set for elements of a specific class:
context = {'item': { preUpdateText: function(e, finished) { finished(); } } };
context = {'_all_': { preUpdateText: function(e, finished) { finished(); } } };
All change handlers have the same signature:
- e is the element being changed or its parent
- f is a function to chain back to (with no args) after completing the animation
Change handlers
All change handlers come in pairs. A pre- and a post-operation. And with the exception of the text change handlers also in Insert- and Remove- pairs.
- preInsert- handlers are called with a newly created element, before it is inserted into the DOM. That doesn't happen until the handler has called back
- postInsert- handlers are called after a new element has been inserted into the DOM
- preRemove- handlers are called before an existing element is removed from the DOM. That doesn't happen until the handler has called back
- postRemove- handlers are called after the element has been removed from the DOM
These 4 handlers are defined for different kinds of elements:
- -Text for data-graft-text, e is the parent data-graft-text element for convenience rather than the text node itself
- -If for data-graft-if, again e is the parent data-graft-if element rather than the elements just inserted/removed under it
- -Sequence for data-graft-each and data-graft-for, in this case e is the the child element
- -Else for data-graft-else, again e is the parent data-graft-else element rather the elements just inserted/removed under it
Finally there are 2 handlers for in-place changes to a text node, in both e is the parent data-graft-text element:
- preUpdateText is called before the text node is changed. That doesn't happen until the handler has called back
- postUpdateText is called after the text node has been changed
Animation start/finish
Each graft update() can set off a cascade of change handler calls and resulting (asynchronous) animations.
Strictly following the convention to call finished() upon the completion of the animation(s) for a change allows update() to orchestrate these callbacks harmoniously.
Until everything settles down, you must not touch the DOM graft either directly or through another call to update() since it may interfere with changes still queued up or with the animations themselves, often with showstopper errors.
To keep tabs with the animation progress you can set two hooks in context:
- start() will be called with no arguments before the animations start
- finish() will be called with no arguments after the animations have finished
Initializing an element
Sometimes, it can be handy to initialize a newly created element.
Change handlers are meant for animation and are not called on initial germination, or for elements internal to an insertion.
context = {'item': { init: function(e) { ... } } };
init is called for each element e created during germination or update. It must perform its function synchronously and without delay


This is my team! We like to consider ourselves as some sort of Guardians of thee Galaxy
type family. We might be disfunctional, but we still get along!


--- title: Sequence Classification keywords: fastai sidebar: home_sidebar summary: "Sequence Classification API for Transformers and Flair" description: "Sequence Classification API for Transformers and Flair" nb_path: "nbs/06_sequence_classification.ipynb" ---
class
TransformersSequenceClassifier
[source]
TransformersSequenceClassifier
(tokenizer
:PreTrainedTokenizer
,model
:PreTrainedModel
) ::AdaptiveModel
Adaptive model for Transformer's Sequence Classification Model
Usage:
>>> classifier = TransformersSequenceClassifier.load('transformers-sc-model')
>>> classifier.predict(text='Example text', mini_batch_size=32)
Parameters:
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
example_text = "This didn't work at all"
classifier = TransformersSequenceClassifier.load("nlptown/bert-base-multilingual-uncased-sentiment")
sentences = classifier.predict(text=example_text,mini_batch_size=1,
)
TransformersSequenceClassifier.load
[source]
TransformersSequenceClassifier.load
(model_name_or_path
:Union
[HFModelResult
,str
])
Class method for loading and constructing this classifier
HFModelResult
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
example_text = "This didn't work at all"
classifier = TransformersSequenceClassifier.load("nlptown/bert-base-multilingual-uncased-sentiment")
sentences = classifier.predict(text=example_text,mini_batch_size=1,
)
TransformersSequenceClassifier.predict
[source]
TransformersSequenceClassifier.predict
(text
:Union
[List
[Sentence
],Sentence
,List
[str
],str
],mini_batch_size
:int
=32
, **kwargs
)
Predict method for running inference using the pre-trained sequence classifier model
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
example_text = "This didn't work at all"
classifier = TransformersSequenceClassifier.load("nlptown/bert-base-multilingual-uncased-sentiment")
sentences = classifier.predict(text=example_text,mini_batch_size=1,
)
class
FlairSequenceClassifier
[source]
FlairSequenceClassifier
(model_name_or_path
:str
) ::AdaptiveModel
Adaptive Model for Flair's Sequence Classifier...very basic
Usage:
>>> classifier = FlairSequenceClassifier.load('sentiment')
>>> classifier.predict(text='Example text', mini_batch_size=32)
Parameters:
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
example_text = "This didn't work at all"
classifier = FlairSequenceClassifier.load('sentiment')
sentences = classifier.predict(text=example_text,mini_batch_size=1,
)
pred = sentences[0].get_labels()[0]
test_eq(pred.value, 'NEGATIVE')
test_close(pred.score, 0.999, 1e-3)
FlairSequenceClassifier.load
[source]
FlairSequenceClassifier.load
(model_name_or_path
:Union
[HFModelResult
,FlairModelResult
,str
])
Class method for loading a constructing this classifier
HFModelResult
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
example_text = "This didn't work at all"
classifier = FlairSequenceClassifier.load('sentiment')
sentences = classifier.predict(text=example_text,mini_batch_size=1,
)
pred = sentences[0].get_labels()[0]
test_eq(pred.value, 'NEGATIVE')
test_close(pred.score, 0.999, 1e-3)
FlairSequenceClassifier.predict
[source]
FlairSequenceClassifier.predict
(text
:Union
[List
[Sentence
],Sentence
,List
[str
],str
],mini_batch_size
:int
=32
, **kwargs
)
Predict method for running inference using the pre-trained sequence classifier model
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
example_text = "This didn't work at all"
classifier = FlairSequenceClassifier.load('sentiment')
sentences = classifier.predict(text=example_text,mini_batch_size=1,
)
pred = sentences[0].get_labels()[0]
test_eq(pred.value, 'NEGATIVE')
test_close(pred.score, 0.999, 1e-3)
class
EasySequenceClassifier
[source]
EasySequenceClassifier
()
Sequence classification models
Usage:
>>> classifier = EasySequenceClassifier()
>>> classifier.tag_text(text='text you want to label', model_name_or_path='en-sentiment')
Usage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
hub = HFModelHub()
model = hub.search_model_by_name("nlptown/bert-base", user_uploaded=True)[0]
classifier = EasySequenceClassifier()
sentences = classifier.tag_text(text=example_text,
model_name_or_path=model,
mini_batch_size=1)
for pred, truth in zip(preds, truth_lbls):
test_eq(pred.value, truth.value)
test_close(pred.score, truth.score, 1e-4)
EasySequenceClassifier.tag_text
[source]
EasySequenceClassifier.tag_text
(text
:Union
[List
[Sentence
],Sentence
,List
[str
],str
],model_name_or_path
:Union
[str
,FlairModelResult
,HFModelResult
]='en-sentiment'
,mini_batch_size
:int
=32
, **kwargs
)
Tags a text sequence with labels the sequence classification models have been trained on
Sentence
, or list of Sentence
s to be classifiedTextClassifier.predict()
method params
return A list of Flair's Sentence
'sUsage Examples:
Sample code from: 06_sequence_classification.ipynb (View Notebook for more context)
hub = HFModelHub()
model = hub.search_model_by_name("nlptown/bert-base", user_uploaded=True)[0]
classifier = EasySequenceClassifier()
sentences = classifier.tag_text(text=example_text,
model_name_or_path=model,
mini_batch_size=1)
for pred, truth in zip(preds, truth_lbls):
test_eq(pred.value, truth.value)
test_close(pred.score, truth.score, 1e-4)
EasySequenceClassifier.tag_all
[source]
EasySequenceClassifier.tag_all
(text
:Union
[List
[Sentence
],Sentence
,List
[str
],str
],mini_batch_size
:int
=32
, **kwargs
)
Tags text with all labels from all sequence classification models
Sentence
input formatsTextClassifier.predict()
method paramsSentence
'sEasySequenceClassifier.release_model
[source]
EasySequenceClassifier.release_model
(model_name_or_path
:str
)
Unload model_name_or_path
from classifier and empty cuda memory cache
May leave residual cache per pytorch documentation on torch.cuda.empty_cache()


Google Code offered in: English - Español - 日本語 - 한국어 - Português - Pусский - 中文(简体) - 中文(繁體)
The Lightweight Metrics system is a useful tool to find key areas where latency may be noticeable to your end users. Some of the advantages of the system are:
The Debug Panel for GWT, developed by Google engineers and GWT contributors, uses the Lightweight Metrics system. It provides an easy way to collect metrics as well as test your GWT application. You can read more details about the features of the tool in this blog post.
The Lightweight Metrics system is composed of sets of events that you're interested in tracking and a global collector method that is responsible for evaluating these events and reporting metrics.
For example, when loading a GWT application, the steps involved in the process consist of bootstrapping the application, loading external references, and starting up the GWT module. Each of these steps further break down into dowloading the bootstrap script, selecting the right permutation of your application to load, fetching the permutation, and so on. This is illustrated in the Lightweight Metrics design doc (see GWT Startup Process diagram). Each of the smaller steps, like selecting the correct permutation of the application to load, can be represented as events you would like to measure in the overall application load time. The events themselves are standard JSON objects that contain the following information:
{ moduleName : <Module name>, subSystem : <Subsystem name>, evtGroup : <Event group>, millis : <Current time in millis>, type : <Event type> }
The moduleName
is the name of your GWT module. The subSystem
refers to the specific component that is emitting these events in your GWT application (for example, the GWT RPC subsystem). The evtGroup
is analogous to a grouping of related events that can be assumed to follow a serial order. The millis
field contains the timestamp when the event was emitted, and the type
field indicates the actual method or step that was run and emitted the event. Each (moduleName, subSystem, evtGroup, type)
tuple can be interpreted as a checkpoint in an event group.
In the GWT Startup Process, the event for selecting a permutation might look something like:
{ moduleName : 'Showcase', subSystem : 'startup', evtGroup : 'bootstrap', millis : new Date().getTime(); type : 'selectingPermutation' }
The global collector function, named __gwtStatsEvent()
, is called whenever you want to report an event to measure. It can either be defined directly in your host HTML page, or injected dynamically. As long as it gets defined before your GWT bootstrap script is executed, it will be receive event metrics. From within the global collection function implementation you can decide how you want to display the metrics collected for the given processes you measured. The collector function must return true
or false
to indicate whether or not the event was successfully recorded.
Here's an example of what the __gwtStatsEvent()
function might look like if you wanted to log all the events you have timed in your GWT application:
 <title>Hello</title>

Statistics for Events Logged

The GWT bootstrap sequence and the GWT RPC mechanism are already instrumented. You can start collecting information about these events simply by defining the global collector function. To see the system in action, add the global collector function in the snippet above to your host HTML page.
You can use the Lightweight Metrics system to measure important events that are specific to your own application. For example, suppose you have a potentially expensive method call somewhere in your entry point onModuleLoad()
called createWidget()
. Create the following method that calls the global stats collector function to measure the time it takes for createWidget()
to execute:
public class StatsEventLogger { public static native void logEvent(String moduleName, String subSystem, String eventGroup, double millis, String type) /*-{ $wnd.__gwtStatsEvent({ 'moduleName' : moduleName, 'subSystem' : subSystem, 'evtGroup' : eventGroup, 'millis' : millis, 'type' : type }); }-*/; }
Next, add calls before and after the code you want to profile in the createWidget() method, as shown below:
public FlexTable createWidget() { FlexTable listings = new FlexTable(); double startTime = Duration.currentTimeMillis(); StatsEventLogger.logEvent(GWT.getModuleName(), "listings", "loadListings", startTime, "begin"); loadListings(listings, range); double endTime = Duration.currentTimeMillis(); StatsEventLogger.logEvent(GWT.getModuleName(), "listings", "loadListings", endTime, "end"); return listings; }
The initial load times as well as RPC execution times for multiple modules can be measured at the same time since they each will make the same call to the __gwtStatsEvent()
global collector function and pass in their module name as part of the event information reported. This makes it easier to evaluate varying functional implementations of a method and compare their performance. You can also compare groups of events across various modules by grouping them by the evtGroup field allowing you to compare larger interaction implementations directly against each other.


All created using Sublime Text or Atom and utilizing basic HTML and CSS for styling:
High school and college studies focused on music and science, particularly music performance like choir and classical guitar and physics and astronomy for my science focus. Photography was a favorite elective. More recently I completed a course in Nutritional Therapy, and pursued general aviation as well by getting my Private Pilots license and Instrument rating.
Nearly 20 years of experience with customer service in the hospitality industry. Currently employed as a Senior Customer Service Jedi and Manager for Coradine Aviation where I remotely manage a small team of 6 CS reps who provide tech support via email using Tender. Since this job includes support for various customizable reports all written with CSS and HTML, I decided to embark on my programming eduction by joining the part-time Intro to Programming evening class at Epicodus.
I love being a mom! My daughter Kessa is 2 - going on 3 - and although it sounds cliche, being her mommy is the most challenging and rewarding chapter in my life thus far. I also love aviation, technology, scuba diving, exploring the world, yoga, nutrition, music, and hanging out with my close friends and family.


Through the use of acrylics and medium, I use the visual language of color and texture to express the freedom and strength of the human mind, memory, emotions, and spirit. I am very interested in how we “see” the world around us, which I view as highly personal. My work employs color and tone and how they play off of each other to produce a visual dialogue, creating a rhythm and sometimes teasing the eye. Much of my current work also uses repetition and symmetry. From a distance, colors and shapes often move and blur. My work is very process driven and I often engage in self imposed limits and systems to show the boundless creative and formal possibilities within these confines.
- Marcia Fraerman 2018
| 1976 | BA Art History and Education, Washington University, St. Louis, MO |
| 2018 | Spacial Ambiguity, Hofheimer Gallery, Chicago, IL |
| 2010 | In the Mind's Eye, Gallery G, Glencoe, IL |
| 2007 | Sharp Edges, Gallery Mornea, Evanston, IL |
| 2005 | Alumni Exhibition, Highland Park High School, Highland Park, IL |
| 2012 | Benefit Art Auction, ORT Gala, Highland Park, IL |
| 2011 | Benefit Art Auction, The Art Center, Highland Park, IL |
| 2009 | Benefit Art Auction, The Art Center, Highland Park, IL |
| 2006 | Student Show, Evanston Art Center, Evanston IL |
| 2005 | Summer Art Festival, Michigan City, MI |
| 2002 | Studio of Evolving Artists, Noyes Street Cafe, Evanston, IL |
The New Art Examiner, “Spatial Ambiguity”, by Bruce Thorn, September/October, 2018
Chicago Fine Art Blogspot, “Spatial Ambiguity”, by Chuck Gniech July 5, 2018
“Spatial Ambiguity” mini review by Dan Ramirez on Facebook, July 21, 2018
Chicago Gallery News, “Spatial Ambiguity”, July 2018
The Visualist, Chicago Visual Arts Calendar, July 2018
| Email: |<EMAIL_ADDRESS>|


Toggle navigation
connecting << blocks
Info
Open Matches
Connect Four
Short Match - 1 hour per move
Please enable Metamask to use this website.


Klank Records
Home
Contact
Blog
Register
Login
0
Contact Us
KlankRecordsOfficial
KlankRecordsOfficial
KlankRecordsOfficial
072 349 5629
<EMAIL_ADDRESS>For demo submissions leave your details below and we will be in contact with you.
Name *
Email address *
We'll never share your email with anyone else.
Phone Number *
How would you like us to respond?
Email
Phone Call
Submit
Back To Top


Besides being an upcoming IT specialist, I like dancing, music, composing and beekeeping.
Configuration of the company network
Network Administration, Web Development, Monitoring, Windows 10 Migration, Virtualisation and IT Support
Diploma project: Development of a Server Room Monitoring System
Network Administration, Development of a Network Monitoring System, Preparing the Windows 10 Migration, Python Programming and Database Development
Supporting the relocation of FCP: Configuring network devices, arranging workstations, configuring printers and beamers, wiring a server room and structured testing
Network Administration, Development of a Sensor System, Python Programming, Database Development and IT Support
Assembling and flashing / programming of network devices, repairing products, packing products and optical quality control


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
Dietary
Yes we’re asking you to deep-fry an egg yolk. But stick with us, coated in crisp breadcrumbs it makes a delicious vegetarian treat with smoked wild mushrooms, celeriac purée and thyme vinaigrette.
Place the diced celeriac in a medium saucepan. Pour over the milk and season with salt and pepper. Bring to the boil, then turn to a simmer and cook until very tender. Drain the celeriac from the milk, reserving the milk, and place the flesh in a blender with half of the milk. Blend to a thick purée. Set aside.
Heat the vegetable oil in a deep-fat fryer or medium sized, tall-sided pan to 170C/340F (CAUTION: hot oil can be dangerous. Do not leave unattended.) Prepare a bowl of ice cold water.
Heat a small saucepan of water until boiling and then turn to a low simmer. Separate the egg yolk from the whites and then drop each yolk into the water and cook for two minutes until just set (a timer is useful for this); now quickly transfer the yolks to the cold water to cool down.
Place the flour, beaten egg and breadcrumbs in three separate bowls ready for coating the yolks. Carefully drain the yolks and transfer to the flour bowl. Gently coat with the flour, followed by the beaten egg and then lastly the breadcrumbs. Set aside.
Heat a griddle pan over a medium heat. Rub the porcini with the oil, season well with salt and pepper and add to the pan with the garlic. Once the porcini slices are cooked through and nicely caramelised, remove from the grill and reserve.
To smoke the porcini, be sure to be working in a ventilated space. Place a medium pan over a high heat and add the drained smoking chips. On top of this add some scrunched up foil or metal baking rings to form a trivet and then a small colander or strainer.
When the chips start to smoke, add the porcini to the colander and place a tight-fitting lid over the pan.
Remove the pan from the heat and allow the porcini to smoke for 3-4 minutes, or until they catch the flavour of the smoke. Do not leave the mushrooms too long in the pan as they can turn acrid. Remove and set aside.
Deep-fry the eggs in the hot oil until golden-brown and crisp. Carefully remove using a slotted spoon and drain on kitchen paper.
For the thyme vinaigrette, whisk together the rapeseed oil and the vinegar in a small bowl, season well and then stir in the thyme leaves, lemon juice and Dijon mustard.
To serve, spoon some of the warm celeriac purée onto serving plates and then top with the mushrooms and the the crisp yolk. Finally spoon over the thyme vinaigrette.


- key k is mapped to the node with the smallest identrifier $id \ge k$
- key 128 or 160 bits long
- for instance node 9 is asked to look up the node responsible for key 3
- node 9 has 4 shortcuts 11, 14, 18, and 28
- node 28 forward request to node 1
Unstructured peer-to-peer systems
- each node maintains ad hoc list of neighbors
- overlay network resembles to a random graph
- lists of neighbors are changed frequently
- different techniques for the search of data
- Flooding - passing request to all neighbors
- Random walks - randomly choosing neighbors
- in both cases TTL (time to live) method is
used to constraint number of hops
Hybrid architectures
- client-server solutions combined with decentralized solutions
- Edge server systems
- Colaborative distributed systems
Edge server systems
- hybrid architecture in which Internet Service Providers (ISPs) to which end users
connect are considered to be on the edge (edge servers)
- edge servers (ISPs):
- are used to optimize content and application distribution
- represent a boundary between enterprise networks and actual Internet
- are used to optimize the content, for application distribution, for Web site
replication etc.
Edge server systems
internet as a collection of edge servers
Colaborative distributed systems
- starting communiation is an issue
- solution:
- during starting phase using traditional client-server scheme
- after starting phase fully decentralised scheme used for colaboration
- example: BitTorrent file sharing system
BitTorrent
logic - end user downloads chunks of a file until he has the complete file
Question: how to ensure collaboration?
- free riding - majority of users only
downloading but contributing nothing
BitTorrent - organization
-
well-known Web sites contain referrences to torrent files
-
torrent files - contain information necessary to download a specific file
-
torrent files contain links to trackers
-
tracker has an account of active nodes
-
active nodes - nodes which in the process of downloading the same file
-
simple rule for colaboration
P can decide to decrease the rate at which it sends data to Q
if Q is downloading more than it is uploading
BitTorrent - organization cont.
-
generally only one tracker per file
-
tracking functionality is minimalized to one-time provisioning
of peers.
-
trackers provides only part of all downloading nodes
-
swarm - complete set of downloading nodes
-
neighbor set - subset of swarm with whom node collaborates
-
neighbor set periodically updated by contacting the tracker
- when new peer joins the swarm
BitTorrent - organization cont.
-
seeder - node which has all chunks of file
and continues to participate in its swarm
-
leechers - all others in the swarm
-
pieces - equaly sized chunks, the file is divided in
- typically 256 Kbyte
-
block - unit of data transfer between peers
- typically 16 Kbyte
-
potential set - neighbor B belongs to potential set of node A if it
has nodes that A does not have, and vice versa - important for trading
BitTorrent - downloading phases
-
Bootstrap phase
pieces get through mechanisam of optimistic unchoking
-
Trading phase
there are always peers with whom node can trade blocks
-
Last download phase
- potential set has dropped to zero
- node dependent on newly arriving peers
BitTorrent - downloading phases
developement of the potential set size relative to the neighborhood size


THE ICICLE THIEF A film review by Barry Margolin Copyright 1990 Barry Margolin
Over the weekend I saw the Italian film THE ICICLE THIEF. I'm surprised that I haven't seen any mention of it on the net (unless it was all during my vacation a couple of weeks ago). I'm cross-posting to rec.arts.tv because TV is part of the subject matter of the movie.
THE ICICLE THIEF is a wonderful satire and spoof. It's a satire of the butchering that is done to films in order to show them on TV, using the "film within a film" technique and turning it inside-out. The inner film is a drama about a family after WWII, in turmoil because the father can't find work. The outer film is about activities at the TV studio broadcasting the film, preceded by a review and interview with the director (the outer director, playing himself); part of the outer film also takes place in the living room of a family watching the movie (a must-see for Lego lovers -- could someone tell me what the kid built).
Since the movie is being shown on a commercial TV station, it is periodically interrupted by commercials. Things get strange, though, when one of the children in the inner movie starts humming one of the jingles and an actress from one of the commercials shows up in the movie. After this, things get *very* weird, but I won't say any more since I promised only minor spoilers.
This is definitely one of the funniest movies I've seen in a long time. The subtitling was done very well, I hardly ever had trouble reading the dialogue.
-- Barry Margolin, Thinking Machines Corp.
<EMAIL_ADDRESS>{uunet,harvard}!think!barmar
.
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


I have always liked opiated hashish, though I hear that indicates a sub-standard quality of both the opium and the hash. Regardless, it has always been my high of choice, though, for me, it has been extremely hard to find since the days of the drug wars. In it's absence, I do what I can.
Recently I have discovered that opium poppies are sold as ornamental dried flowers, and that unlike the seed teas, the pod tea is fairly palatable and potent. I am quite sensitive to most psycho-active drugs, though I acclimate quickly, and need very little to feel the euphoric effects. The tea works well for me, and I find it eminently drinkable when mixed with oolong or green tea and honey. The high seems to last the entire evening and over night, leaving a pleasantly swingy drone in my head the next morning.
However, I stumbled over an internet post that described not only making the tea, but also in consuming the left-over pulp. The author related that the high lasted well into the following day, adding that it wasn't ever particularly intense, but that it seemed to just go on and on. Not being particularly squeamish, I gave this a try and found the description to be quite accurate. The initial high seemed to be equal to what one expects of the tea, but it intensified a bit after about an hour, and then, after I had slept (and slept well), ran until the next morning or so, gradually tapering off.
Since that time I have tried goosing the end of the high with another dose, and find that it is very, very easy to overdo it, pushing myself into an itching, irritated bundle of raw nerves. A friend of mine and I, each on our own, have since then been experimenting with eating the ground pods raw, unsteeped, gaging dosages. He has reported the feeling of approximately one and a half medium sized pods (spread out over a day) as akin to the feeling of a vicodin, but lasting throughout, without any peaks or valleys. For myself, codeine and vicodin make me sleepy, so that analogy doesn't apply. I found that the dry ground pods give a high equivalent to smoking opium, though nowhere as intense nor as debilitating, just as with the tea. Additionally different from the opium high I am used to, I find no difficulty doing physical work, in fact the high seems stimulating, like weak coffee, in the first hour or two, also lending me an air of focus and an attention to detail.
In addition, the fiber of the pulp seems to help offset the constipating nature of the opium, though not entirely. However, I found that I require a greater amount of the plant matter than my friend, perhaps fifty percent more, more than two pods spread out over a day. Whether this is because I weigh perhaps twice what he does, or because of a uniqueness in my own chemistry, I am not sure, but I suspect the former. Ultimately, the high seems no different from the high the tea brings, though the effects last substantially longer.
This seems a thoroughly inviting method of inebriation, I only have three hesitations: ONE--On an empty stomach the dry material sometimes produced sudden and unexpected bouts of nausea, which were quite intense at times, though they passed quickly, but I was never sure if or when they would repeat. Fortunately I never did vomit, on any of the occasions, but it could have gone either way.
TWO—From my experiences with mushroom picking, I have learned to be cautious of parasites. I think that rather than eating the dry plant pulp, or encapsulating it, it likely would be better to brew the tea, sparging the material with very hot water to reduce the possibility of infestation. I feel much better about ingesting the resulting mash than I do about eating the dry herb, and it seems to have little effect on the longevity of the high, though it seems stronger in it's initial phase and less so in the longer term.
THREE—Lastly I am concerned about the alkaloids in the plant matter that may not be present in traditional opium, and therefore may not be well understood or known at all. One must assume that the opium sap and the other alkaloids in the poppy plant developed as a poisonous deterrent to animals who might eat the flower. That begs the question of whether the plant is safe for people to eat. It is entirely possible that it may cause liver or kidney problems, if ingested in sufficient quantity, over a long enough period of time. As yet I have been unable to find any information relating to this subject, so it remains, to me, an outstanding issue.
These objections aside, I find that eating the poppy is a preferable alternative to smoking opium or taking opiate pills. Saving my one ultimate preference, I very much enjoy this high over most any other I've found.
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.


| {{team.week - 1}} |
{{team.opponent}} |
{{(team.home) ? 'Home': 'Away'}} |
{{(team.record === 'Bye Week') ? ' ' : team.record}} |
{{(team.result === 'Bye Week') ? ' ' : team.result}} |
{{team.points_for}} |
{{team.points_against}} |
{{team.total_yards_for}} |
{{team.pass_yards_for}} |
{{team.rush_yards_for}} |
{{team.turnovers_forced}} |
{{team.total_yards_against}} |
{{team.pass_yards_against}} |
{{team.rush_yards_against}} |
{{team.turnovers_lost}} |


Rust is a compiled programming language which aims to replace C++. The designers wanted it to be similar fast, give the programmer similar fine-grained control over memory management, but more safety.
Rust does so by introducing the concept of ownership, borrowing and lifetimes of variables. Rust also makes sure that after the scope is finished, the memory of variables gets de-allocated.
I think FFI is interesting. It allows Rust to "talk" with C code.
Rust 1.0 was just released (source). This means the language should be stable.
If you want to know more, you should take a look at the beautiful A 30-minute Introduction to Rust.
Syntax Example
fn fib(n: u32) -> u32 {
if n <= 1 {
return n;
} else {
return fib(n-1) + fib(n-2);
}
}
fn main() {
let n = 36;
println!("The {0}th Fibonacci number is {1}.", n, fib(n))
}
Video introduction
Comparison
- benchmarksgame shows that rust is similar fast as C++. For some games it is faster, for some slower. Sometimes it needs less code, sometimes more.
- stackoverflow has only 1781 questions of which are 102 unanswered (5.7%). C++ has 356,824 questions and 55,172 questions are not answered (15.5%). But I guess that will change as soon as more people use Rust (and libraries written in Rust).
- GitHub: Wow, Rust seems to be growing fast!
Tools
As rust is still in very heavy development, you should build it yourself from the source at GitHub. Don't worry, there are very detailed instructions. (But it takes a lot of time to compile.)
cargo
package manager- Syntax Highlighting and auto completion for ST3 (via Package Control)
- Auto completion with Racer
Comparison to C++
1: No crashes because of code misuse (as long as you do not use unsafe {} )
2: No memory leaks
3: No data races (so you can thread this thing like mad, but better is has async task handling (crs pattern to). So lighting up your machines cores is no prob.
4: Cross platform (really much better than most)
5: Inbuilt version management, build system and test harness (with benchmarking to).
6: Package management system (no more I Cannot build XX, it becomes automatic)
7: Inbuilt generics and traits (c++ concepts and more)
8: Very strongly typed (near zero runtime)
9: Very fast
10 compiles into a c lib basically (easy integration)
Source: dirvine
See also
- www.rust-lang.org: Official Website
- doc.rust-lang.org: Shown with
fmt
- looks very nice! - doc.rust-lang.org/intro.html
- doc.rust-lang.org/book/
- doc.rust-lang.org/reference.html
- blog.rust-lang.org
- crates.io: Hosting site for community packages ☺
- rustbyexample.com
- joshondesign.com/2014/09/17/rustlang: A short introduction to Rust with a tiny ray tracer.
- learnxinyminutes.com/docs/rust
Conclusion
Rust looks very, very interesting. I am usually not a fan of new languages (e.g. I don't see a reason to use Go, Swift ... not to speak of Clojure, Julia, TypeScript, Dart). Most of the time, I don't see anything new which is better than in existing languages and almost always the material around (tools, libraries, community) is much worse than in existing solutions.
This seems to be different with Rust. Rust seems to provide everything I enjoy from Python, but in the fast, explicitly typed world.
@Johannes: Thanks for pointing me to Rust ☺


Pizza Planet
Customize Pizza
Toppings: ($2 Each)
Cheese (Free)
Pepperoni
Sausage
Canadian Bacon
Onion
Pepper
Olive
Pineapple
Hot sauce
Feta Cheese
Pesto
Anchovies
Size:
Mercury
Earth
Mars
Add Pizza
Purchase Order
Order Summary:
Number of Pizzas:
Total Cost: $
Special thanks for choosing Pizza Planet.
© 2020 Pizza Planet
Reset Order!


A volunteer organization whose goal is to provide registration, support, and insurance for members who are involved in volunteer animal-assisted activities.
An Alzheimer’s Association event that takes place every summer solstice to raise funds and awareness for care, support and research.
A non-profit whose vision is to grant the wish of every child diagnosed with a life-threatening medical condition.
An organization inspiring kids to read by delivering books to kids across 18 states.
A community creating economic and social mobility through entrepreneurship.
An organization that helps people in Bryan and College Station, Texas to live independently for as long as possible.
A private college focused on a curriculum that prepares students for careers in sustainable energy fields (wind, solar, etc.).
A campaign under Hope 4 Women International bringing dignity to women around the world through dress donations.
A three to five mile honor and awareness walk hosted by the American Cancer Society.
Provides volunteer opportunities for civilians anywhere in America to express their appreciation to all who serve our nation and annually sends 200,000+ care packages.


DiscordMail links your Discord account to a unique E-Mail address, opening the reach of Discord to be able to communicate to a wider range of of people.
Create an account today!
Invite the bot and type 'dmail register'
By registering with DiscordMail, you fully agree to the contents of the Terms of Service and Privacy Agreement, found in the documentation.


The controls below allow to tranverse between 4 colours
ENTER -->
Blue
L -->
Green
Y -->
Yellow
R -->
Red


Elegant, powerful, and easy to use cloud-based platform
Create, configure and customize B2B eCommerce sites faster, easier and at lower cost. Solve complex order management challenges quickly by leveraging our cloud-based platform.
Component Based Development Get to your custom solution faster by leveraging our core acceleration components. Best practices, your way.
Rapid Development Tools Leverage seeds, SDK's, Documentation and Courses to build on OrderCloud quickly.
Extendable Data Model Built on 16 years solving complex eCommerce and order management challenges. Feature rich and robust.
Developers can create custom code, debug the code, check it into a common source code repository and deploy it to the test, staging or production environments.


Let the Other 95% of Great Programmers In
December 2014
American technology companies want the government to make immigration easier because they say they can't find enough programmers in the US. Anti-immigration people say that instead of letting foreigners take these jobs, we should train more Americans to be programmers. Who's right?
The technology companies are right. What the anti-immigration people don't understand is that there is a huge variation in ability between competent programmers and exceptional ones, and while you can train people to be competent, you can't train them to be exceptional. Exceptional programmers have an aptitude for and interest in programming that is not merely the product of training. [1]
The US has less than 5% of the world's population. Which means if the qualities that make someone a great programmer are evenly distributed, 95% of great programmers are born outside the US.
The anti-immigration people have to invent some explanation to account for all the effort technology companies have expended trying to make immigration easier. So they claim it's because they want to drive down salaries. But if you talk to startups, you find practically every one over a certain size has gone through legal contortions to get programmers into the US, where they then paid them the same as they'd have paid an American. Why would they go to extra trouble to get programmers for the same price? The only explanation is that they're telling the truth: there are just not enough great programmers to go around. [2]
I asked the CEO of a startup with about 70 programmers how many more he'd hire if he could get all the great programmers he wanted. He said "We'd hire 30 tomorrow morning." And this is one of the hot startups that always win recruiting battles. It's the same all over Silicon Valley. Startups are that constrained for talent.
It would be great if more Americans were trained as programmers, but no amount of training can flip a ratio as overwhelming as 95 to 5. Especially since programmers are being trained in other countries too. Barring some cataclysm, it will always be true that most great programmers are born outside the US. It will always be true that most people who are great at anything are born outside the US. [3]
Exceptional performance implies immigration. A country with only a few percent of the world's population will be exceptional in some field only if there are a lot of immigrants working in it.
But this whole discussion has taken something for granted: that if we let more great programmers into the US, they'll want to come. That's true now, and we don't realize how lucky we are that it is. If we want to keep this option open, the best way to do it is to take advantage of it: the more of the world's great programmers are here, the more the rest will want to come here.
And if we don't, the US could be seriously fucked. I realize that's strong language, but the people dithering about this don't seem to realize the power of the forces at work here. Technology gives the best programmers huge leverage. The world market in programmers seems to be becoming dramatically more liquid. And since good people like good colleagues, that means the best programmers could collect in just a few hubs. Maybe mostly in one hub.
What if most of the great programmers collected in one hub, and it wasn't here? That scenario may seem unlikely now, but it won't be if things change as much in the next 50 years as they did in the last 50.
We have the potential to ensure that the US remains a technology superpower just by letting in a few thousand great programmers a year. What a colossal mistake it would be to let that opportunity slip. It could easily be the defining mistake this generation of American politicians later become famous for. And unlike other potential mistakes on that scale, it costs nothing to fix.
So please, get on with it.
Notes
[1] How much better is a great programmer than an ordinary one? So much better that you can't even measure the difference directly. A great programmer doesn't merely do the same work faster. A great programmer will invent things an ordinary programmer would never even think of. This doesn't mean a great programmer is infinitely more valuable, because any invention has a finite market value. But it's easy to imagine cases where a great programmer might invent things worth 100x or even 1000x an average programmer's salary.
[2]  By all means crack down on these. It should be easy to write legislation that distinguishes them, because they are so different from technology companies. But it is dishonest of the anti-immigration people to claim that companies like Google and Facebook are driven by the same motives. An influx of inexpensive but mediocre programmers is the last thing they'd want; it would destroy them.
[3] Though this essay talks about programmers, the group of people we need to import is broader, ranging from designers to programmers to electrical engineers. The best one could do as a general term might be "digital talent." It seemed better to make the argument a little too narrow than to confuse everyone with a neologism.
Thanks to Sam Altman, John Collison, Patrick Collison, Jessica Livingston, Geoff Ralston, Fred Wilson, and Qasar Younis for reading drafts of this.


{% extends "home.html" %} {% block body_attrs %}{% endblock %} {% block main %}
This privacy policy has been compiled to better serve those who are concerned with how their
'Personally identifiable information' (PII) is being used online. PII, as used in US privacy law and information
security, is information that can be used on its own or with other information to identify, contact, or locate a
single person, or to identify an individual in context. Please read our privacy policy carefully to get a clear
understanding of how we collect, use, protect or otherwise handle your Personally Identifiable Information in
accordance with our website.
When ordering or registering on our site, as appropriate, you may be asked to enter your name, email address or other details to help you with your experience.
We collect information from you when you register on our site or enter information on our site.
We may use the information we collect from you when you register, make a purchase, sign up
for our newsletter, respond to a survey or marketing communication, surf the website, or use certain other site
features in the following ways:
• To personalize user's experience and to allow us to deliver the type of content and product offerings in which you are most interested.
We do not use vulnerability scanning and/or scanning to PCI standards.
We use regular Malware Scanning.
Your personal information is contained behind secured networks and is only accessible by a limited number of persons who have special access rights to such systems, and are required to keep the information confidential. In addition, all sensitive/credit information you supply is encrypted via Secure Socket Layer (SSL) technology.
We implement a variety of security measures when a user enters, submits, or accesses their information to maintain the safety of your personal information.
All transactions are processed through a gateway provider and are not stored or processed on our servers.
Yes. Cookies are small files that a site or its service provider transfers to your computer's hard drive through your Web browser (if you allow) that enables the site's or service provider's systems to recognize your browser and capture and remember certain information. For instance, we use cookies to help us remember and process the items in your shopping cart. They are also used to help us understand your preferences based on previous or current site activity, which enables us to provide you with improved services. We also use cookies to help us compile aggregate data about site traffic and site interaction so that we can offer better site experiences and tools in the future.
We use cookies to:
• Compile aggregate data about site traffic and site interactions in order to offer better site experiences and tools in the future. We may also use trusted third party services that track this information on our behalf.
You can choose to have your computer warn you each time a cookie is being sent, or you
can choose to turn off all cookies. You do this through your browser (like Internet Explorer) settings. Each
browser is a little different, so look at your browser's Help menu to learn the correct way to modify your
cookies.
If users disable cookies in their browser:
If you disable cookies off, some features will be disabled It will turn off some of the features that make your site experience more efficient and some of our services will not function properly.
We do not sell, trade, or otherwise transfer to outside parties your personally identifiable
information unless we provide you with advance notice. This does not include website hosting partners and other
parties who assist us in operating our website, conducting our business, or servicing you, so long as those
parties agree to keep this information confidential. We may also release your information when we believe
release is appropriate to comply with the law, enforce our site policies, or protect ours or others' rights,
property, or safety.
However, non-personally identifiable visitor information may be provided to other
parties for marketing, advertising, or other uses.
We do not include or offer third party products or services on our website.
When it comes to the collection of personal information from children under 13, the
Children's Online Privacy Protection Act (COPPA) puts parents in control. The Federal Trade Commission, the
nation's consumer protection agency, enforces the COPPA Rule, which spells out what operators of websites and
online services must do to protect children's privacy and safety online.
We do not specifically market to children under 13.
The Fair Information Practices Principles form the backbone of privacy law in the United
States and the concepts they include have played a significant role in the development of data protection laws
around the globe. Understanding the Fair Information Practice Principles and how they should be implemented is
critical to comply with the various privacy laws that protect personal information.
In order to be in line with Fair Information Practices we will take the following responsive action, should a data breach occur:
We will notify the users via email
• Within 7 business days
We will notify the users via in site notification
• Within 7 business days
We also agree to the individual redress principle, which requires that individuals have a
right to pursue legally enforceable rights against data collectors and processors who fail to adhere to the law.
This principle requires not only that individuals have enforceable rights against data users, but also that
individuals have recourse to courts or a government agency to investigate and/or prosecute non-compliance by
data processors.
If there are any questions regarding this privacy policy you may contact us.


Contents:
Defined in File filesystem.h
Path
Public Functions
operator=
parentPath
filename
extension
empty
getImpl
operator std::string
string
operator==
operator!=


Vert.x is a polyglot event-driven application framework that runs on the Java Virtual Machine (JAVA 7 is the minimum supported version). Like Node.js, Vert.x is asynchronous and scalable, and lets developers build modern and effective web applications.
Being polyglot, Vert.x can be used in many flavors, among which : JavaScript,CoffeeScript, Ruby, Python,Groovy and Java. In order to enforce asynchronism and scalabity, Vert.x is built upon Netty, leverage the reactor pattern, using a frightening number of handlers.
This article aims at showing the powerful combination of Scala and Vert.x - the Java counterpart being provided as comparison. Note : the source code are hosted on GitHub as part of lang-scala https://github.com/ouertani/vert.x/tree/master/vertx-lang/vertx-lang-scala
Vert.x supports many components :
I - WebSocket
Web Socket are HTML 5 feature providing full-duplex communications. For old browsers that do not support WebSocket, Vert.x provides SockJS as out-of-the-box component.
In order to run the following example check out : https://github.com/ouertani/vert.x/blob/master/vertx-examples/src/main/javascript/websockets/ws.html and save it into the compiled lib directory
Java
import org.vertx.java.core.Handler;
import org.vertx.java.core.buffer.Buffer;
import org.vertx.java.core.http.HttpServerRequest;
import org.vertx.java.core.http.ServerWebSocket;
import org.vertx.java.deploy.Verticle;
public class SampleWebSocket extends Verticle {
public void start() {
vertx.createHttpServer().websocketHandler(new Handler<ServerWebSocket>() {
public void handle(final ServerWebSocket ws) {
if (ws.path.equals("/myapp")) {
ws.dataHandler(new Handler<Buffer>() {
public void handle(Buffer data) {
ws.writeTextFrame(data.toString()); // Echo it back
}
});
} else {
ws.reject();
}
}
}).requestHandler(new Handler<HttpServerRequest>() {
public void handle(HttpServerRequest req) {
if (req.path.equals("/")) req.response.sendFile("ws.html"); // Serve the html
}
}).listen(8080);
}
}
Scala
import org.vertx.java.core.buffer.Buffer;
import org.vertx.java.core.http.HttpServerRequest;
import org.vertx.java.core.http.ServerWebSocket;
import org.vertx.scala.deploy.Verticle
import org.vertx.scala.core._
class SampleWebSocket extends Verticle (
_.getVertx().createHttpServer().websocketHandler{
ws:ServerWebSocket => ws.path match {
case "/myapp" => ws.dataHandler{data : Buffer => ws.writeTextFrame(data.toString())}
case _ => ws.reject();
}}
.requestHandler{req : HttpServerRequest => req.path match {case ("/") => req.response.sendFile("ws.html")}}
.listen(8080)
)()
II-HttpWebServer
Vert.x allows you to easily write full featured, highly performant and scalable HTTP and HTTPS servers.
The following example starts up an Http server, listening on port 8080, and logging all received requests.
Java
import org.vertx.java.core.Handler;
import org.vertx.java.core.http.HttpServer;
import org.vertx.java.core.http.HttpServerRequest;
import org.vertx.java.core.logging.Logger;
import org.vertx.java.deploy.Verticle;
public class SampleHttpWebServer extends Verticle {
public void start() {
HttpServer server = vertx.createHttpServer();
final Logger log = getContainer().getLogger();
server.requestHandler(new Handler<HttpServerRequest>() {
public void handle(HttpServerRequest request) {
log.info("A request has arrived on the server!");
}
}).listen(8080, "localhost");
}
}
Scala
import org.vertx.java.core.http. { HttpServerRequest => JHttpServerRequest}
import org.vertx.scala.deploy.Verticle
import org.vertx.scala.core._
class SampleWebServer extends Verticle ( x =>
x.getVertx().createHttpServer().withRequestHandler{_ : JHttpServerRequest =>
x.info("A request has arrived on the server!")}
.listen(8080, "localhost")
)()
III-HttpClient
Vert.x also provides an HttpClient API, so as to interact with the server part. The following samples create and send a GET request, then log the server’s response.
Java
import org.vertx.java.core.Handler;
import org.vertx.java.core.http.HttpClient;
import org.vertx.java.core.http.HttpClientRequest;
import org.vertx.java.core.http.HttpClientResponse;
import org.vertx.java.core.logging.Logger;
import org.vertx.java.deploy.Verticle;
public class SampleHttpClient extends Verticle {
@Override
public void start() throws Exception {
HttpClient client = vertx.createHttpClient().setHost("<IP_ADDRESS>");
final Logger log = getContainer().getLogger();
HttpClientRequest request = client.post("/some-path/", new Handler<HttpClientResponse>() {
public void handle(HttpClientResponse resp) {
log.info("Got a response: ");
}
});
request.end();
}
}
Scala
import org.vertx.scala.deploy.Verticle
import org.vertx.scala.core._
class SampleWebClient extends Verticle (v =>
v.getVertx.createHttpClient().setHost("<IP_ADDRESS>").setPort(8080)
.andGetNow("/") {_ => v.info("Got a response: " )}
)()
IV-EventBus
The event bus is like a vertebral spine, it can be used to connect distributed nodes, and to support interaction between different Verticles, even written in different languages.
Java
import org.vertx.java.deploy.Verticle;
import org.vertx.java.core.eventbus.EventBus;
public class SampleEventBus extends Verticle {
@Override
public void start() throws Exception {
EventBus eb = vertx.eventBus();
eb.send("path", "ping1");
eb.send("path", "ping2");
}
}
Scala
import org.vertx.scala.deploy.Verticle
import org.vertx.scala.core._
class SampleEventBus extends Verticle ( x => {
val point = x ! ("path")
point >> ("ping 1")
point >> ("ping 2")
}
)()
Conclusion
This article introduced the basic of Vert.x using scala language and short examples. Full Scala language support will soon, hopefully, become available.
Stay tuned, a subsequent post will show you more about Vert.x with Scala.
source : http://blog.zenika.com/index.php?post/2013/02/11/fun-with-scala-and-vert-x


Climate Change Puts North Africa in Hot Spot
Government leaders and experts plan a climate change summit in Madrid next month amid a raft grim reports about the warming world. Sandwiched between an expanding Sahara and a rising Mediterranean Sea, North African countries are particularly vulnerable to its effects. From the Tunisian village of Bir Salah, Lisa Bryant takes a look at the challenges and what’s being done.


I will be photographing and capturing your entire day! Not a moment will be missed.
The flash-drive will be loaded with at least one hundred of your wedding's unwatermarked, professionally edited photos, all the non-edited photos, and a slideshow for both of you to enjoy and easily share among your family and friends.
After I hand-pick and professionally edit your best moments, I will send you a high quality, leather covered wedding album. The perfect mantle piece.


This tool lets you convert a normal string including newlines, quotes and unicode characters into a payload string literal ready to use in your REST client. hide
You neeed Javascript enabled in your browser for this to work.
© Public Domain. NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. Created 2011 by Bernhard Häussner. Escaping code borrowed from Douglas Crockford's JSON-js.
Normal:
Ready to post as payload:


Project¶
Projects are the root container which contain all other resources. Projects are composed of:
- apps
- settings
Once you start using gordon, you’ll realize it makes sense to have several projects, and not only one monolitic one with dozens of applications.
This is not news to you if you have heard about microservices, but it is good to emphasize that massive projects might not a good idea (generally speaking).
As always, give it a shoot and decide what is better for you.
How can I create a new project?¶
Creating a new project is easy, you only need to run the following command:
$ gordon startproject demo
This will create a new directory called demo
which will contain the most basic project. That’s a single settings.yml
file:
demo
└── settings.yml
Project Actions¶
Once you have created your project, there are two main actions that you’ll run from the command line; build
and apply
.
build¶
Build is the action that will collect all registered resources in your project, and create several
templates in the _build
directory which will represent everything you have defined.
As well as creating these templates, gordon will create all necessary artifacts that it’ll later upload to s3.
At this point, gordon will not use any AWS credentials. This is important.
What gordon generates in the build directory is merely declarative and completely agnostic of in which region or stage you’ll (later) deploy it. Gordon doesn’t know/care what is the current status (if any) of all those resources.
This is one of the greatness (and technical challenges) of gordon.
The number of required templates depend on you project, but these are all possible templates gordon will create:
| Acronym | Name | Description |
|---|---|---|
pr_p.json |
Pre Project | Custom template - This is not generally used |
p.json |
Project | CloudFormation template - Gordon will create a S3 bucket where it’ll upload your lambdas |
pr_r.json |
Pre Resources | Custom template - Gordon will generally upload your lambdas to S3. |
r.json |
Resources | CloudFormation template - Gordon will create your lambdas and event sources |
ps_r.json |
Post Resources | Custom template - This is not generally used |
apply¶
Apply is the action that will deploy your project to one specific region and stage.
| Term | Description |
|---|---|
region |
AWS cloud is divided in several regions. Each Region is a separate geographic area. AWS Regions and Availability Zones |
stage |
Stages are 100% isolated deployments of the same project. The idea is that the same project can be deployed in the same AWS account in different stages (dev , staging , prod ...) in order to SAFELY test it’s behaviour. |
This command will:
- Collect all required parameters for this stage.
- Sequentially apply all gordon templates.
This command (for obvious reasons), will use your AWS credentials to apply your project templates.
delete¶
Removes all deployed project resources of one specific region and stage.
This is a destructive action, so gordon will by default do a dry-run
and output all resources which would be deleted.
If you are ok with those resources being deleted, you can run the same command but adding
the argument --confirm
in order to confirm your desire of gordon deleting all of them.
Anatomy of the project¶
---
project: { STRING }
default-region: { AWS_REGION }
code-bucket: { STRING }
apps:
- { STRING }
vpc: { MAP }
contexts: { MAP }
Lambda Properties¶
Project Name¶
| Name | project |
| Required | Yes |
| Valid types | string |
| Description | Name for your Project |
default-region¶
| Name | default-region |
| Required | Yes |
| Valid types | string |
| Description | Default region where the project will be deployed |
code-bucket¶
| Name | code-bucket |
| Required | Yes |
| Valid types | string |
| Description | Base Name of the bucket gordon will use to store the source code of your lambdas and Cloudformation templates. |
Because the source code and the lambdas needs to be in the same region, gordon will create on bucket per region and stage following the following format:
$CODE_BUCKET-$REGION-$STAGE
.
apps¶
| Name | apps |
| Required | Yes |
| Valid types | list |
| Description | List of installed apps |
By default when you create a project, gordon will include some applications which you’ll probably need. Those applications are called gordon.contrib applications and provide you (and your gordon project) with some basic functionalities that you (or gordon) might need.
vpc¶
| Name | vpc |
| Required | No |
| Valid types | map |
| Description | Map of vpc names with their respective security-groups and subnet-ids . |
For more information Lambdas vpc setting.
Example:
---
project: vpcexample
...
vpcs:
my-vpc:
security-groups:
- sg-00000000
subnet-ids:
- subnet-1234567a
- subnet-1234567b
- subnet-1234567c


Nearly half of Wellingtonians accessing ultra-fast internet
Press Release – Business Central – Wellington
Wellington’s increasing uptake of ultra-fast broadband will help cement our reputation as a creative capital where high-tech start-ups want to be.
“The government’s fibre roll-out programme means 44 per cent of Wellington’s households and businesses are now accessing the internet at lightning speeds,” says Chief Executive John Milford.
“This is really impressive infrastructure that enables businesses to dramatically improve their productivity and reach markets they could never dream of before.
“It demonstrates what is possible when the government thinks ahead and partners with private companies to deliver 21st century infrastructure.
“The government’s goal is to deploy fibre-to-the-premises to 87 per cent of the country by 2022, so far they are ahead of schedule having reached 87 per cent of their goal.
“I encourage all businesses and families to check out their ability to access ultra-fast broadband and see for themselves how everyday tasks like watching a movie or doing their accounts can be made so much easier.
“The challenge now is for more Wellington businesses to adopt faster broadband and the advantages it brings.
“Wellington is home to an exciting mix of online companies and start-ups. Having innovative companies so close to their new customers will push further development.”
Content Sourced from scoop.co.nz
Original url


Watch anything, anywhere you go!
Imprisoned, the mighty Thor finds himself in a lethal gladiatorial contest against the Hulk, his former ally. Thor must fight for survival and race against time to prevent
the all-powerful Hela from destroying his home and the Asgardian civilization.
Kesto 2:26 min
Julkaisupäivä: 3.11.2017
A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.
Kesto 2:18 min
Julkaisupäivä: 23.7.2010
Earth's mightiest heroes must come together and learn to fight as a team if they are to stop the mischievous Loki and his alien army from enslaving humanity.
Kesto 2:04 min
Julkaisupäivä: 27.4.2012
When Tony Stark and Bruce Banner try to jump-start a dormant peacekeeping program called Ultron, things go horribly wrong and it's up to Earth's mightiest heroes to stop
the villainous Ultron from enacting his terrible plan.
Kesto 2:33 min
Julkaisupäivä: 22.4.2015
Steve Rogers, a rejected military soldier transforms into Captain America after taking a dose of a "Super-Soldier serum". But being Captain America comes at a price as he
attempts to take down a war monger and a terrorist organization.
Kesto 2:32 min
Julkaisupäivä: 26.3.2014
After being held captive in an Afghan cave, billionaire engineer Tony Stark creates a unique weaponized suit of armor to fight evil.
Kesto 2:29 min
Julkaisupäivä: 1.5.2008
With the world now aware of his identity as Iron Man, Tony Stark must contend with both his declining health and a vengeful mad man with ties to his father's legacy.
Kesto 2:57 min
Julkaisupäivä: 5.5.2010
When Tony Stark's world is torn apart by a formidable terrorist called the Mandarin, he starts an odyssey of rebuilding and retribution.
Kesto 2:44 min
Julkaisupäivä: 24.4.2013


Goes through the values in the iterator. Calls f for each these and if any of
them returns false this returns false (without checking the rest). If all
return true this will return true.
The function to call for
every element. This function
takes 3 arguments (the element, undefined, and the iterator) and should
return a boolean. If the return value is true the element will be
included in the returned iteror. If it is false the element is not
included.
opt_obj: T=
The object to be used as the value of 'this' within
f.
Returns
A new iterator in which only elements that
passed the test are present.
The iterator to iterate
over. If the iterable is an object toIterator will be
called on
it.
f: function(this: T, ?, ?, ?): ?
The function to call for every
element. This function
takes 3 arguments (the element, undefined, and the iterator) and the
return value is irrelevant. The reason for passing undefined as the
second argument is so that the same function can be used in
goog.array#forEach as well as others.
opt_obj: T=
The object to be used as the value of 'this' within
f.
Cartesian product of zero or more sets. Gives an iterator that gives every
combination of one element chosen from each set. For example,
([1, 2], [3, 4]) gives ([1, 3], [1, 4], [2, 3], [2, 4]).
The stop value if only one argument is provided.
The start value if 2 or more arguments are provided. If only one
argument is used the start value is 0.
The function to call for every
element. This function takes 2 arguments (the function's previous result
or the initial value, and the value of the current element).
function(previousValue, currentElement) : newValue.
val: V
The initial value to pass into the function on the first call.
opt_obj: T=
The object to be used as the value of 'this'
within f.
Returns
Result of evaluating f repeatedly across the values of
the iterator.
Goes through the values in the iterator. Calls f for each these and if any of
them returns true, this returns true (without checking the rest). If all
return false this will return false.
If the object is an iterator it
will be returned as is. If the object has a __iterator__
method
that will be called to get the value iterator. If the object is an
array-like object we create an iterator for that.
Returns
An iterator that knows how to iterate over the
values in iterable.


Take a look at the file /Scripts/itemsonloan/itemsonloan.js, and see how the itemsOnLoan module has a dependency to both ngRoute and itemsOnLoanFilters. The itemsOnLoanFilters module can be found in /Scripts/itemsonloan/filters.js. Can you see where on the page the custom filter created in this module is used?
Create another custom filter called numOnLoan in filters.js, which returns the number of items with the status 'On Loan'.
Add the logic needed in order to display the number of items on loan in the "Number of items on loan" column in the table to the left.
Click on the details links next to Sue. Right now all the borrowed items and the items on loan are shown in both boxes. Can you make the borrowed items only display in the first box, and the items on loan only display in the second?
Can you make the Borrowed and On Loan boxes in the details view only display if they contain items?


The Maestro cometh
by Darren HandschuhThe God Father of Canadian hip hop is coming to Vernon.
Wes Williams, who is much better known by his rap name Maestro Fresh-Wes, is coming back to the Okanagan to help Saverio Loria celebrate his 60th birthday.
Williams was one of the first Canadian rappers to achieve mainstream success with 1989's smash hit Let Your Backbone Slide.
His 2017 album, Coach Fresh, was nominated for a Juno and Williams was recently inducted into the Canadian Songwriters' Hall of Fame.
He is also an author, actor and record producer.
Loria runs Status Night Club where Maestro will perform Saturday Nov. 30.
Doors open at 8:30 p.m. and tickets are $20 in advance or $25 at the door.
More information can be found online.


Making NDIToolbox do more
NDIToolbox supports the execution of plugins, additional bits of code that can be loaded to extend its functionality. Here we'll discuss what a plugin is and how to use one.
In a nutshell, a plugin is an extra bit of software that's designed to work with NDIToolbox and extend its functionality. For the most part, plugins in NDIToolbox tend to be small programs - they usually do one thing and one thing only, and they usually do not have a separate user interface. The idea is to have a simple program that receives NDE data and configuration info; performs some sort of function on the data; then returns the results. NDIToolbox worries about the details of how to read data and present it to the user.
If you're an end user, you can add plugins to your NDIToolbox installation to make the program work for your needs. If you're more of a developer, you can create your own plugins and share them with others.
All NDIToolbox plugins must be installed under your plugins folder, which is a subfolder of your NDIToolbox
local
files folder. Remember from the Quick Start guide that this folder will be under
your $HOME
folder (e.g. c:\users\chris
in Windows 7 or /home/chris
under
Linux).
Although you can copy a plugin directly to this folder manually, we recommend using NDIToolbox to install your plugins since NDIToolbox will ensure that the plugin is properly structured. From any Plot window, select Plugins from the Tools menu. If you already have a copy of the plugin as a ZIP archive, choose Install Plugin... and select the ZIP to install. The Install Plugin window will pop up, from which you can get more information about the plugin by pressing the About Plugin... button.
If the ZIP archive has been password-protected, make sure the Protected check box is checked and provide the password you were given by the plugin's author. When ready to install, click OK to proceed. NDIToolbox will unpack the ZIP archive and install the plugin in your local files folder. If the plugin doesn't seem to be a proper NDIToolbox plugin, NDIToolbox will abort installation and notify you of the situation.
NDIToolbox can also automatically download and install plugins, for example if you're installing a commercial plugin. The installation procedure is nearly the same as for installing a plugin you've already got locally, but from the Tools menu select Download Plugin... and fill in the Install Plugin window that appears. Among other things, you'll need the full URL to the plugin; if the server hosting the plugin download requires a login you can specify a username and password in this window as well. As is the case with installing a local plugin, if the plugin archive is password-protected you should enter the password in this window.
Once a plugin has been successfully installed, you can run it simply by selecting it from the list of plugins. Under the Tools menu, select the Plugins submenu, then click the name of the plugin you wish to execute.
If a plugin requires extra information from you before executing, it will open a new window asking for the input. For example, NDIToolbox includes a median filter plugin that when run asks you to specify the rank (also known as the window length or kernel size) of the filter as shown below. In this example, the user is instructing the median filter plugin to run a filter of rank 3 on the data.
When a plugin is run, NDIToolbox passes it a copy of the current data set displayed in the plot window. The plugin performs its function on this data and returns it to NDIToolbox, which then updates the plot window with the results. Going back to the median filter plugin, here's an example of the results of applying this plugin against an ultrasonic C-scan. The image on the left is the original C-scan image plot; on the right is the resulting C-scan after a median filter of rank 5 has been applied.
Since NDIToolbox keeps a copy of the original data, you can always reverse any changes a plugin makes to your data by selecting Revert To Original from the plot window's Operations menu. The original data will be reloaded and the changes made by the plugin will be discarded.


IgeEngine CLASS
Declared in IgeEngine.js
The base engine class definition.
Methods
$
Returns an object from the engine's object register by the object's id. If the item passed is not a string id then the item is returned as is. If no item is passed the engine itself is returned.
$({String || Object} item)
- {String || Object}item The id of the item to return, or if an object, returns the object as-is.
$$
Returns an array of all objects that have been assigned the passed category name.
$$({String} categoryName)
- {String}categoryName The name of the category to return all objects for.
$$$
Returns an array of all objects that have been assigned the passed group name.
$$$({String} groupName)
- {String}groupName The name of the group to return all objects for.
register
Register an object with the engine object register. The register allows you to access an object by it's id with a call to ige.$(objectId).
register({Object} obj)
- {Object}obj The object to register.
Returns {*}
unRegister
Un-register an object with the engine object register. The object will no longer be accessible via ige.$().
unRegister({Object} obj)
- {Object}obj The object to un-register.
Returns {*}
categoryRegister
Register an object with the engine category register. The register allows you to access an object by it's category with a call to ige.$$(categoryName).
categoryRegister({Object} obj)
- {Object}obj The object to register.
Returns {*}
categoryUnRegister
Un-register an object with the engine category register. The object will no longer be accessible via ige.$$().
categoryUnRegister({Object} obj)
- {Object}obj The object to un-register.
Returns {*}
groupRegister
Register an object with the engine group register. The register allows you to access an object by it's groups with a call to ige.$$$(groupName).
groupRegister({Object} obj, {String} groupName)
- {Object}obj The object to register.
- {String}groupName The name of the group to register the object in.
Returns {*}
groupUnRegister
Un-register an object with the engine group register. The object will no longer be accessible via ige.$$$().
groupUnRegister({Object} obj, {String} groupName)
- {Object}obj The object to un-register.
- {String}groupName The name of the group to un-register the object from.
Returns {*}
requireScript
Load a js script file into memory via a path or url.
requireScript({String} url, {Function} callback)
- {String}url The file's path or url.
- {Function}callback Optional callback when script loads.
_requireScriptLoaded
Called when a js script has been loaded via the requireScript method.
_requireScriptLoaded({Element} elem)
- {Element}elem The script element added to the DOM.
requireStylesheet
Load a css style file into memory via a path or url.
requireStylesheet({String} url)
- {String}url The file's path or url.
addGraph
Adds a scenegraph class into memory.
addGraph({String} className, {Object} options)
- {String}className The name of the scenegraph class.
- {Object}options Optional object to pass to the scenegraph class graph() method.
Returns {*}
removeGraph
Removes a scenegraph class into memory.
removeGraph({String} className, {Object} options)
- {String}className The name of the scenegraph class.
- {Object}options Optional object to pass to the scenegraph class graph() method.
Returns {*}
enableUpdates
Allows the update() methods of the entire scenegraph to be temporarily enabled or disabled. Useful for debugging.
enableUpdates({Boolean} val)
- {Boolean}val If false, will disable all update() calls.
Returns {*}
enableRenders
Allows the tick() methods of the entire scenegraph to be temporarily enabled or disabled. Useful for debugging.
enableRenders({Boolean} val)
- {Boolean}val If false, will disable all tick() calls.
Returns {*}
debugEnabled
Enables or disables the engine's debug mode. Enabled by default.
debugEnabled({Boolean} val)
- {Boolean}val If true, will enable debug mode.
Returns {*}
debugTiming
Enables or disables the engine's debug timing system. The timing system will time all update and rendering code down the scenegraph and is useful for tracking long-running code but comes with a small performance penalty when enabled. Enabled by default.
debugTiming({Boolean} val)
- {Boolean}val If true, will enable debug timing mode.
Returns {*}
hideAllExcept
Sets the opacity of every object on the scenegraph to zero *except* the one specified by the given id argument.
hideAllExcept({String} id)
- {String}id The id of the object not to hide.
showAll
Calls the show() method for every object on the scenegraph.
showAll()
setFps
Sets the frame rate at which new engine steps are fired. Setting this rate will override the default requestAnimFrame() method as defined in IgeBase.js and on the client-side, will stop usage of any available requestAnimationFrame() method and will use a setTimeout()-based version instead.
setFps({Number} fpsRate)
defineClass
Defines a class in the engine's class repository.
defineClass({String} id, {Object} obj)
- {String}id The unique class ID or name.
- {Object}obj The class definition.
getClass
Retrieves a class by it's ID that was defined with a call to defineClass().
getClass({String} id)
- {String}id The ID of the class to retrieve.
Returns {Object} The class definition.
classDefined
Returns true if the class specified has been defined.
classDefined({String} id)
- {String}id The ID of the class to check for.
Returns {*}
newClassInstance
Generates a new instance of a class defined with a call to the defineClass() method. Passes the options parameter to the new class during it's constructor call.
newClassInstance({} id, {} options)
Returns {*}
dependencyCheck
Checks if all engine start dependencies have been satisfied.
dependencyCheck()
Returns {Boolean}
viewportDepth
Gets / sets the flag that determines if viewports should be sorted by depth like regular entities, before they are processed for rendering each frame. Depth-sorting viewports increases processing requirements so if you do not need to stack viewports in a particular order, keep this flag false.
viewportDepth({Boolean} val)
Returns {Boolean}
dependencyTimeout
Sets the number of milliseconds before the engine gives up waiting for dependencies to be satisfied and cancels the startup procedure.
dependencyTimeout({} val)
updateProgress
Updates the loading screen DOM elements to show the update progress.
updateProgress()
textureLoadStart
Adds one to the number of textures currently loading.
textureLoadStart()
textureLoadEnd
Subtracts one from the number of textures currently loading and if no more need to load, it will also call the _allTexturesLoaded() method.
textureLoadEnd()
textureFromUrl
Returns a texture from the texture store by it's url.
textureFromUrl({String} url)
Returns {IgeTexture}
texturesLoaded
Checks if all textures have finished loading and returns true if so.
texturesLoaded()
Returns {Boolean}
_allTexturesLoaded
Emits the "texturesLoaded" event.
_allTexturesLoaded()
globalSmoothing
Gets / sets the default smoothing value for all new IgeTexture class instances. If set to true, all newly created textures will have smoothing enabled by default.
globalSmoothing({} val)
Returns {*}
canvasReady
Checks to ensure that a canvas has been assigned to the engine or that the engine is in server mode.
canvasReady()
Returns {Boolean}
newId
Generates a new unique ID
newId()
Returns {String}
newIdHex
Generates a new 16-character hexadecimal unique ID
newIdHex()
Returns {String}
newIdFromString
Generates a new 16-character hexadecimal ID based on the passed string. Will always generate the same ID for the same string.
newIdFromString({String} str)
- {String}str A string to generate the ID from.
Returns {String}
start
Starts the engine.
start({} callback)
stop
Stops the engine.
stop()
Returns {Boolean}
autoSize
Gets / sets the _autoSize property. If set to true, the engine will listen for any change in screen size and resize the front-buffer (canvas) element to match the new screen size.
autoSize({} val)
Returns {Boolean}
renderContext
Gets / sets the rendering context that will be used when getting the context from canvas elements.
renderContext({String} contextId)
- {String}contextId The context such as '2d'. Defaults to '2d'.
Returns {*}
createFrontBuffer
Creates a front-buffer or "drawing surface" for the renderer.
createFrontBuffer({Boolean} autoSize, {Boolean} dontScale)
- {Boolean}autoSize Determines if the canvas will auto-resize when the browser window changes dimensions. If true the canvas will automatically fill the window when it is resized.
- {Boolean}dontScale If set to true, IGE will ignore device pixel ratios when setting the width and height of the canvas and will therefore not take into account "retina", high-definition displays or those whose pixel ratio is different from 1 to 1.
canvas
Sets the canvas element that will be used as the front-buffer.
canvas({} elem, {} autoSize)
- {}elem The canvas element.
- {}autoSize If set to true, the engine will automatically size the canvas to the width and height of the window upon window resize.
clearCanvas
Clears the entire canvas.
clearCanvas()
removeCanvas
Removes the engine's canvas from the DOM.
removeCanvas()
openUrl
Opens a new window to the specified url. When running in a native wrapper, will load the url in place of any existing page being displayed in the native web view.
openUrl({} url)
showWebView
Loads the specified URL as an HTML overlay on top of the front buffer in an iFrame. If running in a native wrapper, will load the url in place of any existing page being displayed in the native web view. When the overlay is in use, no mouse or touch events will be fired on the front buffer. Once you are finished with the overlay, call hideOverlay() to re-enable interaction with the front buffer.
showWebView({String} url)
hideWebView
Hides the web view overlay.
hideWebView()
Returns {*}
layerCall
Evaluates javascript sent from another frame.
layerCall({} js)
mousePos
Returns the mouse position relative to the main front buffer. Mouse position is set by the ige.input component (IgeInputComponent)
mousePos()
Returns {IgePoint3d}
mouseOverList
Walks the scenegraph and returns an array of all entities that the mouse is currently over, ordered by their draw order from drawn last (above other entities) to first (underneath other entities).
mouseOverList()
_resizeEvent
Handles the screen resize event.
_resizeEvent({} event)
_canvasPosition
Gets the bounding rectangle for the HTML canvas element being used as the front buffer for the engine. Uses DOM methods.
_canvasPosition()
Returns {ClientRect}
toggleFullScreen
Toggles full-screen output of the main ige canvas. Only works if called from within a user-generated HTML event listener.
toggleFullScreen()
watchStart
Adds a new watch expression to the watch list which will be displayed in the stats overlay during a call to _statsTick().
watchStart({*} evalStringOrObject)
- {*}evalStringOrObject The expression to evaluate and display the result of in the stats overlay, or an object that contains a "value" property.
Returns {Integer} The index of the new watch expression you just added to the watch array.
watchStop
Removes a watch expression by it's array index.
watchStop({Number} index)
- {Number}index The index of the watch expression to remove from the watch array.
traceSet
Sets a trace up on the setter of the passed object's specified property. When the property is set by any code the debugger line is activated and code execution will be paused allowing you to step through code or examine the call stack to see where the property set originated.
traceSet({Object} obj, {String} propName, {Number} sampleCount, {Function} callbackEvaluator)
- {Object}obj The object whose property you want to trace.
- {String}propName The name of the property you want to put the trace on.
- {Number}sampleCount The number of times you want the trace to break with the debugger line before automatically switching off the trace.
- {Function}callbackEvaluator Optional callback that if returns true, will fire debugger. Method is passed the setter value as first argument.
traceSetOff
Turns off a trace that was created by calling traceSet.
traceSetOff({Object} object, {String} propName)
- {Object}object The object whose property you want to disable a trace against.
- {String}propName The name of the property you want to disable the trace for.
findBaseClass
Finds the first Ige* based class that the passed object has been derived from.
findBaseClass({} obj)
Returns {*}
getClassDerivedList
Returns an array of all classes the passed object derives from in order from current to base.
getClassDerivedList({} obj, {} arr)
Returns {*}
_secondTick
Is called every second and does things like calculate the current FPS.
_secondTick()
timeScale
Gets / sets the current time scalar value. The engine's internal time is multiplied by this value and it's default is 1. You can set it to 0.5 to slow down time by half or 1.5 to speed up time by half. Currently will not accept a negative value.
timeScale({Number} val)
- {Number}val The time scale value.
Returns {*}
incrementTime
Increments the engine's interal time by the passed number of milliseconds.
incrementTime({Number} val, {Number} lastVal)
- {Number}val The number of milliseconds to increment time by.
- {Number}lastVal The last internal time value, used to calculate delta internally in the method.
Returns {Number}
currentTime
Get the current time from the engine.
currentTime()
Returns {Number} The current time.
pause
Gets / sets the pause flag. If set to true then the engine's internal time will no longer increment and will instead stay static.
pause({} val)
Returns {*}
useManualTicks
Gets / sets the option to determine if the engine should schedule it's own ticks or if you want to manually advance the engine by calling tick when you wish to.
useManualTicks({Boolean} val)
Returns {*}
manualTick
Schedules a manual tick.
manualTick()
useManualRender
Gets / sets the option to determine if the engine should render on every tick or wait for a manualRender() call.
useManualRender({Boolean} val)
- {Boolean}val True to enable manual rendering, false to disable.
Returns {*}
manualRender
Manually render a frame on demand. This is used in conjunction with the ige.useManualRender(true) call which will cause the engine to only render new graphics frames from the scenegraph once this method is called. You must call this method every time you wish to update the graphical output on screen. Calling this method multiple times during a single engine tick will NOT make it draw more than one frame, therefore it is safe to call multiple times if required by different sections of game logic without incurring extra rendering cost.
manualRender()
engineStep
Called each frame to traverse and render the scenegraph.
engineStep()
sceneGraph
Walks the scene graph and outputs a console map of the graph.
sceneGraph()
getSceneGraphData
Walks the scenegraph and returns a data object of the graph.
getSceneGraphData()


This is a trial web page documenting the Power-Z KM002C sold by ChargerLab . Obviously ChargerLab are based in China (or maybe Hong Kong) and the primary documentation is written in (simplified) Chinese. There is documentation in English about the KM002C tester itself (follow the ChargerLab link above then click the Power-Z tab) but to date there seems to be little English documentation of the accompanying Windows (7+) PC Software (hereafter called the app).
The purpose of this page is to collect information about the KM002C from the perspective of the app. Without feedback and additional information, this page will become stale and probably be removed. Feedback can be sent for those with GitHub accounts by adding Issues and/or Pull request to this project. Those without an account can use email to the address at the bottom of this document.
Here is a screenshot of the tester (hereafter called the dongle) from ChargerLab’s documentation:
Given that ChargerLab define the USB-C Male (Plug) as “in” then the positive sense of current is moving from “in” to “out”. So USB-C sources such as the Apple 140 Watt USB-C Power Supply (PS) with a USB-C receptacle mounted on the body of the PS will show positive current while power supplies with a captive cable with a male USB-C plug at the end of that cable will show negative currents.
When using the KM002C dongle in stand-alone mode then the HID connector can be connected to any USB source, as long as it can supply 100 milliAmps or more. The HID capability is only needed when controlling or monitoring the dongle with Windows 7+ app. When not using the app, a small USB-C power bank (i.e. battery) should be sufficient to power the dongle for long enough to do plenty of measurements with the dongle.
1. Rotate the display direction in the main menu
2. Back
3. Press and hold it when power off, you can enter the DFU mode
5 Confirm
1. Long press: Enter Settings
2. Short press: Confirm
6 Left
1. Switch four different interfaces in the main menu
2. Modify parameter values in the setting
7 Right
1. Switch four different interfaces in the main menu
2. Modify parameter values in the setting
3. Long press "Right" on startup when HID is disconnected to power (Flip the USB-C connector if it doesn't work)
Release CC pull-down resistor, it'll shut down after 5 seconds
Keep CC pull-down resistor, enter the charging protocol
Attention: Please use this function under the guidance of professionals, otherwise the short circuit caused by the CC1 and VBUS of the cable may damage the tester.
The above button description for the dongle is cut and paste from ChargerLab’s documentation. Noteworthy is the long press on the right button (7) when power initially flows between USB-C IN (1) and USB-C OUT (2). In that case the dongle will power itself from Vbus flowing between connector (1) and (2) . It is fun documenting this device since I’m pretty sure my KM002C did what was just described. Retesting the dongle with 1.5.0 firmware, the long press on the right button (7) does nothing at power-up. Now it seems that if there is no HID power, the dongle will automatically take power from Vbus passing between connector (1) and (2), if it is available.
Powering the dongle from the PD connection being monitored is not ideal. The reason is whenever the PD protocol passes through a state that drives Vbus to Vsafe0 then the dongle itself will reset. That can be very frustrating, so powering via the HUB connector (and _not_ doing a long press on the right button (7) during power-up) is recommended. Also recommended is fitting a right-angle USB-C adapter (male to female) to the HID connector (3) so, as shown in some ChargerLab videos, the dongle can be held in one hand with the HID connector at the bottom with your thumb on the right angle USB-C adapter, that will leave your fingers (relatively) free to press the 4 control buttons which should now be facing upwards. [The white glove, as used by ChargeLab, is optional :-)]
Another issue with taking power from Vbus is that if Vbus is at or near 48 Volts a “low dropout (linear) regulator” (LD0) generating 3.3 Volts (say) for the dongle’s logic is going to generate a fair amount of heat. A better solution would be to use a switcher but not many USB-C testers do that.
The “Attention” warning is a bit of a worry. The CC and Vbus contacts in the USB-C plug (and receptacle) are adjacent one another so that during insertion and removal it is possible that a CC line touches Vbus momentarily passing up to 48 Volts down the CC line to the source and sink. In the Product specification for the KM002C ChargerLab state that the “Withstand Voltage of the CC1/2 Pins” is 50 Volts. Also one would hope that any well designed USB-C PS (i.e. a USB PD source) would have a withstand Voltage on its CC pins of at least its maximum advertised Vbus voltage. That leaves the USB PD sink device (assuming the dongle is in “monitor” mode) that may or may not have sufficient withstand Voltage on its CC pins. So that “Attention” might be about taking care with any USB-C device (most likely PD sinks) that do not make any statement about the CC withstand Voltage capability.
A more serious warning in ChargerLab’s documentation is that the dongle does not have reverse voltage protection. So a (malicious) cable, or USB-C connector breakout board, that swaps Vbus and ground could destroy the KM002C. A large diode that can withstand a reverse bias of 55 Volts, connected externally, should protect the KM002C if there is a risk of polarity reversal.
Below is a rendering of the app when it detects the dongle is connected to a USB-A or USB-C port of the computer hosting the app. If it appears with Chinese script then left click on the down triangle button (circled roughly in orange, near the top right) and pick the third item, then select English. While discussing that pull-down menu the second item (which appears on my system in Chinese, even after English has been selected) can be used to update the app’s software (i.e. the app not the dongle’s firmware). Another simple change is the name of the “real-time timing chart” which is the default name that I have changed to “chart” and has a light brown circle around it. The reason is that Chinese has a much larger alphabet than English and can render that longer name without overwriting the adjacent tabs (“temp” and “Charge” in this case). Left clicking on that field (i.e. the one that now has “chart” in it) will cause a box to pop-up into which the new field name can be placed.
Yyyyyyy
zzzzzzz
xxxxx
yyyyyy
There is more to follow.
Email address: dgilbert at interlog dot com
Last update: 5 October 2022, 09:45 +2


$eacLink
Find & Connect - New South Wales consists of 1,347 entries with references to 699 publications, and 465 gallery.
| Archival Collections | 57 entities | |
| Archival Items | 11 entities | |
| Archival Series | 350 entities | |
| Contact Details | 71 entities | |
| Events | 14 entities | |
| Glossary Terms | 99 entities | |
| Legislation | 36 entities | |
| Organisations | 697 entities | |
| People | 4 entities | |
| Places | 7 entities | |
| Projects | 1 entity | |
| Categories | 73 descriptors | |
| Gallery | 465 items | |
| Publications | 698 citations | |
| 0 holdings |