The Pro's and Con's behind
the Language of the Web
Why is JavaScript popular in web development?
JavaScript’s popularity is almost a forced one, with it doning the title of “Language of the Web”. Looking back at it’s history, it started to succeed after the fall of Java and when Netscape, the dominant browser at the time, developed and launched the language in the mid 90’s. It’s timing was perfect for other browsers to pick-up. Since then it has had blazing popularity for it’s relative ease of being able to learn and it being accessible across all major browsers.
What are the great things about JavaScript?
On the user end, It makes otherwise stagnant sites come alive with interactivity and user function. Filling out forms, online shopping and playing games have all become more responsive and intereactive. This makes for more enjoyable and effortless web browsing. On the developer end, JavaScript is great because all you need a browser and text editor to program - both of which come standard on pcs.
What are its limitations?
It is my (inexperienced) impression that JavaScript gets it’s bad rep from seasoned programmers who simply prefer other (non-web) programming languages and hold a grudge over JS basically being the only option when it comes to developing for the web. I look forward to coming back to the former statement after I become more experienced with web development to see if I feel the same way. That being said, in my short time of learning JavaScript so far, I have been hurdled many warnings about how to approach my JS programming.
There are other still plenty of complaints over the language, even from JS fans. The most prominent warning I am experiencing while learning the language is that errors can be easy to make and incredibly hard to find. When it was released with Netscape it’s popularity exploded at such a rate that removing imperfections from the language became impossible without existing code being broken. While the language has evolved, those early imperfections still hang around with vengeance. Of course this is a lot more to JavaScript in terms of pros and cons.
What I have written here is what I have discovered in the last few weeks of learning and researching. In the weeks to come I hope to expand my knowledge and learn more about what makes this language have such a love/hate relationship amongst the developer community.


0.3.6 CSS for Dinner - 11/27/2015
Positioning elements using CSS takes practice! Unlike working with color or font-family, sometimes the CSS I write has unexpected results. The least that I can do on my path to mastery is knowing what each type does—so I’ve written a little story. Perhaps it will help you too!
You’re at Thanksgiving dinner. it’s not a casual Friendsgiving potluck, but instead a little more formal with a host or hostess who’s spent all day making an elaborate meal for you. They have crafted main dishes and sides and wine pairings. It’s delightful.
 Each item is in it’s static position—exactly where’s it’s been put on the plate. But you just love to mix your turkey with cranberry sauce, so you move the cranberry sauce to a new relative position right next to the turkey. Unfortunately, the host has also put creamed corn on your plate (which is gross) so you move it to the absolute edge of your plate where it can’t touch anything else. As the evening proceeds and everyone gets fuller and drunker, you’re gesticulating wildly and knock over your wine glass. Perhaps they should have afixed it to the table where you couldn’t move it and make a mess!
For another resource, check out this rad 10 step tutorial.


The T cell activation factor NF-ATc positively regulates HIV-1 replication and gene expression in T cells.
Abstract
Clinical deterioration in human immunodeficiency virus type 1 (HIV-1) infection is associated with increased levels of viral replication and burden in the peripheral blood and lymphoid organs. T cell activation and ensuing cellular gene activation can be critical for HIV-1 replication. The hypothesis that the nuclear factor of activated T cells (NF-AT) may influence HIV-1 replication is therefore compelling given the tight correlation of HIV-1 transcriptional induction to T cell activation. We report that certain NF-AT (Rel) family members productively bind the kappaB regulatory elements, synergize with NF-kappaB and Tat in transcriptional activation of HIV-1, and enhance HIV-1 replication in T cells. These results link regulatory factors critical to T cell commitment directly to HIV-1 replication.


B.I.Verkin Institute for Low Temperature Physics & Engineering,
47 Nauky Ave., Kharkov 61103 Ukraine
+38 (057) 340-50-62
+38 (057) 340-33-70
Research interests: spectral properties of random operators and matrices, theoretical physics of disordered systems, random matrices and their applications
Thomas precession, persistent spin currents and quantum forces. Europhysics Letters, 106, (2014), 18001, 6 pp., (coauthors S. Ouvry, A. Yanovsky).
Ground state of one-dimension repulsing particles on disordered lattice. Internat. J. Modern Phys. C, 25, (2014), № 8, 1450028 , p. 17 (coauthors V. Slavin, A. Krivchikov).
The central limit theorem for linear eigenvalue statistics of the sum of independent random matrices of rank one. In: Spectral Theory and Differential Equations, 145–164, Amer. Math. Soc. Transl. Ser. 2, 233, Amer. Math. Soc., Providence, RI, (2014) (coauthors O. Guedon, A. Lytova, A. Pajor).
Area law scaling for the entropy of disordered quasifree fermions. Phys. Rev. Letters, 113, (2014), 150404, 4 pp. (coauthor V. Slavin).
Analogues of Szego's theorem for ergodic operators. Mat. Sb. 206, (2015), № 1, 103-130, translation in Sb. Math. 206 (2015), № 1-2, 93-119 (coauthor W. Kirsch).
On the equilibrium state of a small system with random matrix coupling to its environment. J. Phys. A, 48, (2015), № 26, 265201, 19 pp., (coauthor J. Lebowitz).
Examples of random Schroedinger-type operators with non-Poissonian spectra, Markov Processes and Related Fields, 21, (2015), № 3, 713 – 749 (coauthors S. Molchanov, E. Ray).
On a limiting distribution of singular values of random band matrices. J. Analysis, Mathematical Physics, Geometry, 11, (2015), № 4, 311–332 (coauthor A. Lytova).
The Shannon's mutual information of a multiple antenna time and frequency dependent channels: an ergodic operator approach. Journal of Mathematical Physics, 56, (2015), № 11, 113501, 29 pp., (coauthors W. Hachem, A. Moustakas).
Large block properties of the entanglement entropy of disordered fermions. Journal of Statistical Physics, 165, № 6, 1023-1059 (coauthors A. Elgart, M.Shcherbina).


--- layout: post title: Amazon Simple Notification Service Now Supports SMS date: '2011-11-03T07:23:00.001Z' author: solrevdev tags: modified_time: '2011-11-03T07:23:14.117Z' blogger_id: tag:blogger.com,1999:blog-31446756.post-6577283495970890917 blogger_orig_url: http://www.solrevdev.com/2011/11/amazon-simple-notification-service-now.html ---
US only for now but should rollout to other regions at some point.


Creates a StaffModel
storing input data and result
Generic information about a score to crate a staff with
Default value to replace missing key at bar 0
The bar, tempo, time signature and key signature info by quarters
Staff clef as MIDI pitch note at the staff 3rd line (G clef -> B = 71)
Last handled quarter, i.e. staff length in quarters
The resut of staff analysis on staff blocks indexed by starting quarter
The input staff info, stored for further outer modifications
Analyzes stored info and defaults to update staffBlockMap
, unless the
staff info received has not changed (in length of its members).
New staff information to replace previous one.
Analyzed staff as an indexed per quarter StaffBlockMap
Processes new staff info to update internal model. It will modify received staff info if it is disordered or incomplete.
New staff information to replace previous one
Generated using TypeDoc
Models a staff info into a musical structure of staff blocks indexed by the quarter they start from


Exception handling class for RtMidi.
More...
#include <RtMidi.h>
Inherits exception.
|
| enum | Type {
WARNING,
DEBUG_WARNING,
UNSPECIFIED,
NO_DEVICES_FOUND,
INVALID_DEVICE,
MEMORY_ERROR,
INVALID_PARAMETER,
INVALID_USE,
DRIVER_ERROR,
SYSTEM_ERROR,
THREAD_ERROR
} |
| | Defined RtMidiError types. More...
|
| |
Exception handling class for RtMidi.
The RtMidiError class is quite simple but it does allow errors to be "caught" by RtMidiError::Type. See the RtMidi documentation to know which methods can throw an RtMidiError.
Definition at line 63 of file RtMidi.h.
Defined RtMidiError types.
| Enumerator |
|---|
| WARNING |
A non-critical error.
|
| DEBUG_WARNING |
A non-critical error which might be useful for debugging.
|
| UNSPECIFIED |
The default, unspecified error type.
|
| NO_DEVICES_FOUND |
No devices found on system.
|
| INVALID_DEVICE |
An invalid device ID was specified.
|
| MEMORY_ERROR |
An error occured during memory allocation.
|
| INVALID_PARAMETER |
An invalid parameter was specified to a function.
|
| INVALID_USE |
The function was called incorrectly.
|
| DRIVER_ERROR |
A system driver error occured.
|
| SYSTEM_ERROR |
A system error occured.
|
| THREAD_ERROR |
A thread error occured.
|
Definition at line 67 of file RtMidi.h.
The constructor.
Definition at line 82 of file RtMidi.h.
| virtual RtMidiError::~RtMidiError |
( |
void |
| ) |
|
| throw | ( | |
| ) | | |
|
inlinevirtual |
The destructor.
Definition at line 85 of file RtMidi.h.
| virtual const std::string& RtMidiError::getMessage |
( |
void |
| ) |
const |
| throw | ( | |
| ) | | |
|
inlinevirtual |
Returns the thrown error message string.
Definition at line 94 of file RtMidi.h.
| virtual const Type& RtMidiError::getType |
( |
void |
| ) |
const |
| throw | ( | |
| ) | | |
|
inlinevirtual |
Returns the thrown error message type.
Definition at line 91 of file RtMidi.h.
| virtual void RtMidiError::printMessage |
( |
void |
| ) |
const |
| throw | ( | |
| ) | | |
|
inlinevirtual |
Prints thrown error message to stderr.
Definition at line 88 of file RtMidi.h.
| virtual const char* RtMidiError::what |
( |
void |
| ) |
const |
| throw | ( | |
| ) | | |
|
inlinevirtual |
Returns the thrown error message as a c-style string.
Definition at line 97 of file RtMidi.h.
| std::string RtMidiError::message_ |
|
protected |
The documentation for this class was generated from the following file:


const _ = require('lodash');
const namedEventEmitters = {};
const convertWildcardToRegex = wildcardString => new RegExp(`^${wildcardString.replace(/\*/g, '.*')}$`, 'g');
const wildcardEventMatcher = (leftValue, rightValue) => {
if (leftValue === '*' || rightValue === '*') {
return true;
}
if (leftValue === rightValue) {
return true;
}
return convertWildcardToRegex(leftValue).test(rightValue) || convertWildcardToRegex(rightValue).test(leftValue);
};
const checkListOptions = (options, value) => {
return options.some(option => option === value);
};
const getListOptions = string => {
if (string.startsWith('{') && string.endsWith('}')) {
return string.substr(1).slice(0, -1).split(',');
}
return [];
};
const listOptionEventMatcher = (leftValue, rightValue) => {
if (leftValue === rightValue) {
return true;
}
return checkListOptions(getListOptions(leftValue), rightValue) || checkListOptions(getListOptions(rightValue), leftValue);
};
const sectionFilter = _.curry((sectionMatchers, lhs, rhs) => {
const leftSections = lhs.split('.');
const rightSections = rhs.split('.');
if (leftSections.length !== rightSections.length) {
return false;
}
return leftSections.every((eventSection, index) => {
return sectionMatchers.some(sectionMatcher => sectionMatcher(leftSections[index], rightSections[index]));
});
});
const getHandlers = {
advanced: _.curry((data, filter, matchEvent) => {
return Object.entries(data.events)
.filter(([event]) => filter(matchEvent, event))
.map(([__event, handlers]) => handlers)
.reduce((allHandlers, handlers) => allHandlers.concat(handlers), []);
}),
exact: _.curry((data, matchEvent) => {
return data.events[matchEvent] || [];
})
};
const eventRegistrars = {
basic: _.curry((data, event, handler) => {
if (!data.events[event]) {
data.events[event] = [];
}
data.events[event].push(handler);
})
};
const eventEmitter = ({ getHandlers, registerEventHandler }) => {
const getEventObject = eventName => {
const meta = {
action: 'continue'
};
return {
meta,
handlers: getHandlers(eventName),
eventObject: Object.freeze({
eventName,
continueWithUndefined: Symbol('continue-with-undefined'),
returnUndefined: Symbol('return-undefined'),
preventDefault: () => meta.action = 'return'
})
};
};
/**
* Emit an event synchronously. This emit will execute all matching handlers and return an array of their return values.
*
* @function
* @name EventEmitter#emit
* @param {string} event The name of the event to emit (use full-stop '.' as a namespace delimiter).
* @param {...*} [args] Any number of arguments to pass to all event handlers.
* @returns {array} An array of all the values returned by event handlers in the order they were executed.
*/
const emit = (event, ...args) => {
const { handlers, eventObject } = getEventObject(event);
return handlers.map(handler => handler(eventObject, ...args));
};
/**
* Emit an event asynchronously. This emit will execute all matching handlers concurrently (in parallel) and return an
* array of their return values.
*
* @function
* @name EventEmitter#emitAsync
* @param {string} event The name of the event to emit (use full-stop '.' as a namespace delimiter).
* @param {...*} [args] Any number of arguments to pass to all event handlers.
* @returns {Promise<array>} A Promise that will resolve to an array of all the values returned by the event handlers in the order they were matched.
*/
const emitAsync = async (event, ...args) => {
const { handlers, eventObject } = getEventObject(event);
return await Promise.all(handlers.map(async (handler) => await handler(eventObject, ...args)));
};
const updateWaterfallMetaData = ({ meta, eventObject }) => {
switch (meta.lastResult) {
case eventObject.continueWithUndefined:
meta.nextInput = [];
return;
case eventObject.returnUndefined:
meta.action = 'return';
meta.result = undefined;
return;
case undefined:
return;
default:
meta.result = meta.lastResult;
meta.nextInput = [meta.result];
}
};
/**
* Emit an event synchronously and in order where the output of each handler in the chain becomes the input to the next.
* The exception to this rule is that returning undefined from a handler will be interpreted as "leave the data unchanged".
* If the intention of a handler is to continue execution, but replace the data of previous steps with undefined, return "event.continueWithUndefined" instead
* of simply returning undefined. If the intention is to halt execution of subsequent steps and return undefined overall, return "event.returnUndefined"
* where "event" is the first parameter passed to each handler.
*
* @function
* @name EventEmitter#emitWaterfall
* @param {string} event The name of the event to emit (use full-stop '.' as a namespace delimiter).
* @param {...*} [args] Any number of arguments to pass to the first event handler.
* @returns The return value of the last event handler that executed and returned a value.
*/
const emitWaterfall = (event, ...args) => {
const { handlers, eventObject, meta } = getEventObject(event);
meta.nextInput = args;
for (const handler of handlers) {
meta.lastResult = handler(eventObject, ...meta.nextInput);
updateWaterfallMetaData({ meta, eventObject });
if (meta.action === 'return') {
break;
}
}
return meta.result;
};
/**
* An asynchronous version of {@link EventEmitter#emitWaterfall}
*
* @function
* @name EventEmitter#emitWaterfallAsync
* @see {EventEmitter#emitWaterfall}
* @param {string} event The name of the event to emit (use full-stop '.' as a namespace delimiter).
* @param {...*} [args] Any number of arguments to pass to the first event handler.
* @returns The return value of the last event handler that executed and returned a value.
*/
const emitWaterfallAsync = async (event, ...args) => {
const { handlers, eventObject, meta } = getEventObject(event);
meta.nextInput = args;
for (const handler of handlers) {
meta.lastResult = await handler(eventObject, ...meta.nextInput);
updateWaterfallMetaData({ meta, eventObject });
if (meta.action === 'return') {
break;
}
}
return meta.result;
};
/**
* Register an event handler. The event handler will be called when any event matching the event string is emitted. The order of execution and parameters
* passed to the handler can change based on which emit was used. {@link EventEmitter#emit} {@link EventEmitter#emitWaterfall}.
*
* @function
* @name EventEmitter#on
* @param {string} event The name (or matching string) of the event you want the handler to be registered against.
* @param {function} handler The event handler to register.
*/
/**
* @classdesc The main aggregating event emitter object.
*
* @class
* @hideconstructor
* @name EventEmitter
*/
return {
emit,
emitAsync,
emitWaterfall,
emitWaterfallAsync,
on: registerEventHandler
};
};
/**
* The options that can set on an event emitter when it is created.
*
* @typedef options
* @type {object}
* @property {boolean} [wildcards=false] Whether or not to enable wildcard matching in event names (e.g., "data.*" to match "data.get").
* @property {boolean} [listOptions=false] Whether or not to enable list option matching in event names. (e.g., "data.{get,set}" to match both "data.get" and "data.set").
* @property {boolean|array} [hooks=false]
False to disable hooks, or an array to specify lifecycle hooks (in order) to allow handlers to register against.
* E.g., if passing in ['first', 'before', 'default' 'after', 'last'] any handler registered as "namespace.event" will be in the "default" lifecycle, which will happen
* after those registered as "first:namespace.event" or "before:namespace.event".

If a "default" is not provided, an error will be raised if any handler is registered
* without a lifecycle marker. If the value true is provided instead of an array, the default lifecycles will be used (["early", "before", "default", "after", "late"]).

NOT YET IMPLEMENTED

*/
const configureEventEmitter = ({ wildcards = false, listOptions = false }) => {
const data = {
cache: {},
events: {}
};
const options = {
getHandlers: getHandlers.exact(data),
registerEventHandler: eventRegistrars.basic(data)
};
const sectionMatchers = [];
if (wildcards) {
sectionMatchers.push(wildcardEventMatcher);
}
if (listOptions) {
sectionMatchers.push(listOptionEventMatcher);
}
if (sectionMatchers.length > 0) {
options.getHandlers = getHandlers.advanced(data, sectionFilter(sectionMatchers));
}
return eventEmitter(options);
};
/**
* Find an existing event emitter by name or create a new one. Named event emitters will always return the first instance
* created when fetched by name unless they've been specifically deleted using the {@link removeNamedEventEmitter} or
* {@link removeNamedEventEmitters} functions. If no name is provided, an anonymous event emitter that cannot be fetched
* again will be created.
*
* @param {options} [options] The options to set for the event emitter (ignored if an event emitter by that name already exists).
* @param {string} [options.name] The name of the event emitter to get or create.
* @returns {EventEmitter} The event emitter associated with the name provided (or an anonymous one if a name is not provided).
*/
const aggregatingEventEmitter = ({ name, ...options } = {}) => {
const eventEmitter = namedEventEmitters[name] || configureEventEmitter({ ...options });
if (name) {
namedEventEmitters[name] = eventEmitter;
}
return eventEmitter;
};
/**
* Remove an existing event emitter by name. This will not stop the event emitter from functioning, only from being
* returned from {@link aggregatingEventEmitter}.
*
* @param {string} name The name of the event emitter to remove the reference to.
* @returns {boolean} True if the event emitter existed (and was removed), false otherwise.
*/
const removeNamedEventEmitter = (name) => {
if (namedEventEmitters[name] === undefined) {
return false;
}
delete namedEventEmitters[name];
return true;
};
/**
* Remove all existing event emitters. This will not stop the event emitters from functioning, only from being
* returned from {@link aggregatingEventEmitter}.
*/
const removeNamedEventEmitters = () => {
Object.keys(namedEventEmitters).forEach(key => delete namedEventEmitters[key]);
};
/**
* @see {@link aggregatingEventEmitter}
*/
function AggregatingEventEmitter() {
return aggregatingEventEmitter.apply(null, arguments);
}
module.exports = {
AggregatingEventEmitter,
aggregatingEventEmitter,
removeNamedEventEmitter,
removeNamedEventEmitters
};


