Contiguous The simplest datatype constructor is MPI_TYPE_CONTIGUOUS which allows replication of a datatype into contiguous locations.
MPI_TYPE_CONTIGUOUS(count, oldtype, newtype)
[ IN count] replication count (nonnegative integer)
[ IN oldtype] old datatype (handle)
[ OUT newtype] new datatype (handle)
int MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype *newtype)
MPI_TYPE_CONTIGUOUS(COUNT, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, OLDTYPE, NEWTYPE, IERROR
newtype is the datatype obtained by concatenating count copies of oldtype. Concatenation is defined using extent as the size of the concatenated copies.
Example
Let oldtype have type map
with extent 16,
and let
. The type map of
the datatype returned by newtype is
i.e., alternating double and char elements, with displacements 0, 8, 16, 24, 32, 40.
In general, assume that the type map of oldtype is
with extent ex. Then newtype has a type map with entries defined by:
Vector The function MPI_TYPE_VECTOR is a more general constructor that allows replication of a datatype into locations that consist of equally spaced blocks. Each block is obtained by concatenating the same number of copies of the old datatype. The spacing between blocks is a multiple of the extent of the old datatype.
MPI_TYPE_VECTOR( count, blocklength, stride, oldtype,
newtype)
[ IN count] number of blocks (nonnegative integer)
[ IN blocklength] number of elements in each block
(nonnegative integer)
[ IN stride] number of elements between start of each block (integer)
[ IN oldtype] old datatype (handle)
[ OUT newtype] new datatype (handle)
int MPI_Type_vector(int count, int blocklength, int stride, MPI_Datatype oldtype, MPI_Datatype *newtype)
MPI_TYPE_VECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR
Example
Assume, again, that oldtype has type map
with extent 16.
A call to MPI_TYPE_VECTOR( 2, 3, 4, oldtype, newtype) will
create the datatype with type map,
That is, two blocks with three copies each of the old type, with a stride of 4 elements ( bytes) between the blocks.
Example
A call to MPI_TYPE_VECTOR(3, 1, -2, oldtype, newtype) will create
the datatype,
In general, assume that oldtype has type map,
with extent ex. Let bl be the blocklength. The newly created datatype has a type map with
entries:
A call to MPI_TYPE_CONTIGUOUS(count, oldtype, newtype) is equivalent to a call to MPI_TYPE_VECTOR(count, 1, 1, oldtype, newtype), or to a call to MPI_TYPE_VECTOR(1, count, n, oldtype, newtype), n arbitrary.
Hvector The function MPI_TYPE_HVECTOR is identical to MPI_TYPE_VECTOR, except that stride is given in bytes, rather than in elements. The use for both types of vector constructors is illustrated in Sec. Examples . ( H stands for ``heterogeneous'').
MPI_TYPE_HVECTOR( count, blocklength, stride,
oldtype, newtype)
[ IN count] number of blocks (nonnegative integer)
[ IN blocklength] number of elements in each block
(nonnegative integer)
[ IN stride] number of bytes between start of each block (integer)
[ IN oldtype] old datatype (handle)
[ OUT newtype] new datatype (handle)
int MPI_Type_hvector(int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype *newtype)
MPI_TYPE_HVECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR
Assume that oldtype has type map,
with extent ex. Let bl be the blocklength. The newly created datatype has a type map with
entries:
Indexed The function MPI_TYPE_INDEXED allows replication of an old datatype into a sequence of blocks (each block is a concatenation of the old datatype), where each block can contain a different number of copies and have a different displacement. All block displacements are multiples of the old type extent.
MPI_TYPE_INDEXED( count, array_of_blocklengths,
array_of_displacements, oldtype, newtype)
[ IN count] number of blocks -- also number of entries in
array_of_displacements and
array_of_blocklengths (nonnegative integer)
[ IN array_of_blocklengths] number of elements per block
(array of nonnegative integers)
[ IN array_of_displacements] displacement for each block,
in multiples of oldtype extent (array of integer)
[ IN oldtype] old datatype (handle)
[ OUT newtype] new datatype (handle)
int MPI_Type_indexed(int count, int *array_of_blocklengths, int *array_of_displacements, MPI_Datatype oldtype, MPI_Datatype *newtype)
MPI_TYPE_INDEXED(COUNT, ARRAY_OF_BLOCKLENGTHS, ARRAY_OF_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, ARRAY_OF_BLOCKLENGTHS(*), ARRAY_OF_DISPLACEMENTS(*), OLDTYPE, NEWTYPE, IERROR
Example
Let oldtype have type map with extent 16. Let B = (3, 1) and let D = (4, 0). A call to MPI_TYPE_INDEXED(2, B, D, oldtype, newtype) returns a datatype with type map,
That is, three copies of the old type starting at displacement 64, and one copy starting at displacement 0.
In general, assume that oldtype has type map,
with extent ex.
Let B be the array_of_blocklength argument and
D be the
array_of_displacements argument. The newly created datatype
has
entries:
A call to MPI_TYPE_VECTOR(count, blocklength, stride, oldtype, newtype) is equivalent to a call to MPI_TYPE_INDEXED(count, B, D, oldtype, newtype) where
and
Hindexed The function MPI_TYPE_HINDEXED is identical to MPI_TYPE_INDEXED, except that block displacements in array_of_displacements are specified in bytes, rather than in multiples of the oldtype extent.
MPI_TYPE_HINDEXED( count, array_of_blocklengths,
array_of_displacements, oldtype, newtype)
[ IN count] number of blocks -- also number of entries in
array_of_displacements and
array_of_blocklengths (integer)
[ IN array_of_blocklengths] number of elements in each block
(array of nonnegative integers)
[ IN array_of_displacements] byte displacement of each block
(array of integer)
[ IN oldtype] old datatype (handle)
[ OUT newtype] new datatype (handle)
int MPI_Type_hindexed(int count, int *array_of_blocklengths, MPI_Aint *array_of_displacements, MPI_Datatype oldtype, MPI_Datatype *newtype)
MPI_TYPE_HINDEXED(COUNT, ARRAY_OF_BLOCKLENGTHS, ARRAY_OF_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, ARRAY_OF_BLOCKLENGTHS(*), ARRAY_OF_DISPLACEMENTS(*), OLDTYPE, NEWTYPE, IERROR
Assume that oldtype has type map,
with extent ex.
Let B be the array_of_blocklength argument and
D be the
array_of_displacements argument. The newly created datatype
has a type map with
entries:
Struct MPI_TYPE_STRUCT is the most general type constructor. It further generalizes the previous one in that it allows each block to consist of replications of different datatypes.
MPI_TYPE_STRUCT(count, array_of_blocklengths,
array_of_displacements, array_of_types, newtype)
[ IN count] number of blocks (integer) -- also number of
entries in arrays array_of_types,
array_of_displacements and array_of_blocklengths
[ IN array_of_blocklength] number of elements in each block
(array of integer)
[ IN array_of_displacements] byte displacement of each block
(array of integer)
[ IN array_of_types] type of elements in each block (array
of handles to datatype objects)
[ OUT newtype] new datatype (handle)
int MPI_Type_struct(int count, int *array_of_blocklengths, MPI_Aint *array_of_displacements, MPI_Datatype *array_of_types, MPI_Datatype *newtype)
MPI_TYPE_STRUCT(COUNT, ARRAY_OF_BLOCKLENGTHS, ARRAY_OF_DISPLACEMENTS, ARRAY_OF_TYPES, NEWTYPE, IERROR)
INTEGER COUNT, ARRAY_OF_BLOCKLENGTHS(*), ARRAY_OF_DISPLACEMENTS(*), ARRAY_OF_TYPES(*), NEWTYPE, IERROR
Example
Let type1 have type map,
with extent 16. Let B = (2, 1, 3), D = (0, 16, 26), and T = (MPI_FLOAT, type1, MPI_CHAR). Then a call to MPI_TYPE_STRUCT(3, B, D, T, newtype) returns a datatype with type map,
That is, two copies of MPI_FLOAT starting at 0, followed by one copy of type1 starting at 16, followed by three copies of MPI_CHAR, starting at 26. (We assume that a float occupies four bytes.)
In general, let T be the array_of_types argument, where T[i] is a handle to,
with extent exi. Let B be the array_of_blocklength argument and D be the array_of_displacements argument.Let c be the count argument. Then the newly created datatype has a type map with
entries:
A call to MPI_TYPE_HINDEXED( count, B, D, oldtype, newtype) is equivalent to a call to MPI_TYPE_STRUCT( count, B, D, T, newtype), where each entry of T is equal to oldtype.


Rule 1—"No melodic line may span more than octave(s)"
Rule 4—"A melodic skip of a major or minor seventh is forbidden because this is a dissonant* melodic interval"
Rule 5—"Any melodic skip, i.e., a melodic movement of a minor third or more, must be followed by a tone repeat or by a stepwise motion with or without a change in direction. A stepwise motion is a minor or major second."
Rule 6—"No more than one successive repeat of a given note is permitted."
*According to one historical interpretation of the concept of consonance/dissonance.
Piano Roll Zoom: Speed:


Download Logo Assets
Layer5
The Layer5 mark includes the Layer5 name & logo, and any word, phrase, image, or other designation that identifies the source or origin of any Layer5 projects. Please don’t modify the marks or use them in a confusing way, including suggesting sponsorship or endorsement by Layer5, or in a way that confuses Layer5 with another brand (including your own).
Colors
Our community color palette consists of gray, green and colors representing each of our projects.
The Layer5 logo should be white when using project colors as the background.
Print
For use on printed media:
Bookmarks
Media available for print in the form of bookmarks.
Download Logo Assets
Meshery
The Meshery mark includes the Meshery name & logo, and any word, phrase, image, or other designation that identifies the source or origin of any Layer5 projects. Please don’t modify the marks or use them in a confusing way, including suggesting sponsorship or endorsement by Layer5, or in a way that confuses Layer5 with another brand (including your own).
Colors
The Meshery color palette consists of the primary Meshery color and additional shades. The Meshery logo should be white or monochrome tonal when using a color background.
Web
For use online:
Meshery
#3c494f
RGB 60,73,79
CMYK 82,4,0,0
PMS 2995
Download Logo Assets
Image-Hub
The Image-Hub mark includes the Image-Hub name & logo, and any word, phrase, image, or other designation that identifies the source or origin of any Layer5 projects. Please don’t modify the marks or use them in a confusing way, including suggesting sponsorship or endorsement by Layer5, or in a way that confuses Layer5 with another brand (including your own).
Colors
The Image-Hub color palette consists of the primary Image-Hub color and additional shades. The Image-Hub logo should be white or monochrome tonal when using a color background.
Web
For use online:
Download Logo Assets
Service Mesh Performance
The Service Mesh Performance mark includes SMP name & logo and any word, phrase, image, or other designation that identifies the source or origin of any Layer5 projects. PLease don't modify the marks or use them in a confusing way, including suggesting sponsorship or endorsement by Layer5 with another brand(including your own)
Colors
The SMP color palette consists of gray, green and colors and additional shades.
The SMP logo should be white or monochrome when using project colors as the background.
Web
#00D3A9
#00B39F
#477E96
#647881
#3C494E
For use online:


What's New
Huawei Honor 4c White, also available in black
15 reviews
Huawei P9 32GB (Titanium Gray)
12 reviews
Huawei Nexus 6P 32GB LTE Grey Graphite and Silver Aluminium
31 reviews
Huawei Mate 8 64GB ROM+4GB RAM Dual SIM (Apricot and Mocha Gold)
20 reviews
Huawei Honor 5C 5.2" Octa-core Android 4G+ Phone w/ 2GB +16GB - Golden - Intl
18 reviews


Get a better browser you scrub!
But rlly for srsly your browser does not support HTML5, soooo it could really really use with updating


One of the most dangerous (and evil) things ever injected into
the project world is the notion of process maturity. Process maturity is for
replicable manufacturing contexts. Projects are one-time shots. Replicability is
never the primary issue on one-time shots. More evil than good has come from the
notion that we should "stick to the methodology." This is a recipe for
non-adaptive death.
-- David Schmaltz [
source]


You implement session caching with the HTTP Session Management Module for AppServers with a special filter, defined in the web.xml
, which is configured to intercept and wrap all requests.
You can use this HTTP module with a variety of application servers. Wrapping each request allows the interception of getSession()
calls to be handled by Geode instead of the native container. This approach is a generic solution, which is supported by any container that implements the Servlet 2.4 specification.
Setting Up the HTTP Module for AppServers
To use the module, you need to modify your application’s
web.xml
files. Configuration is slightly different depending on the topology you are setting up.Changing the Default Geode Configuration in the AppServers Module
By default, the AppServers module will run Geode automatically with preconfigured settings. You can change these Geode settings.


--- layout: post title: "Upgraded the site to use Angular.js" date: 2014-08-05 12:00:00 -0500 comments: false ---
The website is now rendered with Angular. Visually, this makes very little difference, but it should allow me to better write and manage my blog posts. For example, now, you can link to individual posts (which, before this post, post #2 was made, wasn't terribly hard either.)
I had originally tried to use Ember.js after taking the Warming up with Ember.js class from Code School, but I just had a hard time getting everything to flow. Specifically, I found the ng-route from Angular to be more intuitive than the routing mechanism Ember used. The two libraries seem functionally equivalent, but I think I'll stick with Angular for future projects.
Of course, dust hadn't even begun to settle on the new site before I learned about Polymer, which seems to be on the cutting edge of web technology, at least according to this summer's Google I/O talks.
I was specifically interested in the Shadow DOM techniques, for isolating element's CSS, and the modules, like code-explainer
, which is currently on their front page.
This looks very nice, similar to the code explanations I've been experimenting with in my earlier blog post. I may consider migrating my "codeCommentary" package to Polymer, as my next foray into Web technology.


Your file is now being built... Click here to download your file (may take a few moments). To export a report for a different timeframe, you can edit the url of this page to the required dates.


Windows binaries are kindly provided by Christoph Gohlke.
The latest stable release is also included as part of the Enthought Python Distribution (EPD), Python(x,y) and Anaconda.
On Debian and Ubuntu, a Debian package python-skimage can be found in the Neurodebian repository. Follow the instructions to add Neurodebian to your system package manager, then look for python-skimage in the package manager.
On systems that support setuptools, the package can be installed from the Python packaging index using
easy_install -U scikit-image
or
pip install -U scikit-image
Obtain the source from the git-repository at http://github.com/scikit-image/scikit-image by running:
git clone http://github.com/scikit-image/scikit-image.git
in a terminal (you will need to have git installed on your machine).
If you do not have git installed, you can also download a zipball from https://github.com/scikit-image/scikit-image/zipball/master.
The SciKit can be installed globally using:
python setup.py install
or locally using:
python setup.py install --prefix=${HOME}
If you prefer, you can use it without installing, by simply adding this path to your PYTHONPATH variable and compiling extensions in-place:
python setup.py build_ext -i
scikit-image can also be built using bento. Bento depends on WAF for compilation.
Follow the Bento installation instructions and download the WAF source.
Tell Bento where to find WAF by setting the WAFDIR environment variable:
export WAFDIR=<path/to/waf>
From the scikit-image source directory:
bentomaker configure
bentomaker build -j # (add -i for in-place build)
bentomaker install # (when not builing in-place)
Depending on file permissions, the install commands may need to be run as sudo.
Matplotlib >= 1.0 is needed to generate the examples in the documentation.
You can use pip to automatically install the base dependencies as follows:
$ pip install -r requirements.txt
On Windows, the error Error:unable to find vcvarsall.bat means that distutils is not correctly configured to use the C compiler. Modify (or create, if not existing) the configuration file distutils.cfg (located for example at C:\Python26\Lib\distutils\distutils.cfg) to contain:
[build]
compiler=mingw32
You can use this scikit with the basic requirements listed above, but some functionality is only available with the following installed:
A Python Unit Testing Framework
A tool that generates a unit test code coverage report


You can create models on the fly using dropOptions.provideRawDataModel handler. In this example, random fruit is created when you drag something in the container. Try dragging pieces of text from the page or files from the desktop and enjoy fruit decorated with your text.


HTML 5
1) <!Doctype html> is written so that the browser know the doctument has to be rendered according to the full standard mode decided by W3C for HTML ,CSS there are three modes:- quirks, almost standard and full standard as in starting the standard was for netscape browser and msft browser internet explorer.
2) Nowdays most of the browsers use full standard mode
3) <title>, <meta>
tags link for favicon and author name.
<title> will define title for the page that will be displayed on tab of browser and on bookmarks.
<meta charset="utf-8"> will let our web page containg all sort of characters available including all makor languages of the world.
<meta name="author" content="Chris Mills"> AUTHOR NAME
<meta name="description" content="The MDN Web Docs Learning Area aims to provide complete beginners to the Web with all they need to know to get started with developing web sites and applications."> for defining description that will also play role in SEO.
<link rel="shortcut icon" href="favicon.ico" type="image/x-icon"> for displaying favicon
<link rel="stylesheet" href="css/style.css">
 In Node.js, you normally execute code in modules. Therefore, the top-level scope is a special module scope: // `global` (not `window`) refers to global object: console.log(Math === global.Math); // true // `this` doesn’t refer to the global object: console.log(this !== global); // true // `this` refers to a module’s exports: console.log(this === module.exports); // true eval() can be called either directly (via a real function call) or indirectly (via some other means). The details are explained here. If eval() is called indirectly, this refers to the global object: > (0,eval)('this === window') true JS don't have block scope it's either local scope or global scope and if we don't define variable using var or let keyword it get s declared in global scope. For browser or for web developer per se the global scope is windows object and( global object for nodejs). setTimeout Variables are Executed in the Global Scope, this keyword used in setTimeout refers to the global object not to var object it is declared in Scope and closures JavaScript falls under the general category of "dynamic" or "interpreted" languages, it is in fact a compiled language. It is notcompiled well in advance, as are many traditionally-compiled languages, nor are the results of compilation portable among various distributed systems. Let's meet the cast of characters that interact to process the program var a = 2;, so we understand their conversations that we'll listen in on shortly: Engine: responsible for start-to-finish compilation and execution of our JavaScript program. Compiler: one of Engine's friends; handles all the dirty work of parsing and code-generation (see previous section). Scope: another friend of Engine; collects and maintains a look-up list of all the declared identifiers (variables), and enforces a strict set of rules as to how these are accessible to currently executing code. var a = 2;. The first thing Compiler will do with this program is perform lexing to break it down into tokens, which it will then parse into a tree. To summarize: two distinct actions are taken for a variable assignment: First, Compiler declares a variable (if not previously declared in the current scope), and second, when executing, Engine looks up the variable in Scopeand assigns to it, if found LHS and RHS lookup When I say: console.log( a ); The reference to a is an RHS reference, because nothing is being assigned to a here. Instead, we're looking-up to retrieve the value of a, so that the value can be passed to console.log(..). By contrast: a = 2; The reference to a here is an LHS reference, because we don't actually care what the current value is, we simply want to find the variable as a target for the = 2 assignment operation. Engine scope and compiler function foo(a) { console.log( a ); // 2 } foo( 2 ); Let's imagine the above exchange (which processes this code snippet) as a conversation. The conversation would go a little something like this: Engine: Hey Scope, I have an RHS reference for foo. Ever heard of it? Scope: Why yes, I have. Compiler declared it just a second ago. He's a function. Here you go. Engine: Great, thanks! OK, I'm executing foo. Engine: Hey, Scope, I've got an LHS reference for a, ever heard of it? Scope: Why yes, I have. Compiler declared it as a formal parameter to foo just recently. Here you go. Engine: Helpful as always, Scope. Thanks again. Now, time to assign 2 to a. Engine: Hey, Scope, sorry to bother you again. I need an RHS look-up for console. Ever heard of it? Scope: No problem, Engine, this is what I do all day. Yes, I've got console. He's built-in. Here ya go. Engine: Perfect. Looking up log(..). OK, great, it's a function. Engine: Yo, Scope. Can you help me out with an RHS reference to a. I think I remember it, but just want to double-check. Scope: You're right, Engine. Same guy, hasn't changed. Here ya go. Engine: Cool. Passing the value of a, which is 2, into log(..). If an RHS look-up fails to ever find a variable, anywhere in the nested Scopes, this results in a ReferenceError being thrown by the Engine. It's important to note that the error is of the type ReferenceError. By contrast, if the Engine is performing an LHS look-up and arrives at the top floor (global Scope) without finding it, and if the program is not running in "Strict Mode" [^note-strictmode], then the global Scopewill create a new variable of that name in the global scope, and hand it back to Engine. "No, there wasn't one before, but I was helpful and created one for you." "Strict Mode" [^note-strictmode], which was added in ES5, has a number of different behaviors from normal/relaxed/lazy mode. One such behavior is that it disallows the automatic/implicit global variable creation. In that case, there would be no global Scope'd variable to hand back from an LHS look-up, and Engine would throw a ReferenceError similarly to the RHS case. Now, if a variable is found for an RHS look-up, but you try to do something with its value that is impossible, such as trying to execute-as-function a non-function value, or reference a property on a null or undefined value, then Engine throws a different kind of error, called a TypeError. ReferenceError is Scoperesolution-failure related, whereas TypeError implies that Scoperesolution was successful, but that there was an illegal/impossible action attempted against the result Lexical scope is used in JS eval is used to cheat the lexical scope that states that first innermost scope will check and so on lastly the global scope And shadowing can also be done that is naming the same variable in different scopes function foo(str, a) { eval( str ); // cheating! console.log( a, b ); } var b = 2; foo( "var b = 3;", 1 ); // 1 3 function foo(str) { "use strict"; eval( str ); console.log( a ); // ReferenceError: a is not defined } foo( "var a = 2" with (keyword ) is other way of cheating lexical scope function foo(obj) { with (obj) { a = 2; } } var o1 = { a: 3 }; var o2 = { b: 3 }; foo( o1 ); console.log( o1.a ); // 2 foo( o2 ); console.log( o2.a ); // undefined console.log( a ); // 2 -- Oops, Lexical scope means that scope is defined by author-time decisions of where functions are declared JS compiler does 1) Lexing 2) parsing ( taking token and creating AST Abstract Syntax Tree) 3) Code-Generation: the process of taking an AST and turning it into executable code. function sayHello() { console.log("hello");};var func = sayHello; You are assigning the variable func a reference to the function sayHello, nota copy. Here, func is simply an alias to sayHello. Anything you do on the alias you will actually be doing on the original function. For example: func.answer = 42;console.log(sayHello.answer); // prints 42 Scopes have a lifetime When you call a function, you create a scope during the execution of that function. Then that scope goes away. When you call the function a second time, you create a new different scope during the second execution. Then this second scope goes away as well. function printA() { console.log(answer); var answer = 1;};printA(); // this creates a scope which gets discarded right afterprintA(); // this creates a new different scope which also gets discarded right after; Closures span multiple scopes When you define a function, a closure gets created Unlike scopes, closures are created when you define a function, not when you execute it. Closures also don’t go away after you execute that function. You can access the data in a closure long after a function is defined and after it gets executed as well. A closures encompasses everything the defined function can access. This means the defined function’s scope, and all the nested scopes between the global scope and the defined function scope plus the global scope itself. var G = 'G';// Define a function and create a closurefunction functionA() { var A = 'A' // Define a function and create a closure function functionB() { var B = 'B' console.log(A, B, G); } functionB(); // prints A, B, G // functionB closure does not get discarded A = 42; functionB(); // prints 42, B, G}functionA(); But the relation between scopes and closures is not always simple like this. Things become different when the defining and invoking of functions happen in different scopes. Let me explain that with an example: var v = 1;var f1 = function () { console.log(v);}var f2 = function() { var v = 2; f1(); // Will this print 1 or 2?};f2();
But the relation between scopes and closures is not always simple like this. Things become different when the defining and invoking of functions happen in different scopes. Let me explain that with an example: var v = 1;var f1 = function () { console.log(v);}var f2 = function() { var v = 2; f1(); // Will this print 1 or 2?};f2(); What do you think the above example will print? The code is simple, f1()prints the value of v, which is 1 on the global scope, but we execute f1()inside of f2(), which has a different vthat’s equal to 2. Then we execute f2(). Will this code print 1 or 2? If you’re tempted to say 2, you’ll be surprised. This code will actually print 1. The reason is, scopes and closures are different. The console.log line will use the closure of f1(), which is created when we define f1(), which means the closure of f1() gives us access to only the scope of f1() plus the global scope. The scope where we execute f1() does not affect that closure. In fact, the closure of f1() will not give us access to the scope of f2() at all. If you remove the global v variable and execute this code, you’ll get a reference error: var f1 = function () { console.log(v);}var f2 = function() { var v = 2; f1(); // ReferenceError: v is not defined};f2(); Since closures give us references to variables in scopes, the access that they give us means both read and write, not just read. // ReferenceError: funcName is not defined funcName(); // TypeError: undefined is not a function varName(); var varName = function funcName() { console.log("Definition not hoisted!"); }; As you can see, the function's name doesn't get hoisted if it is part of a function expression. A Tricky problem in JS // interviewer: what will the following code output?const arr = [10, 12, 15, 21];for (var i = 0; i < arr.length; i++) { setTimeout(function() { console.log('Index: ' + i + ', element: ' + arr[i]); }, 3000);} This question deals with the topics: closures, setTimeout, and scoping. The correct answer to this is question is: Index: 4, element: undefined(printed 4 times). setTimeout(function() {//code}, 1000) setInterval clearInterval(timeoutId) ; JavaScript is designed on a simple object-based paradigm. An object is a collection of properties, and a property is an association between a name (or key) and a value. A property's value can be a function, in which case the property is known as a method Unassigned properties of an object are undefined (and not null). However, any property name that is not a valid JavaScript identifier (for example, a property name that has a space or a hyphen, or that starts with a number) can only be accessed using the square bracket notation. JavaScript object property names (keys) can only be strings or Symbols You can also access properties by using a string value that is stored in a variable: var propertyName = 'make'; myCar[propertyName] = 'Ford'; Starting with ECMAScript 5, there are three native ways to list/traverse object properties: for...in loop Object.keys(o) Object.getOwnPropertyNames(o) To create new variable 1) use object initializers {s:2,p:3} 2) Using constructor function Car(make, model, year) { this.make = make; this.model = model; this.year = year; } var mycar = new Car('Eagle', 'Talon TSi', 1993); JavaScript is a prototype-based language, meaning object properties and methods can be shared through generalized objects that have the ability to be cloned and extended. This is known as prototypical inheritance and differs from class inheritance. let x = new Object(). The double square brackets that enclose [[Prototype]] signify that it is an internal property, and cannot be accessed directly in code. To find the [[Prototype]] of this newly created object, we will use the getPrototypeOf() method. Object.getPrototypeOf(x); JavaScript has a [[Prototype]] as it creates a way for any two or more objects to be linked. When you attempt to access a property or method of an object, JavaScript will first search on the object itself, and if it is not found, it will search the object's [[Prototype]]. If after consulting both the object and its [[Prototype]] still no match is found, JavaScript will check the prototype of the linked object, and continue searching until the end of the prototype chain is reached. When you attempt to access a property or method of an object, JavaScript will first search on the object itself, and if it is not found, it will search the object's [[Prototype]]. If after consulting both the object and its [[Prototype]] still no match is found, JavaScript will check the prototype of the linked object, and continue searching until the end of the prototype chain is reached. Introduction JavaScript is a prototype-based language, meaning object properties and methods can be shared through generalized objects that have the ability to be cloned and extended. This is known as prototypical inheritance and differs from class inheritance. Among popular object-oriented programming languages, JavaScript is relatively unique, as other prominent languages such as PHP, Python, and Java are class-based languages, which instead define classes as blueprints for objects. In this tutorial, we will learn what object prototypes are and how to use the constructor function to extend prototypes into new objects. We will also learn about inheritance and the prototype chain. JavaScript Prototypes In Understanding Objects in JavaScript, we went over the object data type, how to create an object, and how to access and modify object properties. Now we will learn how prototypes can be used to extend objects. Every object in JavaScript has an internal property called [[Prototype]]. We can demonstrate this by creating a new, empty object. let x = {}; This is the way we would normally create an object, but note that another way to accomplish this is with the object constructor: let x = new Object(). The double square brackets that enclose [[Prototype]] signify that it is an internal property, and cannot be accessed directly in code. To find the [[Prototype]] of this newly created object, we will use the getPrototypeOf() method. Object.getPrototypeOf(x); The output will consist of several built-in properties and methods. Output {constructor: ƒ, _defineGetter: ƒ, __defineSetter_: ƒ, …} Another way to find the [[Prototype]]is through the _proto_ property. _proto_ is a property that exposes the internal [[Prototype]] of an object. It is important to note that ._proto_is a legacy feature and should not be used in production code, and it is not present in every modern browser. However, we can use it throughout this article for demonstrative purposes. x._proto_; The output will be the same as if you had used getPrototypeOf(). Output {constructor: ƒ, _defineGetter: ƒ, __defineSetter_: ƒ, …} It is important that every object in JavaScript has a [[Prototype]] as it creates a way for any two or more objects to be linked. Objects that you create have a [[Prototype]], as do built-in objects, such as Date and Array. A reference can be made to this internal property from one object to another via the prototypeproperty, as we will see later in this tutorial. Prototype Inheritance When you attempt to access a property or method of an object, JavaScript will first search on the object itself, and if it is not found, it will search the object's [[Prototype]]. If after consulting both the object and its [[Prototype]] still no match is found, JavaScript will check the prototype of the linked object, and continue searching until the end of the prototype chain is reached. At the end of the prototype chain is Object.prototype. All objects inherit the properties and methods of Object. Any attempt to search beyond the end of the chain results in null. In our example, x is an empty object that inherits from Object. x can use any property or method that Object has, such as toString(). x.toString(); Output [object Object] This prototype chain is only one link long. x -> Object. We know this, because if we try to chain two [[Prototype]]properties together, it will be null. x._proto.proto_; Output null Let's look at another type of object. If you have experience Working with Arrays in JavaScript, you know they have many built-in methods, such as pop() and push(). The reason you have access to these methods when you create a new array is because any array you create has access to the properties and methods on the Array.prototype. We can test this by creating a new array. let y = []; Keep in mind that we could also write it as an array constructor, let y = new Array(). If we take a look at the [[Prototype]] of the new y array, we will see that it has more properties and methods than the xobject. It has inherited everything from Array.prototype. y._proto_; [constructor: ƒ, concat: ƒ, pop: ƒ, push: ƒ, …] This is the reason we can push and pop from the array y._proto_ === Array.prototype; // true y._proto.proto_ === Object.prototype; // true We can also use the isPrototypeOf()method to accomplish this. Array.prototype.isPrototypeOf(y); // true Object.prototype.isPrototypeOf(Array); // true We can use the instanceof operator to test whether the prototype property of a constructor appears anywhere within an object's prototype chain. y instanceof Array; // true To summarize, all JavaScript objects have a hidden, internal [[Prototype]]property (which may be exposed through _proto_ in some browsers). Objects can be extended and will inherit the properties and methods on [[Prototype]] of their constructor. These prototypes can be chained, and each additional object will inherit everything throughout the chain. The chain ends with the Object.prototype. We have seen some built-in JavaScript constructors, such as new Array() and new Date(), but we can also create our own custom templates from which to build new objects. // Add greet method to the Hero prototype Hero.prototype.greet = function () { return `${this.name} says hello.`; } function Point(x, y) { this.x = x; this.y = y; } Point.prototype = { dist: function () { return Math.sqrt((this.x*this.x)+(this.y*this.y)); }, toString: function () { return "("+this.x+", "+this.y+")"; } } We assign an object to Point.prototype, via an object initializer with two properties dist and toString. Now there is a clear separation of responsibility: The constructor is responsible for setting up instance-specific data, the prototype contains shared data (i.e., the methods). Note that prototypes are highly optimized in JavaScript engines, so there is usually no performance penalty for putting methods there. Methods are called just like before, you don’t notice whether they are stored in the instance or in the prototype To fix extend(), we must ensure that only own properties of source are considered. function extend(target, source) { for (var propName in source) { // Is propName an own property of source? if (source.hasOwnProperty(propName)) { // (1) target[propName] = source[propName]; } } return target; } There is one more problem: The above code fails if source has an own property whose name is “hasOwnProperty” [3]: var proto = { bla: true }; var obj = Object.create(proto); obj.foo = 123; obj.bar = "abc"; obj has both inherited and own properties: > obj.bla true > obj.foo 123 var obj = Object.create(proto, { foo: { value: 123 }, bar: { value: "abc" } }); Object.keys() const object1 = { a: 'somestring', b: 42, c: false }; console.log(Object.keys(object1)); // expected output: Array ["a", "b", "c"] language = { set current(name) { this.log.push(name); }, log: [] } language.current = 'EN'; language.current = 'FA'; console.log(language.log); // expected output: Array ["EN", "FA"] var obj = { log: ['a', 'b', 'c'], get latest() { if (this.log.length == 0) { return undefined; } return this.log[this.log.length - 1]; } } console.log(obj.latest); // expected output: "c" if (somethingBadHappened) { throw new Error('Something bad happened'); } Any value can be thrown: function throwIt(exception) { try { throw exception; } catch (e) { console.log('Caught: '+e); } } Array Array in JS are non homogeneous and non contiguous and the memory allocation is not together var array1 = [1, 4, 9, 16]; // pass a function to map const map1 = array1.map(x => x * 2); console.log(map1); // expected output: Array [2, 8, 18, 32] const array1 = [1, 2, 3, 4]; const reducer = (accumulator, currentValue) => accumulator + currentValue; // 1 + 2 + 3 + 4 console.log(array1.reduce(reducer)); // expected output: 10 // 5 + 1 + 2 + 3 + 4 console.log(array1.reduce(reducer, 5)); // expected output: 15 var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present']; const result = words.filter(word => word.length > 6); console.log(result); // expected output: Array ["exuberant", "destruction", "present"] var array1 = ['a', 'b', 'c']; array1.forEach(function(element) { console.log(element); }); // expected output: "a" // expected output: "b" // expected output: "c" var array1 = ['a', 'b', 'c']; Mutating array.push() and array.ushift(). array.pop() removes an item at the end of the array array.shift() removes an item at the beginning of the array. let mutatingRemove = ['a', 'b', 'c', 'd', 'e']; mutatingRemove.splice(0,2 ); // ['c', 'd', 'e'] array.splice() Non-Mutating array.concat() ... Spread operator // use const const arr1 = ['a', 'b', 'c', 'd', 'e']; const arr2 = arr1.filter(a => a !== 'e'); // ['a', 'b', 'c', 'd'] // OR const arr2 = arr1.filter(a => { return a !== 'e'; }); // ['a', 'b', 'c', 'd'] array.slice() takes two parameters. The first parameter is the index where the copy should begin. The second parameter is the index where the copy should end. This end index is non-inclusive. array.map To create a regular expression 1)var re = /ab+c/; //using enclosing slashes 2) var re = new RegExp('ab+c'); //using RegExp constructor match a single 'a' followed by zero or more 'b's followed by 'c', you'd use the pattern /ab*c Date Object let now = new Date(); // will display method call time date and time var today = new Date(); var birthday = new Date('December 17, 1995 03:24:00'); var birthday = new Date('1995-12-17T03:24:00'); var birthday = new Date(1995, 11, 17); var birthday = new Date(1995, 11, 17, 3, 24, 0); var date1 = new Date('December 17, 1995 03:24:00'); // Sun Dec 17 1995 03:24:00 GMT... var date2 = new Date('1995-12-17T03:24:00'); // Sun Dec 17 1995 03:24:00 GMT... console.log(date1 === date2); // expected output: false; console.log(date1 - date2); // expected output 0 JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language. JSON is built on two structures: A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array. An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence. Working with JSON parse stringify difference between objects and JSON -Sharing global variables between unrelated code is a big no-no in development. Modules are reusablw chunk of code in ES5 that we can reuse in any project and in the same project the dependency of one module should be very less on other modules. we can use closure based way of creating and using functions to avoid global namespacing pollution using var myGradesCalculate = (function () { // Keep this variable private inside this closure scope var myGrades = [93, 95, 88, 0, 55, 91]; var average = function() { var total = myGrades.reduce(function(accumulator, item) { return accumulator + item; }, 0); return'Your average grade is ' + total / myGrades.length + '.'; }; var failing = function() { var failingGrades = myGrades.filter(function(item) { return item < 70; }); return 'You failed ' + failingGrades.length + ' times.'; }; // Explicitly reveal public pointers to the private functions // that we want to reveal publicly return { average: average, failing: failing } })(); myGradesCalculate.failing(); // 'You failed 2 times.' myGradesCalculate.average(); // 'Your average grade is 70.33333333333333.' or ew can also use commonJS that works like NodeJs modeule approach. commonJS code function myModule() { this.hello = function() { return 'hello!'; } this.goodbye = function() { return 'goodbye!'; } } module.exports = myModule; There are two obvious benefits to this approach over the module patterns we discussed before: 1. Avoiding global namespace pollution 2. Making our dependencies explicit AMD CommonJS is all well and good, but what if we want to load modules asynchronously? The answer is called Asynchronous Module Definition, or AMD for short. Loading modules using AMD looks something like this: define(['myModule', 'myOtherModule'], function(myModule, myOtherModule) { console.log(myModule.hello()); }); Creating and using code using ES6 Modules // lib/counter.js var counter = 1; function increment() { counter++; } function decrement() { counter--; } module.exports = { counter: counter, increment: increment, decrement: decrement }; // src/main.js var counter = require('../../lib/counter'); counter.increment(); console.log(counter.counter); // 1 Module bundling What is module bundling? On a high level, module bundling is simply the process of stitching together a group of modules (and their dependencies) into a single file (or group of files) in the correct order. As with all aspects of web development, the devil is in the details. :) Why bundle modules at all? When you divide your program into modules, you typically organize those modules into different files and folders. Chances are, you’ll also have a group of modules for the libraries you’re using, like Underscore or React. As a result, each of those files has to be included in your main HTML file in a


Load these examples using an up to date Android mobile or tablet device, or a laptop with a webcam. Print out this target, load one of these examples, and point your camera at the target to overlay a BIM model on the real world! Click or touch an element to view it's BIM properties.
| Name | Github Account |
|---|---|
| Ana Garcia Puyol | anagpuyol |
| Benjamin Howes | bhowes-tt |
| Jaime Rosales Duque | jaimerosales |
| Scott Sorenson | ssorenson |
AugmentedBIM was prototyped at the 2015 AEC Techology Hackathon. It lets you overlay your BIM models on the real world - augmented reality for BIM models. The project is a mashup of a few existing open source technologies. It uses Spectacles to export BIM models from popular AEC authoring applications, and was forked off of this awesome project, which has figured out how to lay THREE.js models into an augmented reality workflow. AugmentedBIM is an open source project, Licensed with the MIT License. Please check out the source code here: github.com/anagpuyol/AugmentedBIM
Print out a marker at scale, tape it up in the right location on site, and use your tablet to review the BIM model overlayed on top of the in-process construction work.
Use AugmentedBIM to present design options to a client. Instead of making them imagine how a few options work work, take them on site and show them.
Want to know what a space will feel like? Print out a marker and find out!
Check out the project on github! github.com/anagpuyol/AugmentedBIM


Japer Speech Recognizer
powered by NeMo
Upload your .wav single-channel 16kHz file for transcription!
Rescore with ngram


Development
Predator-Prey was made in C++ using Qt Creator and Qt OpenGL. This project's world is inhabited by many different creatures:
- Prey - Generic creatures that do not hunt other creatures. They are instead the basis of all life in this world. They simply eat grass from the ground when they are hungry, and breed regularly.
- Predator - Generic predator that hunts prey creatures.
- Hunter - An apex predator. They hunt all creatures, even their own kind.
- Infected - A special creature that has its own rules. They do not hunger nor breed. Instead, they infect other creatures and assimilate them into their own kind. As a result, they tend to spread quite rapidly, only kept in check by Hunters.
Predator-Prey keeps track of the states of each creature in a specialized class that wraps a 2d array. At each step, it tells each creature that a time step has passed, and each creature performs its duties of move, eat, breed, and die.
Predator-Prey also keeps some useful stats, such as the number of each creature, as well as, the percentage of each creature population. It also lets you toggle on/off infections at any moment.
One of the more interesting parts of this project was balancing the inherent stats of each creature. This includes the time it takes to eat, breed, die, and their initial populations. Having one creature be too strong leads to them dominating the world, and if that creature was a predator of some kind, eventually leads to the collapse of the environment, as all of the prey die out. Thus, having a strong prey population is essential to the survival of the ecosystem. Also, ensuring that the infection rate isn't too high is essential. When you do achieve a balance, you end up with this wave-like pattern as the prey population shrinks and then expands, with the predator shrink and expansion just out of sync.


Laced Records Releasing Vinyl Version of ‘Gears 5’ Score
by Mike WilsonLaced Records have snagged another videogame soundtrack for a vinyl release, this one being Ramin Djawadi’s score for Gears 5! The set is up for pre-order right now, and will ship in February 2020.
The two-LP set features 18 tracks specifically mastered for vinyl, and features new artwork by UK based designer, Luke Preece. And like other Laced Records releases, the set also has a limited edition variant with transparent red and orange vinyl.
Gears 5 is available now on Xbox One and PC.


VOEIS is a YOGO Data Management Framework (YDMF) application. The YOGO framework is a
set of software tools developed at Montana State University for rapid assembly of data
management applications. The framework is database agnostic, and supports data versioning
and evolving schemas. As an added bonus, it's completely open source! Users interested in
learning more should check out the YOGO website:
http://yogo.msu.montana.edu
VOEIS
The Virtual Observatory and Ecological Informatics System (VOEIS) provides a framework for data
acquisition, analysis, model integration, and display of data products from completed workflows
including geo-spatially explicit models, graphs from statistical analyses, GIS displays of classified
ecological attributes on the landscape, and 3-D visualization models of waterscape and landscape
processes. VOEIS is a an operating system independent web application built with
Ruby on Rails on a
PostgreSQL backend. At the core of the
VOEIS is the VOEIS Data Hub, an application to enable coherent data management for data collected
from streaming sensor networks, generated from laboratory experiments on samples taken in the field,
and recorded from direct field observations. The VOEIS Data Hub is implemented using the YDMF, which
contributes significantly to the software in three specific ways: 1) rigorous authentication and
authorization requirements, 2) static data model support, and 3) import and export of data to external
data sources.
Vision: To develop and deploy an integrated sensor based ecological informatics system
through extensive collaborative research efforts between a consortium of academic entities in the
states of Montana and Kentucky. An integral part of our vision is understanding the greater concepts
and processes that govern the underlying informatics infrastructure and software.
Important Guiding Concepts
Data is a collection of typed values and associated meta-data
Data is organized according to a schema which determines relationships and multiplicities.
Raw data may come in many formats depending on the sensor equipment that is used.
Raw data can be parsed in order to get it into some format that implements a schema. Depending on the schema, loss of fidelity and semantics is possible.
After parsing, data and its associated meta-data becomes part of the main trunk.
A user can then work in a private sandbox. A private sandbox is in essence a branch of the main trunk with a private copy of the data.
Inside a sandbox, a user can tag the data by effecting changes to it. Changes can be as simple as manual datum changes to as complex as running low pass or high pass filters. Each change (filter) adds its own tag.
Tagged data can be merged back into the main trunk.
QA and QC is the process of overseeing that changes made to the main trunk (merged) are valid.
QA and QC processes can be manual or automated.
Tags can be kept in the metadata
Changes deemed invalid can be rolled back because they are tagged.
A data HUB is part of VOEIS. It is comprised of the tools that parse input sensor data (real time or manual) and the software that houses the data itself (HIS or otherwise).
In this section we capture descriptions of the requirements that guided the development of
VOEIS in plain english. These requirements were obtained from multiple sources, including
interviews with stakeholders, technical documents, etc. Note that some of these requirements
are very high level and multiple task decompositions are needed to refine and understand them better.
Stakeholder Requirements
GUI: Ability to see a map of a project
Ability to construct simple and complex queries to obtain earth science data at a given point in time and space
Ability to add information such as photos, links to other data, on-site physically collected data, monthly samples, etc. Basically, the ability to group data and to annotate individual datum or entire data sets with additional information that is not temporally or spatially located.
Support the generation of simple project activity and/or data reports
Development guidance from various documents
Scripting capabilities for QAQC
Ability to organize data for efficient dissemination
Interface for simulation models
Web based secured access to sensors and high performance visualization and simulation engines
APIs to tie into high performance computing
Data paths to facilitate routing of data to publication gateway(s)
Robust validation module for quality control. During QC, errors are corrected, data is annotated, and metadata is created
A robust data provenance module
A common format for storage and access via local, regional and global hubs. This is basically an interoperability requirement
Develop or leverage existing software to facilitate the transfer of data from field sensor arrays, data loggers and analytical equipment into central data servers
Develop or leverage software modules to allow access to data, manage data, provide authentication, etc.
Significance:
Researchers collect and analyze a wide variety of environmental data types, each with
unique formatting, preprocessing, and metadata requirements. This diversity often
creates a significant barrier to adoption of simple data management solutions. Effective
data management is critical to the success of any research project and the
National Science Foundation (NSF)
now requires funded researchers to implement data management plans. VOEIS fills
this need, stadardizing data formatting and providing a breadth of data management features
for storage, quality control, visualization, and publication for multiple
environmental data types. Intuitive and simple user interfaces greatly reduce the training time
required of researchers and lab group members for effective use of the
software. As an added bonus, users can integrate VOEIS into existing data-management workflows by
utilizing the suite of available APIs.
These APIs also offer a convenient mechanism for using VOEIS with third-party scientific workflow
software like Kepler. Original Conceptualizations:
Field Personnel and Activity Management and Tracking
Model Simulation Integration
High Level Architecture
VOEIS is implemented using the Yogo Framework with Ruby on Rails to take advantage of
the data management tools providing flexible schema management, RQL API, Role Based Access Controls (RBAC),
versioning, and support of multiple database back-ends making it platform independent. Currently the system uses
PostgreSQL as the backend storage system. Data processing has been optimized for PostgreSQL; however
generic implementations can make use of any DataMapper ORM supported backend such as MySQL, SQLite3,
Persevere, MongoDB, etc.
Data Model The VOEIS data model is a relational data model loosely based on the
CUAHSI HIS Observation Data Model (ODM). In fact, the original data model used in VOEIS
was the ODM. However, as the number and diversity of users expanded in VOEIS, it became
necessary to adjust the data model to accommodate a broader array of data types and use case
needs. Many of these unique user needs were expressed in the structure of the
Field Data Model (FDM), a data model created
by Geoffrey Poole and Clemente Izurieta at Montana State University. Thus began an effort to
meld the utility and simplicity of the ODM with the more expansive functionality required by
the FDM. The resulting data model should be familiar to users of the ODM, but boasts some unique
characteristics that improve its extensibility to incorporate new data types and provide a mechanism
for robust sample tracking, lab personnel tracking, and field sensor deployment tracking/management.
Standards
The importance of standard data formats during data publication is increasingly recognized.
Self-describing data formats like Water Markup Language (WaterML), Ecological Metadata Languange (EML),
and many others reduce errors in data interpretation by providing end-users with a recognizable data
format that includes the minimum amount and type of metadata deemed necessary to described a set of
data values. Data stored in VOEIS can be exported in .json or .xml formats. VOEIS users who want to publish data
in WaterML format must first publish thier data set to HydroServer using the HIS Gateway. The VOEIS
development team is currently working on proof of concept features for direct exports of data stored in VOEIS
using the WaterML and EML standards.
Controlled Vocabularies
Semantic heterogeneity occurs when data generaters within a single scientific domain use differnet terms
to descibe the same type of data. Adoption of recognized controlled vocabularies or domain ontologies
eliminates the ambiguity this behavior ultimately produces. VOEIS uses the
controlled vocabularies developed
by the CUAHSI HIS as the default setting for data projects. Users needing to alter these vocabularies
to satisfy their specific domain requirements may adjust these vocabularies on a project-by-
project basis. This increases the number of use-cases and scientific domains where VOEIS is applicable.
Programming Interface
The VOEIS Data Hub is designed to offer developers
programmatic access to data via RESTful APIs. The APIs
provide significant flexibility for users to create personalized
tools and views to interact with the data stored in
VOEIS. Access to API methods is role based and is
implemented using API keys that are linked to user accounts.
Thus, API access is managed in the same manner that regular
user access is handled. Further, the implementation of a
Resource Query Language (RQL) REST interface allows
dynamic data querying API functionality resembling SQL
database queries without the security risks and complication
inherent in exposing an SQL interface for a complex database
schema.
Feature #15309: Refactor Site Variable data browsing to provide 10 data points OR 24 hrs of data (the greater)
Development #15491: update new search
Version 1.3:
01/11/2012
New Features Summary:
History/Version/Provenance
Full tracking of edits with custom and generated provenance comments
Rollback to previous version for Site, Variables and Data
Multi-Site and Multi-Variable Search
Basic Controlled Vocabulary support including editing and provenance.
Revised graph on Variable tab to show last 24 hours of data.
Querying over Site data for a single Variable with graph output.
Searching over Site data for multiple Variables with parallel graphing.
CSV exporting for result set of both single and mulit-variable searches.
Foundational Data Set support.
Cleaned up and improved user interface.
Development Activity:
Feature #15174: Advanced Search/Browse
Feature #15175: Aggregate functions added to API calls
Feature #15223: Simple DataValue edit interface for single QA/QC
Feature #15226: Add select user access to DataSets
Feature #15230: Experimental Data Support
Development #14146: Data Search UI
Development #14147: Data Query UI
Development #15331: Add a "Small Data" option to API GET functions
Development #15332: After a new project is created indexes should be created for it
Version 1.2:
09/28/2011
Development Activity:
Feature #15222: Site Version/Provenance/History View
Feature #15224: DataSet creation
Feature #15253: Sample Drill Down
Development #14149: Data UI for a data grid browser
Development #15248: Speed up data search and API search
Development #15249: Change API update_site from PUT to POST
Version 1.1:
08/04/2011
Development Activity:
Bug #15125: Project Browse-- close project tab doesn't deselect project
Feature #15352: Add Data Catalog API Call
Appearance #15027: Update the Project Show page
Administrative #15018: Set up Virtualbox and install WinXP on it
Development #14142: UI convergence for Streaming Data
Development #14145: Data Stream import
Development #14875: Update Sample Variable UI
Development #14878: Change the Variable Value-Type to QA/QC
Development #14903: Add a timestamp selection for UTC or Local time to Sample data upload
Development #14967: Update Quality Control for Variable Creation
Development #14986: Sample Wizard -upload page sample medium
Development #14987: Add Integrated Offset sampling support to Sample Wizard UI
Development #14988: Add Integrated Sample Support in Backend
Development #14990: Variable Partial- Change is_regular to be false by default for Sample Upload
Development #14991: Get MetaTag controllers to work
Development #14992: Create MetaTag DojoDataStore object in Server.js
Development #14994: Add MetaTag DataGrid for selecting system Tags for assign in Sample Wizard
Development #14995: Create MetaTag Partial for new MetaTag creation in Sample Wizard
Development #15000: Add "Assign Batch to Column" button to Sample Wizard
Development #15007: Add Backend support for Spatial Offset storage
Development #15008: Add a Field Collection Method model
Development #15009: Add Field Collection Method to Variable Partial UI for Sample Wizard
Development #15010: Add Backend suport for Field Collection Method
Development #15038: Clean up the current query interface
Development #15058: Add an equipement Model to VOEIS
Development #15059: Add an equipment field to the field method and the lab method
Development #15065: Add the edit links to the dojo Site Grid on the Project view page
Development #15066: Add a view link to the Site Data Grid in the Project Show page
Development #15081: Change Project Browse page to show all a user projects and public projects
Development #15082: update the edit site page to a nice style
Development #15084: Project Show Page: show a summary of the data a site has
Development #15085: Project Show Page: show a summary of the data in the project
Development #15091: On the landing page put supported browser icons
Development #15092: Add the vertical datum drop down in site creation and edit
Development #15108: Change the layout of the Project Show page
Development #15118: remove the add site, add variable and add unit from the Project Show menu
Development #15119: Move the browse stream and sample data to the data menu
Development #15120: remove the campaign menu for now
Development #15161: Project Show: cleanup any depricated menu items
HIS Gateway
A specific goal of the VOEIS project is to integrate with the CUAHSI HIS through HydroServer.
In order for VOEIS to leverage the power of the CUAHSI HydroServer and its corresponding suite of
tools, a fully functional REST interface that allows for the pulling and pushing of data objects
was needed. We have constructed a HIS gateway using Ruby, Sinatra and the DataMapper ORM to provide
the necessary REST functionality. Associated requirements for the HIS gateway include a simple
authorization system to prevent malicious access, and the ability to serve up JSON and XML results
from simple URL style queries that can behave like full APIs to the ODM data-store. The initial
implementation of the VOEIS HIS gateway is currently available for use as a standalone JRuby server
application that can be deployed on any platform.
The VOEIS software is still under development, but interested individuals are invited to explore
the source code and play around with the application. Feel free to fork your own version of the
VOEIS source code and modify it to fit your particular use case needs or use the APIs to build
custom applications and user interfaces to interact with the VOEIS Data Hub.


Canada Surveys Dashboard
COVID-19, Labour Force, and Perspectives
This Rich Data Services powered dashboard combines data from Canada's COVID-19 Case Statistics , Labour Force Surveys and the Perspective Survey Series I on Impacts of COVID-19 public use files. It has been designed to demonstrate RDS benefits and flexibility in terms of combining data from multiple sources for visualization or story telling puposes and rapid design.
open_in_new RDS COVID-19 Project open_in_newWhat is RDS?


-
To add a characteristic to a service, select the accessory, bridge, or bridged accessory that contains the service from the list on the left side of the window. Once the item is selected, it's services are visible in the main view on the right side of the window. Each service has it's own "Add Characteristic" button. Select the "Add Characteristic" button of the service to add a characteristic to that service.
-
This will bring up the options for the new characteristic. There is an option to create a custom characteristic type as well as to create one of the Apple defined characteristics.
-
Depending upon the chosen characteristic, certain properties of the characteristic can be modified. If a characteristic with numeric format is selected, minimum value, maximum value, and step value can be specified. If the format is string, maximum string length can be specified.
-
If a custom characteristic is chosen, a valid UUID must be entered. The following features for a custom characteristic can be configured:
- Format
- Units
- Read/Write/Notify/Unconnected Notify Permissions
- Unconnected Notify permission is only available for Bluetooth LE accessories.
-
Characteristics can also be set to require Additional Authorization data. There is an option in the application Preferences to set specific data to validate against. If no data is entered in the application Preferences, the application will allow any data.
-
The "Hidden" property for a characteristic can also be set by selecting "Hidden" checkbox in the characteristic menu.
-
Once the characteristic details are completed, select the "Finish" button to add the characteristic.
-
Characteristics may be removed by selecting the round "-" button to the right of the characteristic.