All config options you can trun on/off from the theme box configuration (green icon on the left side of page).
Avalible configure options
Check the Dashboard v.4 with top navigation layout
Check the Dashboard v.4 with basic layout


Modern & Creative Agency
Effects present letters inquiry no an removed or friends. Desire behind latter me though in. Supposing shameless am engrossed itatibus additions.
{% extends "base/index.html" %} {% block content %}
Effects present letters inquiry no an removed or friends. Desire behind latter me though in. Supposing shameless am engrossed itatibus additions.
# Python 3: Fibonacci series up to n def fib(n): a, b = 0, 1 while a < n: print(a, end=' ') a, b = b, a+b print() fib(1000)


Keep in mind these are heavily simplified examples.For example, forms related code is purposefully omitted.But real life cases would use the same techniques.
This way, if you would pass a string — it would be used as SVG icon source
By now you've seen that Polymorpheus allows us to be pretty flexible. Let's see how far we can push our very simple ComboBox implementation.
Polymorpheus allows you to write Design-agnostic code. In a sense, it is a lot like generics — you wrap your logic around what you receive from the user without dependence on what exactly you have received.
This concept frees you from flags and specific code for particular use cases. You only define boundaries of how your component looks like and implement actual work logic. Visual customization is delegated to whoever uses your component and is easily reused.
Other good examples that could benefit from this idea are popups, notifications, tooltips, dropdowns, error messages etc.
Read more about it in this article and check out entire polymorpheus based UI library of 200+ components and directives: Taiga UI


@@include('./_head.html', { "path": "..", "title": "Pixel Documentation - File structure" })
MenuIn this section we explain the role of each folder.
In the html/
folder you'll find all of the html templates in the components/
, sections/
and pages/
folders.
Files in partials/
are included in other html files with the help of gulp-file-include
. Such files are _footer.html
, _head.html
and so on.
Please check the official documentation to learn how to use these partials.
img/
holds all of the images and SVG's. Inside this folder there are other folders such as /img/blog
which hold images based on the name of the folder.
When running gulp build
these images will be moved to the dist/assets/img
folder and they will be optimized. Check out our Gulp section if you
want to disable this feature.
In the js/
folder you'll find two important files. One of the is pixel.js
where you will find the custom Javascript written by the Themesberg team. Here you
can write your custom Javascript. We have jQuery
included as well.
pixel.min.js
is generated after running gulp
and it is the file that is included in our templates.
scss/
is one of the most important files in our product. Here you'll find two folders and one important file:
scss/bootstrap
is the scss
code from Bootstrap 4. As our product is an extension of the Bootstrap 4 components, we made use of the variables and mixins provided
by them.
scss/pixel
holds the variables, mixins and custom components developed by Themesberg for Pixel.
pixel/mixins
is where you can find the custom mixins developed by us similar to the ones from Bootstrap 4.
pixel/utilities
has styles for custom helper classes for spacings, borders, shadows and many more.
pixel/vendor
is the folder that holds styles for the external libraries we use for Pixel. We use them here so that there will be only one minified css
file. This way the files will load faster.
*.scss
The remaining files are the styles used for each component from Pixel.
pixel.scss
is where all the other scss
files are imported. This file is later used in gulpfile.js
to compile the code in
CSS
.
The node_modules/
folder contains external libraries generated based on package.json
.
gulpfile.js
is where you'll find the Gulp functions that generate, compile and serve our code.
index.html
is the main html
template.
package.json
holds the theme dependencies.
README.md
can never miss from a project. Here you can find basic information regarding the software we've developed.
.gitignore
is used to ignore folders such as node_modules
or dist
if you have a git instance.
These folders are generated by using Gulp commands. Check them out here.
The dist/
folder will be generated when running the
gulp build:dist
command. You'll find html
,
js
and css
code in a minified state. Ideally you shouldn't modify the content of these files, as they are supposed to be the generated code that you'll use
to go live.
The html&css/
folder can be generated by running gulp build:dev
. This folder will have all the necessary files, unminified files of the project.
We recommend to use this folder if you want a copy of the theme without Sass, Gulp or npm.
You might be wondering what the .temp/
folder is all about. Long story short you don't have to worry about it, as you shouldn't modify files from there. It is dynamically generated by Gulp to serve the files to a local server through BrowserSync and show you how the product will look when it will finally get generated for production.
The css/
folder is generated by gulp
as it holds the compiled scss
files. These files are automatically included by our
html
templates.
We recommend you to use scss
as it is a powerful language where you can change variables to update colors, shadows, font families to your liking. If you choose otherwise, you can modify
the main pixel.css
file by writing simple CSS.
Warning: if you write your own CSS in the
pixel.css
file and run gulp
it will override your file based on what the scss
files hold.


Node.js Variant Skip this step and go to 10 MyApp on NodeJS Site
MyApp
is now ready to upload to the GAE Site. These are the steps. Modify for a non-windows platform.
Start a command line window and make the CWD x:\tri-devp\bats
as defined in Development Package Preparation
Type appcfg
to initiate shipping the application to the GAE Site.
You will be prompted for Email:
. Enter Google account (your email without @gmail.com
suffix)
You will be prompted for Password:
. Enter the password associated with this gmail account.
Note: On subsequent uploads you may not be prompted for this information as for a period of time it remembers.
It will crunch for a few seconds until it announces
Update for server default completed successfully
Note: This will only be necessary the first time you upload MyApp
to the GAE Site.
As before the Datastore is unprimed.
Point your browser at URL tri-test.appspot.com
(where tri-test
is your GAE Site ID) and you should see the familiar screen.
Note: An intermediate Prime.htm
screen may show for a few seconds while the site warms up. Be patient.
Repeat the procedure starting at point 2 in Configuring the Datastore remembering to
use URL tri-test.appspot.com
rather than localhost:8882
If there is data to upload proceed as described in Uploading data to the App. But first read on.
Before using the upload facilities you have to tell the WAKS Utility to use the production site (GAE Site).
First issue the command waks site tri-test
where tri-test
is the MyApp
site id.
Then prefix prod
to each WAKS Command. Thus the sequence
waks set myapp super-userid super-password
waks dir ..\data
waks prod ship % %
would ship the myapp
data stored in the ..\data
folder
We are ready for the final checkout of 09 MyApp on GAE Site