Welcome to Jacque Query's Restaurant where the most delicious pastries are baked warm from the oven.
This button handles starting and stopping the animation by clearing the Interval and setting the Interval.
This button drops down into a form, and when you submit a valid image url your image will be appended to the current slideshow, however data is not persistent so when you reload the page your uploaded image will not be there.


Languages that use CSS for styling:
In CSS, size text using relative units such as rem and em for text sizing and margins. If a user scales their browser’s text size, text sized in relative elements will resize and still keep their visual connectedness. Line heights are unitless so that they are based on the size of the computed size of the text and will also adapt with any text resizing.
:root{ font-size:100%; } body{ font-size:1rem; } h1, .h1{ font-size:2.441rem; font-weight:700; line-height:1.25; margin:0.8em 0 0.262em; } h2, .h2{ font-size:1.953rem; font-weight:700; line-height:1.25; margin:1em 0 0.262em; } p{ margin-top:0; }
Plain text
----- Here’s the end of a paragraph about something very interesting that you’re fascinated in and want to read more about. Here’s a heading to describe the next block of text Here’s the beginning of a new paragraph about something even more interesting than the previous paragraph that was, frankly, amazing. -----
Plain text with markdown
Markdown syntax can create headings that can be converted into multiple other formats. Because markdown documents are frequently converted into other formats, spacing is more important than purely plain-text documents. Headings in markdown should have one line of blank space before them and no space after them. The # symbol is used to create six levels of headings.
# Heading level one ## Heading level two ### Heading level three #### Heading level four ##### Heading level five ###### Heading level six ----- # An exciting document title Here’s the introduction to the document, hopefully with a summary to help readers understand if the contents will be useful to them. ## Here’s an interesting second-level heading This is the beginning of an interesting paragraph of text that you, dear reader, will hopefully enthuse about. -----


public class MainActivity
extends Activity
| Constructor and Description |
|---|
MainActivity() |
| Modifier and Type | Method and Description |
|---|---|
void |
addQuestion(View v)
This method starts the add question thread activity.
|
<any> |
getAdapter() |
ActionBar.OnNavigationListener |
getNavigationListener() |
<any> |
getSpinnerAdapter()
For testing purposes only!
Gets the spinner of the Main Activity's Action Bar
|
ThreadList |
getThreadList()
For testing purposes only!
Gets the ThreadList of the Main Activity
|
ThreadListController |
getThreadListController()
For testing puroposes only!
|
void |
loadMore(View v)
This method loads more threads using the elastic search handler
through a thread list controller and notifies the adapter.
|
boolean |
onCreateOptionsMenu(Menu menu) |
boolean |
onOptionsItemSelected(MenuItem item) |
void |
onScreenHelp()
This method opens up the on-Screen Help dialog when called
The on-Screen Help dialog contains helpful information regarding the
current screen/activity the user is in.
|
void |
setUsername()
This method creates a prompt for setting username
Once the username has been set, it can never be changed.
|
void |
testButton(MenuItem item)
TESTING PURPOSES - to open and test AddQuestionActivity
|
void |
testQThreadButton(MenuItem item)
TESTING PURPOSES - to open and test QuestionThreadActivity
|
void |
userThreadsActivity(java.lang.String FILENAME)
This method allows navigation to lists of locally saved questions (favourites,
my questions and read laters) upon selection from the menu.
|
public boolean onCreateOptionsMenu(Menu menu)
public boolean onOptionsItemSelected(MenuItem item)
public void setUsername()
public void loadMore(View v)
public void addQuestion(View v)
public void userThreadsActivity(java.lang.String FILENAME)
FILENAME
- The file which saves the questions locallypublic void onScreenHelp()
public <any> getSpinnerAdapter()
public ActionBar.OnNavigationListener getNavigationListener()
public void testButton(MenuItem item)
public void testQThreadButton(MenuItem item)
public ThreadList getThreadList()
public ThreadListController getThreadListController()
public <any> getAdapter()


--- layout: about title: TWAS hub ---
TWAS (transcriptome-wide association study) is an approach to estimate the genetic association between disease risk and the local gene expression of thousands of genes. This web interface provides searchable access to TWAS results from hundreds of complex traits and dozens of expression studies.
What can you do here? Search the full list of analyzed traits and diseases in the TRAITS tab. See all genes and loci associated with a given trait like Schizophrenia and browse cross-trait associations. See gene conditional analyses at individual loci like 3p26 and filter all associated models. Evaluate predictive models for individual genes like CNTN4 and browse all corresponding trait associations. All genes with predictive models are listed in the GENES tab.