Flavors
We have 30+ soft serve, 15+ flavors of hand dip, 20+ delicious toppings, Malt Shakes, Drinks, Hot dogs, Funnel Cakes,
Mozzarella Sticks, and so much more!!!
Small Business Sundays
Pamela's Ice Cream has SMALL BUSINESS VENDORS EVERY SUNDAY from 3-8PM


| Example | ||
|---|---|---|
| Mention |
@name
|
|
| List |
@name/list
|
|
| Hashtag |
#hashtag
|
|
| Cashtag |
$cashtag
|
|
| URL without scheme |
example.com
|
|
| URL with scheme |
https://example.com
|


WiDone:
Logged in as
TASK LISTS
USER DETAILS
ABOUT
LOGOUT
WiDone
Viel Spass beim Erledigen ...
WILL BE REPLACED BY DERIVED PAGES


Early-onset Alzheimer's disease caused by mutations at codon 717 of the beta-amyloid precursor protein gene.
A mutation at codon 717 of the beta-amyloid precursor protein gene has been found to cosegregate with familial Alzheimer's disease in a single family. This mutation has been reported in a further five out of approximately 100 families multiply affected by Alzheimer's disease. We have identified another family, F19, in which we have detected linkage between the beta-amyloid precursor protein gene and Alzheimer's disease. Direct sequencing of exon 17 in affected individuals from this family has revealed a base change producing a Val----Gly substitution, also at codon 717. The occurrence of a second allelic variant at codon 717 linked to the Alzheimer's phenotype supports the hypothesis that they are pathogenic mutations.


Apprentice Atra:
I mean no disrespect, but you look a little puny to me. Even if I were to explain to you what is happening here, I doubt that you could help us.
(Quest only available for characters level 82 and above)


import networkx as nx
import matplotlib.pyplot as plt
from collections import Counter
from custom import load_data as cf
from custom import ecdf
import warnings
warnings.filterwarnings('ignore')
from nxviz import CircosPlot
import numpy as np
%load_ext autoreload
%autoreload 2
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
We will load the sociopatterns network data for this notebook. From the Konect website:
This network describes the face-to-face behavior of people during the exhibition INFECTIOUS: STAY AWAY in 2009 at the Science Gallery in Dublin. Nodes represent exhibition visitors; edges represent face-to-face contacts that were active for at least 20 seconds. Multiple edges between two nodes are possible and denote multiple contacts. The network contains the data from the day with the most interactions.
# Load the sociopatterns network data.
G = cf.load_sociopatterns_network()
# How many nodes and edges are present?
len(G.nodes()), len(G.edges())
Within a social network, there will be certain individuals which perform certain important functions. For example, there may be hyper-connected individuals who are connected to many, many more people. They would be of use in the spreading of information. Alternatively, if this were a disease contact network, identifying them would be useful in stopping the spread of diseases. How would one identify these people?
One way we could compute this is to find out the number of people an individual is conencted to. NetworkX let's us do this by giving us a G.neighbors(node)
function.
# Let's find out the number of neighbors that individual #7 has.
len(list(G.neighbors(9)))
API Note: As of NetworkX 2.0, G.neighbors(node)
now returns a dict_keyiterator
, which means we have to cast them as a list
first in order to compute its length.
Can you create a ranked list of the importance of each individual, based on the number of neighbors they have? (3 min.)
Hint: One suggested output would be a list of tuples, where the first element in each tuple is the node ID (an integer number), and the second element is the number of neighbors that it has.
Hint: Python's sorted(iterable, key=lambda x:...., reverse=True)
function may be of help here.
# Possible Answers:
sorted(G.nodes(),
key=lambda x:len(list(G.neighbors(x))), reverse=True)[0:5]
# sorted([(n, G.neighbors(n)) for n in G.nodes()],
# key=lambda x: len(x[1]), reverse=True)[0:5]
The number of other nodes that one node is connected to is a measure of its centrality. NetworkX implements a degree centrality, which is defined as the number of neighbors that a node has normalized to the number of individuals it could be connected to in the entire graph. This is accessed by using nx.degree_centrality(G)
# nx.degree_centrality(G)
# Uncomment the next line to show a truncated version.
list(nx.degree_centrality(G).items())[0:5]
If you inspect the dictionary closely, you will find that node 51 is the one that has the highest degree centrality, just as we had measured by counting the number of neighbors.
There are other measures of centrality, namely betweenness centrality, flow centrality and load centrality. You can take a look at their definitions on the NetworkX API docs and their cited references. You can also define your own measures if those don't fit your needs, but that is an advanced topic that won't be dealt with here.
The NetworkX API docs that document the centrality measures are here: http://networkx.readthedocs.io/en/networkx-1.11/reference/algorithms.centrality.html?highlight=centrality#module-networkx.algorithms.centrality
The following exercises are designed to get you familiar with the concept of "distribution of metrics" on a graph.
n
nodes, then how many possible edges are there in total, assuming self-edges are allowed? What if self-edges are not allowed?Exercise Time: 8 minutes.
Here is what an ECDF is (https://en.wikipedia.org/wiki/Empirical_distribution_function).
Hint: You may want to use:
ecdf(list_of_values)
to get the empirical CDF x- and y-values for plotting, and
plt.scatter(x_values, y_values)
Hint: You can access the dictionary .keys()
and .values()
and cast them as a list.
If you know the Matplotlib API, feel free to get fancy :).
# Possible Answers:
fig = plt.figure(0)
# Get a list of degree centrality scores for all of the
# nodes in the graph
degree_centralities = list(
nx.degree_centrality(G).values())
x, y = ecdf(degree_centralities)
# Plot the histogram of degree centralities.
plt.scatter(x, y)
# Set the plot title.
plt.title('Degree Centralities')
fig = plt.figure(1)
neighbors = [len(list(G.neighbors(node))) for node in G.nodes()]
x, y = ecdf(neighbors)
plt.scatter(x, y)
plt.title('Number of Neighbors')
fig = plt.figure(2)
plt.scatter(degree_centralities, neighbors, alpha=0.1)
plt.xlabel('Degree Centralities')
plt.ylabel('Number of Neighbors')
Before we move on to paths in a network, see if you can use the Circos plot to visualize the network. Order and color the nodes according to the order
keyword. (2 min.)
The CircosPlot API needs documentation written; for now, I am providing the following "on-the-spot" docs for you.
To instantiate and draw a CircosPlot:
c = CircosPlot(G, node_order='node_key', node_color='node_key')
c.draw()
plt.show() # or plt.savefig(...)
Notes:
'node_key'
is a key in the node metadata dictionary that the CircosPlot constructor uses for determining the colour, grouping, and ordering of the nodes.order
, which is already encoded on each node in the graph.c = CircosPlot(G, node_order='order', node_color='order')
c.draw()
plt.savefig('images/sociopatterns.png', dpi=300)
What can you deduce about the structure of the network, based on this visualization?
Nodes are sorted by ID. Nodes are more connected to proximal rather than distal nodes. The data are based on people streaming through an enclosed space, so it makes sense that people are mostly connected to others proximal in order, but occasionally some oddballs stick around.
Graph traversal is akin to walking along the graph, node by node, restricted by the edges that connect the nodes. Graph traversal is particularly useful for understanding the local structure (e.g. connectivity, retrieving the exact relationships) of certain portions of the graph and for finding paths that connect two nodes in the network.
Using the synthetic social network, we will figure out how to answer the following questions:
Let's say we wanted to find the shortest path between two nodes. How would we approach this? One approach is what one would call a breadth-first search (http://en.wikipedia.org/wiki/Breadth-first_search). While not necessarily the fastest, it is the easiest to conceptualize.
The approach is essentially as such:
Try implementing this algorithm in a function called path_exists(node1, node2, G)
. (15 min.)
The function should take in two nodes, node1
and node2
, and the graph G
that they belong to, and return a Boolean that indicates whether a path exists between those two nodes or not. For convenience, also print out whether a path exists or not between the two nodes.
def path_exists(node1, node2, G):
"""
This function checks whether a path exists between two nodes (node1,
node2) in graph G.
Special thanks to @ghirlekar for suggesting that we keep track of the
"visited nodes" to prevent infinite loops from happening. This also
removes the need to remove nodes from queue.
Reference: https://github.com/ericmjl/Network-Analysis-Made-Simple/issues/3
With thanks to @joshporter1 for the second bug fix. Originally there was
an extraneous "if" statement that guaranteed that the "False" case would
never be returned - because queue never changes in shape. Discovered at
PyCon 2017.
With thanks to @chendaniely for pointing out the extraneous "break".
"""
visited_nodes = set()
queue = [node1]
for node in queue:
if node2 in G.neighbors(node):
print('Path exists between nodes {0} and {1}'.format(node1, node2))
return True
else:
visited_nodes.add(node)
queue.extend([n for n in neighbors if n not in visited_nodes])
print('Path does not exist between nodes {0} and {1}'.format(node1, node2))
return False
# Test your answer below
def test_path_exists():
assert path_exists(18, 10, G)
assert path_exists(22, 51, G)
test_path_exists()
If you write an algorithm that runs breadth-first, the recursion pattern is likely to follow what we have done above. If you do a depth-first search (i.e. DFS), the recursion pattern is likely to look a bit different. Take it as a challenge exercise to figure out how a DFS looks like.
Meanwhile... thankfully, NetworkX has a function for us to use, titled has_path
, so we don't have to implement this on our own. :-) Check it out here.
nx.has_path(G, 400, 1)
NetworkX also has other shortest path algorithms implemented.
We can build upon these to build our own graph query functions. Let's see if we can trace the shortest path from one node to another.
nx.shortest_path(G, source, target)
gives us a list of nodes that exist within one of the shortest paths between the two nodes. (Not all paths are guaranteed to be found.)
nx.shortest_path(G, 4, 400)
Incidentally, the node list is in order as well.
Write a function that extracts the edges in the shortest path between two nodes and puts them into a new graph, and draws it to the screen. It should also return an error if there is no path between the two nodes. (5 min.)
Hint: You may want to use G.subgraph(iterable_of_nodes)
to extract just the nodes and edges of interest from the graph G
. You might want to use the following lines of code somewhere:
newG = G.subgraph(nodes_of_interest)
nx.draw(newG)
newG will be comprised of the nodes of interest and the edges that connect them.
# Possible Answer:
def extract_path_edges(G, source, target):
# Check to make sure that a path does exists between source and target.
if nx.has_path(G, source, target):
nodes = nx.shortest_path(G, source, target)
newG = G.subgraph(nodes)
return newG
else:
raise Exception('Path does not exist between nodes {0} and {1}.'.format(source, target))
newG = extract_path_edges(G, 4, 400)
nx.draw(newG, with_labels=True)
These exercises below are designed to let you become more familiar with manipulating and visualizing subsets of a graph's nodes.
Write a function that extracts only node, its neighbors, and the edges between that node and its neighbors as a new graph. Then, draw the new graph to screen.
# Possible Answer
def extract_neighbor_edges(G, node):
neighbors = list(G.neighbors(node))
newG = nx.Graph()
for n1, n2 in G.edges():
if (n1 == node and n2 in neighbors) or (n1 in neighbors and n2 == node):
newG.add_edge(n1, n2)
return newG
fig = plt.figure(0)
newG = extract_neighbor_edges(G, 23)
nx.draw(newG, with_labels=True)
def extract_neighbor_edges2(G, node):
neighbors = G.neighbors(node)
newG = nx.Graph()
for neighbor in neighbors:
if (node, neighbor) in G.edges() or (neighbor, node) in G.edges():
newG.add_edge(node, neighbor)
return newG
fig = plt.figure(1)
newG = extract_neighbor_edges2(G, 19)
nx.draw(newG, with_labels=True)
Let's try some other problems that build on the NetworkX API. Refer to the following for the relevant functions:
http://networkx.readthedocs.io/en/networkx-1.11/reference/algorithms.shortest_paths.html
# Possible answer to Question 1:
# All we need here is the length of the path.
def compute_transmission_time(G, source, target):
"""
Fill in code below.
"""
length = nx.shortest_path_length(G, source, target)
time = sum(range(1, length+1))
return time
compute_transmission_time(G, 14, 4)
# Possible answer to Question 2:
# We need to know the length of every single shortest path between every pair of nodes.
# If we don't put a source and target into the nx.shortest_path_length(G) function call, then
# we get a dictionary of dictionaries, where all source-->target-->lengths are shown.
lengths = []
times = []
for source, sink_length in nx.shortest_path_length(G):
for sink, length in sink_length.items():
times.append(sum(range(1, length+1)))
lengths.append(length)
plt.figure(0)
plt.bar(list(Counter(lengths).keys()), list(Counter(lengths).values()))
plt.figure(1)
plt.bar(list(Counter(times).keys()), list(Counter(times).values()))
If a message has to be passed through the network in the shortest time possible, there may be "bottleneck" nodes through which information must always flow through. Such a node has a high betweenness centrality. This is implemented as one of NetworkX's centrality algorithms. Check out the Wikipedia page for a further description.
btws = nx.betweenness_centrality(G, normalized=False)
plt.bar(list(btws.keys()), list(btws.values()))
Plot betweeness centrality against degree centrality for the network data. (5 min.)
# Possible answer:
deg_centrality = nx.degree_centrality(G)
btw_centrality = nx.betweenness_centrality(G)
deg_cent_sorted = [i[1] for i in sorted(zip(deg_centrality.keys(), deg_centrality.values()))]
btw_cent_sorted = [i[1] for i in sorted(zip(btw_centrality.keys(), btw_centrality.values()))]
plt.scatter(deg_cent_sorted, btw_cent_sorted)
plt.xlabel('degree')
plt.ylabel('betweeness')
plt.title('centrality scatterplot')
Think about it...
From the scatter plot, we can see that the dots don't all fall on the same line. Degree centrality and betweenness centrality don't necessarily correlate. Can you think of scenarios where this is true?
What would be the degree centrality and betweenness centrality of the middle connecting node in the barbell graph below?
nx.draw(nx.barbell_graph(5, 1))


Skechers' 'cool' value gives it room to run like Nike: Barron's
NEW YORK: Shoemaker Skechers USA is expected to post earnings growth on pace with Nike over the next three years, giving its relatively low valuation a chance of catching up, financial newspaper Barron's reported in its Dec 7 edition.
Analysts estimate Skechers' earnings-per-share will rise 15 per cent this year and in 2020, and 12 per cent in 2021. Yet Nike trades at about 30 times analysts' future earnings estimates, compared with 16 times for Sketchers, even after Skechers shares soared more than 75 per cent this year, the paper said.
Skechers sells trainers, dress shoes, sandals and boots - a broader range than Nike - and has grown over the past 20 years to become the third-largest global footwear brand by revenue, after Nike and Adidas, the paper said.
Skechers styles, often priced at US$50 to US$70, are perceived as "cool" and good value, an edge its bigger rivals lack, Barron's added.
"Nike and Adidas are reluctant to identify as value brands, giving Skechers room to run," Barron's said.


Abbott India Standalone September 2019 Net Sales at Rs 1,054.80 crore, up 7.66% Y-o-Y
Reported Standalone quarterly numbers for Abbott India are:
Net Sales at Rs 1,054.80 crore in September 2019 up 7.66% from Rs. 979.72 crore in September 2018.
Quarterly Net Profit at Rs. 178.33 crore in September 2019 up 29.52% from Rs. 137.68 crore in September 2018.
EBITDA stands at Rs. 233.03 crore in September 2019 up 6.63% from Rs. 218.54 crore in September 2018.
Abbott India EPS has increased to Rs. 83.93 in September 2019 from Rs. 64.79 in September 2018.
Abbott India shares closed at 11,698.85 on November 11, 2019 (NSE) and has given 60.61% returns over the last 6 months and 56.63% over the last 12 months.
| Abbott India | |
| Standalone Quarterly Results | in Rs. Cr. |
| Sep'19 | Jun'19 | Sep'18 | |
| Net Sales/Income from operations | 1,054.80 | 998.89 | 979.72 |
| Other Operating Income | -- | -- | -- |
| Total Income From Operations | 1,054.80 | 998.89 | 979.72 |
| EXPENDITURE | |||
| Consumption of Raw Materials | 108.34 | 99.14 | 86.78 |
| Purchase of Traded Goods | 492.31 | 446.84 | 412.86 |
| Increase/Decrease in Stocks | 1.18 | 14.01 | 60.21 |
| Power & Fuel | -- | -- | -- |
| Employees Cost | 120.62 | 120.18 | 105.17 |
| Depreciation | 14.95 | 14.80 | 4.06 |
| Excise Duty | -- | -- | -- |
| Admin. And Selling Expenses | -- | -- | -- |
| R & D Expenses | -- | -- | -- |
| Provisions And Contingencies | -- | -- | -- |
| Exp. Capitalised | -- | -- | -- |
| Other Expenses | 128.22 | 144.54 | 120.69 |
| P/L Before Other Inc. , Int., Excpt. Items & Tax | 189.18 | 159.38 | 189.95 |
| Other Income | 28.90 | 29.60 | 24.53 |
| P/L Before Int., Excpt. Items & Tax | 218.08 | 188.98 | 214.48 |
| Interest | 1.82 | 2.03 | 0.52 |
| P/L Before Exceptional Items & Tax | 216.26 | 186.95 | 213.96 |
| Exceptional Items | -- | -- | -- |
| P/L Before Tax | 216.26 | 186.95 | 213.96 |
| Tax | 37.93 | 70.01 | 76.28 |
| P/L After Tax from Ordinary Activities | 178.33 | 116.94 | 137.68 |
| Prior Year Adjustments | -- | -- | -- |
| Extra Ordinary Items | -- | -- | -- |
| Net Profit/(Loss) For the Period | 178.33 | 116.94 | 137.68 |
| Equity Share Capital | 21.25 | 21.25 | 21.25 |
| Reserves Excluding Revaluation Reserves | -- | -- | -- |
| Equity Dividend Rate (%) | -- | -- | -- |
| EPS Before Extra Ordinary | |||
| Basic EPS | 83.93 | 55.03 | 64.79 |
| Diluted EPS | 83.93 | 55.03 | 64.79 |
| EPS After Extra Ordinary | |||
| Basic EPS | 83.93 | 55.03 | 64.79 |
| Diluted EPS | 83.93 | 55.03 | 64.79 |
| Public Share Holding | |||
| No Of Shares (Crores) | -- | -- | -- |
| Share Holding (%) | -- | -- | -- |
| Promoters and Promoter Group Shareholding | |||
| a) Pledged/Encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| b) Non-encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| Source : Dion Global Solutions Limited |


--- title: (Blackfynn) organizations keywords: documentation theme, jekyll, technical writers, help authoring tools, hat replacements last_updated: July 3, 2016 tags: [getting_started] sidebar: matlab_docs_sidebar permalink: blackfynn_organizations.html folder: mydoc ---
organizations Returns all organizations for the user. OUT = organizations(OBJ) returns all organizations that a user belongs to. Note: The user will need to create a separate API token for each organization in order to access the data through the API. A session can only interact with data from a single organization. Example: BF = BLACKFYNN('profile_name') BF.organizations() ans = Name Id ___________ ______________________________________ 'Blackfynn' 'N:organization:c9055555-3333-4444-...
| Access | public |
| Sealed | false |
| Static | false |


Torstar to close StarMetro national free newspaper chain, lay off 73 employees - Barriere Star Journal
by The Canadian PressCompany also announced plans to open new Star bureaus in Vancouver, Edmonton, Calgary and Halifax
Torstar Corp. will shutter its StarMetro newspapers across the country and lay off 73 staff.
A Torstar spokesperson says the StarMetro papers will publish their final editions on December 20.
The company publishes the commuter papers in Vancouver, Edmonton, Calgary, Toronto and Halifax.
A memo sent to staff from Torstar president John Boynton says the closures will affect 73 people working in editorial, advertising and distribution.
The company also announced plans to open new Star bureaus in the coming weeks in Vancouver, Edmonton, Calgary and Halifax.
The bureaus will be staffed by Star journalists who will provide local coverage.
The Canadian Press


I am currently a postgraduate student in South China University of Technology (SCUT).
My primary research interests are in the application of machine learning in medical detection, sensing, surveying, as well as the intersection of motion control and machine learning. At the same time, I am very interested in the development of algorithms to solve image data problems, such as self-supervised learning, feature-oriented label design, and efficient lightweight network design.
Email<EMAIL_ADDRESS><EMAIL_ADDRESS>Information: GitHub


Quick guide for NERSC Cori using Shifter (v1)¶
Obtaining the container image¶
Shifter is the container runtime used at NERSC to run containers. It’s an alternative to Docker, but supports Docker containers.
View the
e3sm_diags
images available at NERSC.shifterimg images | grep e3sm_diags
If the version you want to use is already available, then please continue to step 3.
Otherwise, you’ll need to download the image you want, shown in step 2.
2. If the specific version you want or the latest
image is not shown, download it.
You can view all of the images available on the
e3sm_diags Docker Hub.
Below, we are getting the image with the latest tag.
shifterimg -v pull docker:e3sm/e3sm_diags:latest
You’ll see the same message with a timestamp print multiple times. This is normal and takes around 10 minutes or so. Something’s just wrong with Shifter, we don’t know why it does that.
Once an image is downloaded from a public repo like this one, all users on NERSC can use it.
You also cannot delete an image that you downloaded via Shifter for now. Please email NERSC support and they can do that for you.
wget
the following script.wget https://raw.githubusercontent.com/E3SM-Project/e3sm_diags/master/acme_diags/container/e3sm_diags_container.py
Running the entire annual latitude-longitude contour set¶
Copy and paste the below code into
myparams.py
using your favorite text editor. Adjust any options as you like.Tip: Make a folder in the following directory
/global/project/projectdirs/acme/www/
based off your username. Then you can setresults_dir
to/global/project/projectdirs/acme/www/<username>/lat_lon_demo
inmyparams.py
below to view the results via a web browser here: http://portal.nersc.gov/project/acme/<username>/lat_lon_demoreference_data_path = '/global/project/projectdirs/acme/acme_diags/obs_for_e3sm_diags/climatology/' test_data_path = '/global/project/projectdirs/acme/acme_diags/test_model_data_for_acme_diags/climatology/' test_name = '20161118.beta0.FC5COSP.ne30_ne30.edison' sets = ["lat_lon"] seasons = ["ANN"] # 'mpl' and 'vcs' are for matplotlib or vcs plots respectively. backend = 'mpl' # Name of folder where all results will be stored. results_dir = 'lat_lon_demo'
Since Shifter cannot be ran on the login nodes, it must be ran either in an interactive session on compute nodes, or as a batch job.
There are two kinds of compute nodes on Cori:
- Cori KNL:
68 cores/node
128 GB/node
Use
-C knl
with anysalloc
orsrun
commands.
- Cori Haswell:
32 cores/node
128 GB/node
Use
-C haswell
with anysalloc
orsrun
commands.
For more information on how to run any batch job on Cori, consult the documentation here.
Interactive session on compute nodes¶
First, request an interactive session with a single node (32 cores with Cori Haswell, 68 cores with Cori KNL) for one hour (running this example should take much less than this).
If obtaining a session takes too long, try to use the debug
partition.
Note that the maximum time allowed for this partition is 00:30:00
.
salloc --nodes=1 --partition=regular --time=01:00:00 -C haswell
Once the session is available, launch E3SM Diagnostics.
python e3sm_diags_container.py --shifter -p myparams.py
Tip: You can select the version of the container you want to run with the --container_version
argument.
If this argument isn’t defined, it defaults to the latest
container.
python e3sm_diags_container.py --shifter --container_version v1.5.0 -p myparams.py
Batch job¶
Alternatively, you can also create a script and submit it to the batch system.
Copy and paste the code below into a file named diags.bash
.
Please remember to change what directory you’re in to one accessible to you.
#!/bin/bash -l #SBATCH --job-name=diags #SBATCH --output=diags.o%j #SBATCH --partition=regular #SBATCH --account=acme #SBATCH --nodes=1 #SBATCH --time=01:00:00 #SBATCH -C haswell # Please change the directory below. cd /global/cscratch1/sd/golaz/tmp wget https://raw.githubusercontent.com/E3SM-Project/e3sm_diags/master/acme_diags/container/e3sm_diags_container.py python e3sm_diags_container.py --shifter -p myparams.py
And then submit it
sbatch diags.bash
View the status of your job with squeue -u <username>
.
Here’s the meaning of some values under the State (ST
) column:
PD
: PendingR
: RunningCA
: CancelledCD
: CompletedF
: FailedTO
: TimeoutNF
: Node Failure
Back to running the latitude-longitude contour set¶
Once you ran the diagnostics in an interactive session or via a batch job, open the following webpage to view the results.
lat_lon_demo/viewer/index.html
Tip: Once you’re on the webpage for a specific plot, click on the ‘Output Metadata’ drop down menu to view the metadata for the displayed plot. Running that command allows the displayed plot to be recreated. Changing any of the options will modify the just that resulting figure.
Running all of the diagnostics sets¶
Copy and paste the following into all_sets.py
using your
favorite text editor:
reference_data_path = '/global/project/projectdirs/acme/acme_diags/obs_for_e3sm_diags/climatology/' test_data_path = '/global/project/projectdirs/acme/acme_diags/test_model_data_for_acme_diags/climatology/' test_name = '20161118.beta0.FC5COSP.ne30_ne30.edison' # Not defining a sets parameter runs all of the default sets: # ['zonal_mean_xy', 'zonal_mean_2d', 'lat_lon', 'polar', 'cosp_histogram'] # 'mpl' and 'vcs' are for matplotlib or vcs plots respectively. backend = 'mpl' # Name of folder where all results will be stored. results_dir = 'diag_demo' # Optional settings below: diff_title = 'Model - Obs' multiprocessing = True # You can set this to 64 if running on the KNL nodes. num_workers = 32
Compared to the previous short test above, note the following changes:
Plots for all the available sets (‘zonal_mean_xy’, ‘zonal_mean_2d’, ‘lat_lon’, ‘polar’, ‘cosp_histogram’) are generated.
Multiprocessing with 32 workers is enabled.
Again, run the diagnostics with this new parameter file (
all_sets.py
), either in an interactive session or via a batch job.Open the following webpage to view the results.
diags_demo/viewer/index.html
Advanced: Running custom diagnostics¶
The following steps are for ‘advanced’ users, who want to run custom diagnostics. So most users will not run the software like this.
By default, all of the E3SM diagnostics are ran for the sets that we defined above. This takes some time, so instead we create our own diagnostics to be ran.
8. Copy and paste the code below in mydiags.cfg
.
Check Available Parameters
for all available parameters.
For more examples of these types of files, look here for the cfg file that was used to create all of the latitude-longitude sets.
[#] sets = ["lat_lon"] case_id = "GPCP_v2.2" variables = ["PRECT"] ref_name = "GPCP_v2.2" reference_name = "GPCP (yrs1979-2014)" seasons = ["ANN", "DJF"] regions = ["global"] test_colormap = "WhiteBlueGreenYellowRed.rgb" reference_colormap = "WhiteBlueGreenYellowRed.rgb" diff_colormap = "BrBG" contour_levels = [0.5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16] diff_levels = [-5, -4, -3, -2, -1, -0.5, 0.5, 1, 2, 3, 4, 5] [#] sets = ["lat_lon"] case_id = "SST_CL_HadISST" variables = ["SST"] ref_name = "HadISST_CL" reference_name = "HadISST/OI.v2 (Climatology) 1982-2001" seasons = ["ANN", "MAM"] contour_levels = [-1, 0, 1, 3, 6, 9, 12, 15, 18, 20, 22, 24, 26, 28, 29] diff_levels = [-5, -4, -3, -2, -1, -0.5, -0.2, 0.2, 0.5, 1, 2, 3, 4, 5]
Run E3SM diagnostics with the
-d
parameter.python e3sm_diags_container.py --shifter -p myparams.py -d mydiags.cfg


An IP (Internet Protocol) Address is a numerical label assigned to each device connected to a computer
network that uses the IP for communication. It serves two functions: host or network interface identification
and location addressing.
There are two primary types of IP address formats used: IPv4 and IPv6.
IPv4
Internet Protocol version 4 (IPv4) defines an IP address as a 32-bit number. It consists of four sets of numbers
from 0 to 255, separated by three dots. The number is used to identify a website on the internet.
For example, the IP address of njit.edu is <IP_ADDRESS>.
The image to the right provides an example of the breakdown of an IPv4 address.
IPv6
Internet Protocol version 6 (IPv6) is a newer version, using 128 bits for the IP address.
The purpose of IPv6 allows for more unique IP address identifiers to be created.
The address format is quite different than the IPv4 version.
Using a hexadecimal notation, here is an example of the format: 3FFE:F200:0234:AB00:0123:4567:8901:ABCD
Packets
A packet is a small segment of a larger message sent over a network, such as the internet. Data sent
over computer networks are divided into packets. Similar to a real life package, information on the internet gets from one place to another via a packet.
Data travels in a less direct fashion, meaning it does not follow a fixed path. Like cars on the road,
traffic congestion may cause data to follow a different route each time it travels.
Packet switching allows packets from multiple computers to travel over the same wires. This
enables multiple connections to take place over the same networking equipment at the same time.
The result of this allows billions of devices to exchange data on the internet at the same time,
rather than just a handful of devices.
The image above illustrates how a packet is sent from one place to another, through an indirect path.
Routing
Routing is the process of choosing a path for traffic in a network or across multiple networks.
Routing is performed in many types of network, including computer networks, such as the internet,
and circuit-switched networks, such as the public switched telephone network (PSTN).
Routing directs network packets from their source toward their destination through network nodes
by specific packet forwarding mechanisms. Packet forwarding is the transit of network packets
from one network interface to another. Routing often refers to IP routing, which assumes that network
addresses are structured and similar addresses imply proximity within the network.
Routing has become dominant in addressing on the internet.


{% extends "admin/base_site.html" %} {% load i18n static %} {% block breadcrumbs %} {% include "admin/media/breadcrumbs.html" %} {% endblock %} {% block extrastyle %} {{ block.super }} {% endblock %} {% block content %} {% if perms_lacking %}
{% blocktrans %}Your account doesn't have permissions to rename all of the selected files.{% endblocktrans %}
{% else %} {% if not to_rename %}{% blocktrans %}There are no files available to rename.{% endblocktrans %}
{% else %}{% blocktrans %}The following files will be renamed (they will stay in their folders and keep original filename, only displayed filename will be changed):{% endblocktrans %}


# extends 'base.html' # import 'macro/forms.html' as forms # import 'macro/utils.html' as utils # block content
| Project | {{crash_db.project_key.get().name if crash_db.project_key else ''}} |
|---|---|
| Electron Version | {{crash_db.ver}} |
| Platform | {{crash_db.platform}} |
| Process Type | {{crash_db.process_type}} |
| GUID | {{crash_db.guid}} |
| App Version | {{crash_db.version}} |
| Product Name | {{crash_db.productName}} |
| Underlying Product | {{crash_db.prod}} |
| Company Name | {{crash_db.companyName}} |


Gold erases daily losses on US-China trade headlines, trades above $1,465
by Eren Sengezer- China is reportedly pessimistic about a trade deal with US.
- 10-year US T-bond yield is erasing nearly 1% on Monday.
- Wall Street's main indexes look to open modestly lower.
After falling to $1,456 during the European session, the XAU/USD pair gained traction in the last hour with the precious metal finding demand as a safe haven on resurfacing fears over the United States and China failing to reach a deal. As of writing, the pair was down only 0.06% on a daily basis at $1,466.20.
Trade headlines trigger flight to safety
Citing a government source, CNBC's Beijing Bureau Chief, Eunice Yoon, on Monday said China was not optimistic about reaching a trade deal with the US and claimed that China would wait for the impeachment and the election in the US while focusing on supporting its own economy.
With the initial market reaction, the 10-year US Treasury bond yield fell sharply and was last down nearly 1% on the day. Furthermore, the S&P 500 Futures turned negative on the day to reflect the souring market sentiment.
The lack of significant macroeconomic data releases from the US will cause investors to stay focused on fresh developments surrounding the US-China trade dispute.
On the other hand, the US Dollar Index stays in the negative territory below the 98 mark on Monday, allowing the risk perception to continue to drive the pair's action.
Technical levels to watch for
XAU/USD
| Overview | |
|---|---|
| Today last price | 1464.92 |
| Today Daily Change | -1.82 |
| Today Daily Change % | -0.12 |
| Today daily open | 1466.74 |
| Trends | |
|---|---|
| Daily SMA20 | 1485.11 |
| Daily SMA50 | 1492.74 |
| Daily SMA100 | 1479.29 |
| Daily SMA200 | 1394.24 |
| Levels | |
|---|---|
| Previous Daily High | 1471.5 |
| Previous Daily Low | 1462.64 |
| Previous Weekly High | 1474.6 |
| Previous Weekly Low | 1445.8 |
| Previous Monthly High | 1519.04 |
| Previous Monthly Low | 1455.5 |
| Daily Fibonacci 38.2% | 1466.03 |
| Daily Fibonacci 61.8% | 1468.12 |
| Daily Pivot Point S1 | 1462.42 |
| Daily Pivot Point S2 | 1458.1 |
| Daily Pivot Point S3 | 1453.56 |
| Daily Pivot Point R1 | 1471.28 |
| Daily Pivot Point R2 | 1475.82 |
| Daily Pivot Point R3 | 1480.13 |


1. Overview of Dukemon
Dukemon is a desktop flashcard application, which aims to streamline and gamify
the process of learning words and definitions.
The user interacts with it primarily through a CLI (Command Line Interface), with some GUI (Graphical User Interface) features.

-
Flashcards are termed as
Cards
. -
A collective set of
Cards
are termed asWordBank
. -
A general flow of Dukemon's usage is as follows:
-
Note taking phase
-
User creates/selects a
WordBank
. -
User populates the
WordBank
withCards
, or edit theCards
.
-
-
Learning phase
-
User starts the game using selected
WordBank
. -
Dukemon prompts the questions, and user has to answer accordingly.
-
Dukemon ends the game.
-
User reviews performance from statistics page.
-
-
2. Summary of contributions
2.1. Major feature
WordBank Management
-
What it does:
-
Enables user to have a high level management for his WordBanks and Cards through CLI and GUI.
Is semi-automated by Dukemon to enhance user’s learning experience.
Consists of four complementary distinct sections.-
WordBank's data structure and its storage system:
Allows developers to use and extend this architecture to streamline their feature implementation.
Allows user to save and load their WordBanks.
Is implemented with a robust underlyingWordBankList
data structure, with its ownWordBankListStorage
, along with rich integration ofModel
,Storage
,Logic
andUI
to synchronise its data. -
User Commands:
Allows user to customise Cards / WordBanks throughCardCommands
/WordBankCommands
. -
Drag and drop:
Allows user to export their WordBanks out of their computer simply by dragging it out of Dukemon.
Likewise, it allows user to import a WordBank file from their computer by dragging it into Dukemon. -
Revision WordBank:
Allows user to visit a centralised word bank that automatically collects cards for revision.
Cards that were answered wrongly are automatically added to this revision bank.
Likewise, cards that were answered correctly during game play are automatically removed from this revision bank.
-
-
-
Justification:
-
Well designed architecture and well implemented data structure streamlines integration and allows extension for features that builds on top of it. (Statistics, Game, Settings)
-
Management system is essential for a self-typed flashcard app like Dukemon.
-
Drag and drop accelerates the sharing of knowledge/notes with friends, thereby enhancing user experience.
-
Revision WordBank improves the learning process by helping the user collate cards that requires revision.
-
-
Highlights:
-
There exists multiple ways to design and implement WordBank management. Throughout Dukemon's development, it has been restructured and rewritten a few times before finally coming to how it is implemented now.
This was primarily because my teammate’s features requires heavy and continuous integration with WordBank’s management. We came together twice every week to discuss how our features should be integrated with one another.
To best implement it, I spent considerable amount of effort to study different design patterns and architectural styles, such as MVC (Model View Controller), Observer Pattern, n-Tier Style, Event-Driven Style, to realise the final design. -
Continual in-depth discussion with team member, Subbash, to find the best design to integrate user commands with his different modes.
-
Discussed with team member, Paul, who is in-charge of UI, on Observer Pattern usage to display Cards and WordBanks that automatically update itself.
-
Consulted team member, Jason, on how I can best leverage his Statistics feature to streamline my revision bank implementation.
-
Learned and adapted Callbacks and Functional Programming into my drag and drop section to preserve the quality and structural integrity of the existing code base, from team member Yi Da.
-
Individually sourced for proper online tutorials and online code references to implement drag and drop section, and design concepts such as Observer Pattern and MVC within Cards and WordBanks.
-
-
Credits:
-
Online resources
-
Teammates
-
For their continual discussion, presence and support as mentioned in my highlights above.
-
-
Tutors
-
For their unconditional effort in guiding us and providing us with valuable resources and feedback throughout Dukemon's development.
-
-
2.2. Minor features
-
Default WordBanks for new players
-
Implemented multiple user friendly word banks for user to try out. (pokemon, arithmetic, trivia, graph, cs2103t)
-
Created on the first launch of Dukemon (implemented through preferences file), and behaves like normal word bank. (Can be edited and removed)
-
Implemented the initialisation of required folders for related files automatically if not present.
-
-
User experience centric messages
-
Played the game insane amount of times to design constructive feedback to display on the command box from the user perspective.
-
Developed user friendly command usage feedback that guides the user to using Dukemon.
-
2.3. Other contributions
-
Code contributed:
-
Overall: [All Commits] [RepoSense] [GitHub]
-
Functional:
-
WordBank: [WordBank] [WordBankList]
-
Storage: [WordBank storage]
-
Commands: [Card commands] [WordBank commands]
-
Command parsers: [Card command parser] [WordBank command parser]
-
UI: [Card display] [WordBanks display]
-
Data for Dukemon: [Default data]
-
-
Tests:
-
Commands: [Card command test] [WordBank command test]
-
WordBank: [WordBank storage test]
-
Data for testing: [WordBank test data] [WordBankList test data]
-
-
-
Other contributions :
-
Discovered and fixed huge amount of bugs across different parts of Dukemon. [Issues resolved] [Bugs fixed]
-
Project management:
-
Found members and formed the team. Went extra miles to bond everyone through fine details.
-
Heavily scrutinised ideas during early stage of idea development, inorder to develop a product idea that our team can fully believe in and dedicate effort.
-
Set up organisation repo, including issues, label and milestones.
-
Set up Netlify to improve workflow.
-
Took initiative to kick start the project by scheduling meetings.
-
-
-
Documentation:
-
Wrote a major chunk of User Guide’s skeleton for my teammates (This does not include writing my own section within UG): [UG update 1] [UG update 2] [UG update 3]
-
Studied and improved styling for team’s UML diagrams. [Style.puml]
-
-
Community:
-
Reviewed PRs. (with positivity): [TimeBook] [Jason’s new command] [Yida’s clean code]
-
Reported bugs for other teams in the class, in the form of GitHub issues. [Njar]
-
-
Tools:
-
[JUnit 5] for testing.
-
[JavaFX] [SceneBuilder] for Dukemon's UI.
-
[PlantUML] for UML diagrams.
-
[Netlify] for workflow improvement.
-
3. Contributions to the User Guide
Given below are sections I contributed to the User Guide. They showcase my ability to write documentation targeting end-users. |
4. WordBank management
4.1. Drag and drop
Streamlines the process of sharing of WordBanks with friends.
→ →
From HOME
mode, you can view your WordBanks.
Simply drag and drop a WordBank json file from your computer into the Dukemon GUI.
→ →
Likewise, drag and drop a WordBank out of the application, into say,
your desktop, or chat applications.
Try it!
|
Note
|
Dukemon only accepts json files when importing WordBanks. Attempting to import or export other types files will not be successful. |
4.2. Revision WordBank
A revision bank is automatically updated for you, every time a game session ends.
It collates all your wrong cards, whichever WordBank it may have came from.
It is also smart enough to remove the cards if you have cleared it afterwards.
The revision bank is best appreciated when you actually play around with some WordBanks, and then visit the revision bank to revise wrong cards. Give it a try!
5. Contributions to the Developer Guide
Given below are sections I contributed to the Developer Guide. They showcase my ability to write technical documentation and the technical depth of my contributions to the project. |
5.1. WordBank's data structure and its storage
WordBank's storage system integration.
WordBankList
within Storage
and Model
.WordBankListStorage
consists of robust methods in which developers can use and extend upon easily.
Alongside with WordBank's data structure, they lay the foundation for the other complementary sections of WordBank Management.
On top of that, they serve as a essential foundation for Dukemon. As such, these data structures and methods were required by the team, to build individual features. (Statistics, Game, Settings)
5.2. User commands
Allows user to customise Cards and group them according to topics (WordBanks).
User commands edits and manipulates Cards and WordBanks heavily.
|
Note
|
As mentioned previously, user commands will extend and utilise WordBank's data structure and storage heavily. You can refer to it to enhance your understanding of this implementation. |
Let us first introduce you how these commands are implemented and structured in Logic
.
Logic
with emphasis on CardCommands
and WordBankCommands
.5.3. Drag and drop
Walkthrough - Drag in.
ImportCommand
and thus the WordBank's storage.LoadBankPanel
is the corresponding class and the FXML file that displays the WordBanks for the user.
It is deeply nested within UI
and only has access to an ObservableList<WordBank>
.
This means it has no way to perform commands
, update model
or update storage
.
-
To work around this, a functional callback is registered within
LoadBankPanel
. -
LoadBankPanel
registers JavaFX’s UI drag detection and drag dropped methods, with the callback. -
After which, the callback essentially performs an
ImportCommand
, to load the WordBank.
It is also noteworthy to mention that, dragging into Dukemon functionality is well guarded against:
-
Not json file format.
-
Json file but data in wrong format.
-
Json file with correct format but contains duplicate cards within.
User receives apt feedback through the command box for different cases.
This is possible with careful exceptions handling within the ImportCommand
itself.


File List Editor - File List Tab Action Menu
on the file list dialog
{bmlwd ACTFLIST.SHG}Selecting the Action button displays a pop-up menu of actions that may be performed on the selected entries in the file list.
Click on the menu entries displayed here for information on each option.
The functions in this menu are also available from the pop-up menu displayed if you right-click your mouse on the file list. Note that the right mouse button is treated in the same way as the left for selecting files; if you want to apply a command to more than one file at a time, you'll need to use shift- or control-right click in order not to lose selections you have made with the left mouse button or keyboard first.