Hamed Ghasemieh
Using nltk for preprocessing:
from nltk.corpus import stopwords
from nltk.stem.wordnet import WordNetLemmatizer
stopwords_removed = ' '.join([
i for i in str(text).lower().split()
if i not in stopwords
])
punct_removed = ''.join(
i for i in stopwords_removed
if i not in set(string.punctuation
))
lemmatized = " ".join(
WordNetLemmatizer().lemmatize(i)
for i in punct_removed.split()
)
The goal is sentiment analysis. But reviews rated as 3 do not carry positive or negative meaning. Hence for now I have decided to remove ratings of 3.
processed_df = processed_df[processed_df['rate'] != 3]
processed_df['pos'] = processed_df['rate'].
apply(lambda x: 1 if x > 3 else 0)
Typical 70-30% train and test split.
X = processed_df['processed_text'].values
y = processed_df['pos']
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test =
train_test_split(X, y, test_size=0.3, random_state=0)
Setting up pipeline and paramters:
pipeline = Pipeline([
('cvect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier()),
])
param_grid = {
'cvect__max_df': (0.5, 0.75, 1.0),
'cvect__ngram_range': ((1, 1), (1, 2)),
'tfidf__use_idf': (True, False),
'clf__loss': ('hinge', 'modified_huber', 'log'),
'clf__alpha': (0.00001, 0.000001),
'clf__penalty': ('l2', 'elasticnet'),
'clf__class_weight': (None, 'balanced')
}
Starting the search over all the parameters:
grid_search = GridSearchCV(pipeline, param_grid,
n_jobs=-1, verbose=1, cv=5)
grid_search.fit(X, y)
Confusion matrix:
| Negative | Positive | |
|---|---|---|
| Negative | 133 | 30 |
| Positive | 19 | 436 |
Classification report:
| precision | recall | f1-score | support | |
|---|---|---|---|---|
| Negative | 0.88 | 0.82 | 0.84 | 163 |
| Posative | 0.94 | 0.96 | 0.95 | 455 |
| avg / total | 0.92 | 0.92 | 0.92 | 618 |
v(King) - v(Man) + v(Woman) = v(Queen)
1) Using gensim to load GloVe already trained model:
with open(glove_embedding_path, "rb") as lines:
for line in lines:
word = str(line.split()[0])
vec = np.array(list(map(float, line.split()[1:])))
w2v[word] = vec
2) Using gensim to train based on our own data:
model = gensim.models.Word2Vec(X, size=dim)
w2v = dict(zip(self.model.wv.index2word, self.model.wv.syn0))
A document representation is then just the average of all its words:
doc_vec = np.array([np.mean([
w2v[w] for w in doc if w in w2v] or
[np.zeros(dim)], axis=0)
])
Instead of averging we can also use tf-idf for smarter weights
Confusion matrix:
| Negative | Positive | |
|---|---|---|
| Negative | 133 | 30 |
| Positive | 52 | 403 |
Classification report:
| precision | recall | f1-score | support | |
|---|---|---|---|---|
| Negative | 0.71 | 0.80 | 0.75 | 163 |
| Posative | 0.92 | 0.89 | 0.90 | 455 |
| avg / total | 0.87 | 0.86 | 0.86 | 618 |
Linear regression with ElasticNet as regularization method.
enet= ElasticNetCV(cv=5, l1_ratio=np.arange(0.1, 1.1, .1),
random_state=0, verbose=1, n_jobs=-1)
enet_pipeline = Pipeline([
('cvect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('reg', enet)
])
enet_pipeline.fit(X_train, y_train)
Confusion matrix:
| Negative | Positive | |
|---|---|---|
| Negative | 81 | 82 |
| Positive | 4 | 451 |
Classification report:
| precision | recall | f1-score | support | |
|---|---|---|---|---|
| Negative | 0.95 | 0.50 | 0.65 | 163 |
| Posative | 0.85 | 0.99 | 0.91 | 455 |
| avg / total | 0.87 | 0.86 | 0.84 | 618 |
Further from minimum ever predicted rating, higher the probability of being positive
i.e. a well calibrated (binary) classifier should classify the samples such that among the samples for which it predicted probability close to 0.8, approximately 80% actually belong to the that class.
enet = ElasticNetCV(cv=5, l1_ratio=np.arange(0.1, 1.1, .1))
enet_reg = RegressionClassifier(enet)
enet_reg.fit(X_train, y_train)
sigmoid = CalibratedClassifierCV(enet_reg, cv='prefit',
method='sigmoid')
sigmoid.fit(X_train, y_train_b)
y_pred = sigmoid.predict(X_test)
class RegressionClassifier(BaseEstimator, ClassifierMixin):
def __init__(self, regressor):
self.regressor = regressor
self.classes_ = [0, 1]
def fit(self, X, y):
self.regressor.fit(X, y)
def predict(self, X):
return [1 if x > 2.5 else 0 for x in self.regressor.predict(X)]
# More the rating more the probability of being positive
def predict_proba(self, X):
prob_pos = self.regressor.predict(X)
prob_pos = (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())
return np.array([[1 - x, x] for x in prob_pos])
Confusion matrix:
| Negative | Positive | |
|---|---|---|
| Negative | 123 | 40 |
| Positive | 21 | 434 |
Classification report:
| precision | recall | f1-score | support | |
|---|---|---|---|---|
| Negative | 0.85 | 0.75 | 0.80 | 163 |
| Posative | 0.92 | 0.95 | 0.93 | 455 |
| avg / total | 0.90 | 0.90 | 0.90 | 618 |
- get more data
- train on bigrams


After creating a Node, you will need to activate it in order to be able to connect to Kong's admin API. There can be only one active Node.
The IP or domain of Kong's admin api.
The port of Kong's admin api.


One of the great things about working in computer science - or any IT field, really - is that you always have an excuse to geek out. In fact, people pretty much expect you to. Which is a good thing, I suppose.
Among a myriad of other popular, geeky topics perfect for this are cellular automata, and more specifically Conway's Game of Life. A simple 2D simulation programme that leads to surprisingly intricate results, it is a fairly common introductory project when learning a programming language for the first time.
So I realised that I'd never actually written one of those in XSLT. This would not stand!
An XSLT stylesheet for this is fairly easy to do, like this:
]]>
This stylesheet closely follows the basic idea behind my earlier XSLT mandelbrot. Applying it to an appropriate input file will return the next generation according to Conway's original rules for his Game of Life.  It might just be the interpreter, I can't say for certain. It doesn't seem all that complex either. Maybe it's related to something about calling lots of named templates. Either way, it works and I suppose that's what counts.


--- title: Software Support Specialist company: Research In Motion Ltd. location: Waterloo, Ontario dates: Sept 2011 - Dec 2011 category: work technologies: - PHP - Oracle Database - JIRA - Rally - Perforce ---
Provided software support for several developer tools. This involved managing user permissions, answering questions, and performing administrative tasks. Created two web applications for the support team during spare time.


#include <SystemID.h>
Public Member Functions | |
| SystemID () | |
| virtual | ~SystemID () |
| virtual void | marshal (DataStream &dataStream) const |
| virtual void | unmarshal (DataStream &dataStream) |
| unsigned short | getSystemType () const |
| void | setSystemType (unsigned short pX) |
| unsigned short | getSystemName () const |
| void | setSystemName (unsigned short pX) |
| unsigned char | getSystemMode () const |
| void | setSystemMode (unsigned char pX) |
| unsigned char | getChangeOptions () const |
| void | setChangeOptions (unsigned char pX) |
| virtual int | getMarshalledSize () const |
| bool | operator== (const SystemID &rhs) const |
Protected Attributes | |
| unsigned short | _systemType |
| unsigned short | _systemName |
| unsigned char | _systemMode |
| unsigned char | _changeOptions |
Copyright (c) 2007-2009, MOVES Institute, Naval Postgraduate School. All rights reserved.
| SystemID::SystemID | ( | ) |
| SystemID::~SystemID | ( | ) | [virtual] |
| unsigned char SystemID::getChangeOptions | ( | ) | const |
| int SystemID::getMarshalledSize | ( | ) | const [virtual] |
| unsigned char SystemID::getSystemMode | ( | ) | const |
| unsigned short SystemID::getSystemName | ( | ) | const |
| unsigned short SystemID::getSystemType | ( | ) | const |
| void SystemID::marshal | ( | DataStream & | dataStream | ) | const [virtual] |
| bool SystemID::operator== | ( | const SystemID & | rhs | ) | const |
| void SystemID::setChangeOptions | ( | unsigned char | pX | ) |
| void SystemID::setSystemMode | ( | unsigned char | pX | ) |
| void SystemID::setSystemName | ( | unsigned short | pX | ) |
| void SystemID::setSystemType | ( | unsigned short | pX | ) |
| void SystemID::unmarshal | ( | DataStream & | dataStream | ) | [virtual] |
unsigned char DIS::SystemID::_changeOptions [protected] |
Change Options
unsigned char DIS::SystemID::_systemMode [protected] |
System mode
unsigned short DIS::SystemID::_systemName [protected] |
System name, an enumeration
unsigned short DIS::SystemID::_systemType [protected] |
System Type


Lab Name
In this Lab, we’ll talk about how to structure a Lab to make it easy for someone to learn from.
I try to present the information in Problem - Solution - Example format.
I generally break down labs into 20 minutes of material. I’ll present on the topic for 5-10 minutes and then I’ll have attendes run through the Lab on their own for 10-15 minutes.
Afterwards, I’ll present myself running through the lab, so that attendees can follow along and so that I can provide additional insights into the Solution / Example.
If I’m short on time or have some reason not to put the Problem and Solution information onto a github page, then I’ll just have the Example on the githbub page and explain the Problem and Solution via slides. Either way, the critical information is always being displayed in the proper order.
Note: This is just my template for doing this. Sometimes it will be necessary to break this template up into separate sections, based on the size of each individual section. That’s OK!
Problem
Maximizing engagement and learning is difficult.
Luckily there are a few small tweaks to how presenters commonly present information that can make this process much simpler. In fact, one of the big mistakes presenters make – because they have so much knowledge on the subject – is jumping right into a problem’s solution or explaining a feature.
The problem with this is that you have to meet the audience we’re they are at. As the presenter, you have ton of knowledge around (and context for) the solution.
But, the people that are attending your workshop? They come from wildly different work backgrounds.
In order to mitigate that, start by explaining the WHY the solution came to be, first. This gets everyone on the same page, so that maximal learning can take place.
Start with making sure your attendee’s understand the Problem, before trying to provide a Solution for it.
Note: Why should we start with a Problem?
To educate the viewer. Stating the Problem clearly, sets the stage for the Solution we’re providing, later. In order to persuade them to try our Solution, the viewer has has to understand what is being solved.
Make sense? If not, no worries; I’ll leave the explanation to a much smarter person:
“Convincing others that a problem is significant is an essential step.
When a problem appears insignificant, almost every solution will seem too expensive. But for a significant problem, there are usually many solutions of reasonable cost. When we disagree about whether to adopt a particular solution, we’re often actually disagreeing about the significance of the problem being solved.
The lesson here is that it is difficult but essential to describe the significance of a problem in a way that someone working in a different environment can understand.
The clearest way to do that is by showing how the problem affects real programs and real production systems.” -rsc, https://blog.golang.org/toward-go2
Solution
Once we’ve set the stage, by introducing a Problem, we’ll show the users a Solution to that problem.
Example
Once the user has seen the Solution, we’ll use a hands-on example to make it vivid and real.
These are steps the user should be running on their own.
Lab -> Presenting with Charisma Problem -> Stage Fright. It’s hard to present well, because nerves make you clam up. Solution -> Reframe anxiety as excitement, because physiologically they appear the same. Example -> Step by step through an exercise for reframing anxiety as excitement.
Wrap Up
In the wrap up, I’ll put a small recap of what the attendee accomplished.
Then I’ll ask ssk additional, bonus questions to check understanding.
- How would you do X?
- Why did we do Y, in the example?
Finally, I’ll leave a little information to lead the user towards whatever interesting topic they’ll be learning in the next Lab.


ownCloud Contacts Import
Export your ownCloud contacts to
/sdcard/Personal.vcf
and run this app to import your contacts.


Order your Pizza by clicking the button below. This will call the orderPizza API using an access token, and the API will validate it using the API's audience value.


Apache Cordova Test Dashboard
Platform
Last Commit
mobile-spec
pass % avg.
Device test breakdown (version & model)
More >
More >
Failed Assertions
Android Commit and Test Data
iOS Commit and Test Data


About Me answers
- Harp
- Born in Minnesota
- Baking
- Wild Cats
- Yoga
Top 10 Favorite xxx
- item 1
- item 1
- item 1
- item 1
"As a front-end developer, I want to give the visitors of my page a guessing game that shows my joys and talents, so they can get insight into what makes me unique."


Detailed course offerings (Time Schedule) are available for
NBIO 301 Introduction to Cellular and Molecular Neurobiology (5) NW Moody
Introduces students to the physiological and molecular properties of individual nerve cells and the synaptic connections between them, and to principles of nervous system development. Includes weekly laboratory sessions. Prerequisite: BIOL 220. Offered: W.
View course details in MyPlan: NBIO 301
NBIO 302 Introduction to Systems and Behavioral Neurobiology (3/5) NW M. BOSMA, J. SISNEROS
Introduces neuroethology, i.e., the mechanisms by which neurons and the synaptic connections among them produce sensory perceptions and complex behavioral outputs. Available with or without weekly laboratory sessions. Prerequisite: NBIO 301. Offered: A.
View course details in MyPlan: NBIO 302
NBIO 303 Neuronal Coding and Computation (1-3)
Introduces computational neuroscience, focusing on concepts that are related to neuronal and synaptic biophysics. Works through mathematical concepts and methods to describe neuronal dynamics, and introduce methods to analyze and characterize neural coding. Uses Matlab as a programming language to implement models or neuronal dynamics to perform data analysis. Prerequisite: MATH 125. Credit/no-credit only. Offered: W.
View course details in MyPlan: NBIO 303
NBIO 401 Systems Neurobiology (3) NW Robinson
Introduces students to the anatomical and physiological organization of the major sensory, motor, and associative systems of the mammalian brain. Behavioral data used to stress functional integration of systems. Includes gross brain anatomy demonstration and computer tutorials. Prerequisite: NBIO 301. Offered: Sp.
View course details in MyPlan: NBIO 401
NBIO 402 Diseases of the Nervous System (3) NW Froener, Horwitz
Introduces the basic mechanisms of mammalian nervous system function through the study of human neurological diseases that result from specific disruption of neuronal signaling. Prerequisite: NBIO 401. Offered: W.
View course details in MyPlan: NBIO 402
NBIO 403 Systems and Behavioral Neurobiology (3) NW Kim
Topics include information processing in sensory and motor systems, sensory-motor integration, learning, and memory. Using examples from the field of neuroethology, encourages students to work independently on problems taken from the recent neurobiological research literature. Prerequisite: NBIO 401. Offered: W.
View course details in MyPlan: NBIO 403
NBIO 404 Neuropharmacology (3) NW Stella
Actions of drugs on the brain at clinical, cellular, and molecular levels. Therapeutic use of drugs in treatment of neurological and psychiatric diseases. Abuse of drugs and the mechanisms of addiction, tolerance, and withdrawal. Prerequisite: NBIO 401. Offered: Sp.
View course details in MyPlan: NBIO 404
NBIO 440 Topics in Current Neurobiology Research (2, max. 6) NW
Prerequisite: NBIO 302. Credit/no-credit only.
View course details in MyPlan: NBIO 440
NBIO 450 Current Research Literature in Neurobiology (2, max. 6) NW
Weekly journal club in neurobiology. Students read and discuss original research articles in neurobiology, centered around a specific topic each quarter. Prerequisite: BIOL 220. Credit/no-credit only.
View course details in MyPlan: NBIO 450
NBIO 490 SEMINAR IN COMPUTATIONAL NEUROSCIENCE (1-3, max. 6) NW
Supervised readings and group discussions in computational neuroscience. Credit/no-credit only.
View course details in MyPlan: NBIO 490
NBIO 496 Peer Teaching Facilitator in Neurobiology (5, max. 10) M. KENNEDY
For undergraduates assisting in Neurobiology courses as facilitators. Peer Facilitators assist with laboratories, attend lectures, and attend weekly course meetings, gaining direct course experience. Does not include independent teaching or grading. Credit/no-credit only. Offered: AW.
View course details in MyPlan: NBIO 496
NBIO 499 Individual Research in Neurobiology (3-6, max. 18)
Students carry out projects in laboratories of program faculty. Prerequisite: NBIO 302.
View course details in MyPlan: NBIO 499


HTML, CSS, Bootstrap, Javascript, JSON, jQuery, Node.js, Github, mySQL, Express
A dynamic web application, containing basic gameplay functionality - including user registration, login, game creation, game execution, and game termination.
View Project
View Code on Github
A Fullstack web project displaying the use of dynamic database manipulation through the use of a classic text adventure game demo. Players will be met their demise, and their deaths will be recorded in the game and applied to an in-game listing, readable by future players
View Project
View Code on Github
A fun and interactive game for web browsers. A guessing game with random crystal values that dynamically updates the page using the jQuery library.
View Project
View Code on Github
This project allows you to add a button to the page and search for gifs of that topic. This project is useful because it allows easy searching of the Giphy website.
View Project
View Code on Github
basically a dating app. This full-stack site will take in results from your users' surveys, then compare their answers with those from other users. The app will then displays the name and picture of the user with the best overall match. Express is used to handle routing, and it is deployed using Heroku.
View Project
View Code on Github
This project is built using full stack development techniques. It uses HTML, CSS, Bootstrap, javascript, node.js, express, MySQL and the Handlebars template/library.
View Project
View Code on Github


Nigeria lawmakers want review of fuel delivery ban along borders
Fuel stations along Nigeria’s land borders have closed and prices have spiked after customs authorities banned deliveries of petroleum products to stations within 20 kilometres (12 miles) of the border in an attempt to curb smuggling.
Border communities have complained about the move however, prompting Nigeria’s lower chamber of parliament on Tuesday to call on the customs service to lift the indefinite ban.
Nigeria, Africa’s top crude oil producer imports most of its refined fuel due to the moribund state of its refineries.
Some 10-20% of Nigerian fuel is then smuggled to neighbouring countries, according to the Major Oil Marketers Association of Nigeria, as gasoline is heavily subsidised in the country.
The Nigerian Customs Service issued the directive on 6 November. The country’s land borders have been closed to trade since late August.
Several station owners in northwest Katsina state, which borders Niger, told Reuters they had to close as a result of the ban.
The lawmakers’ motion said the order “has brought untold hardship to the people of border communities. Prices have sky-rocketed and movements have been crippled”.
The motion, brought by Sada Soli, an All Progressives Congress (APC) party member from Katsina state, called on the customs agency to “review this directive with a human face”.
Customs agency spokesman Joseph Attah declined to comment on their motion. President Muhammadu Buhari, leader of the APC, is from Katsina state. His office declined to comment.
REUTERS


The overarching goal of this project is to develop a quantitative and objective measure of ciliary motion beat patterns.
Cilia are microscopic hair-like projections from cells (Fig. 1). They beat in rhythmic patterns and perform a variety of functions, such as mucociliary clearance in the lungs and generating motility for sperm. Cilia also play sensory and signaling roles that are largely understood to involve the primary cilia, but which has also been recently implicated in motile cilia. Cilia are present along almost every major organ, including but not limited to: lungs, brain, kidneys, and throat.
Because of their presence throughout nearly all the major organs of the body, ciliopathies, or diseases of the cilia, can have wide-ranging impacts. Nearly all ciliopathies are the result of genetic mutations, but these mutations can impact either proteins that form the ciliary ultrastructure, or the intraflagellar transport (IFT) system that kicks off ciliogenesis, or the formation and maintainence system for all the cilia in the body.
Currently, the identification of ciliopathies is a process involving multiple evaluation methods. One of the more well-known methods is to compute ciliary beat frequency (CBF). CBF outside of a "normal" range (10-12Hz) tends to indicate the presence of a ciliopathy. However, there are numerous confounding variables that can present as a CBF outside that range despite the absence of a ciliopathy; conversely, certain ciliopathies can present without a detectable change in CBF. Finally, there is not a well-established methodology for rigorously evaluating CBF for a given sample. Other evaluation methods--electron microscopy to examine the ciliary ultrastructure, evaluation of ciliary beat pattern--likewise have utility but are ultimately not definitive.
In this project, it's the ciliary beat pattern we are focused on. Researchers and clinicians generally recognize the presence of multiple discrete ciliary beat patterns (Fig. 2), but they are assessed entirely by manual inspection. Put another way, there is no rigorously-defined library of ciliary motion phenotypes.
We have established some methods that have proven useful for large-scale quantitative screening and analysis of ciliary motion. We first began investigating flow-based features in our 2011 conference paper[1]. We wrapped this into a full-fledged binary classifier in our landmark 2015 Science Translational Medicine publication[2], achieving over 90% classification accuracy of normal versus abnormal ciliary motion using a support vector machine trained on two different feature sets. These feature sets revealed a low-dimensional manifold where the qualitative differences between normal and abnormal ciliary motion could be easily visualized (Fig. 3).
This paper and its findings led to a multitide of additional questions, many of which we are seeking to address as part of this project.
What constitutes a "good" subspace of ciliary motion, and how could it be used to identify ciliary motion phenotypes? As indicated in Fig. 1, it's well-established that multiple ciliary motion phenotypes exist, but we have no way of quantitatively defining them. Our 2015 paper "merely" performed normal/abnormal binary classification, ignoring any other details. There is evidence to suggest these "details" may correlate with specific genetic mutations and, therefore, provide a key for rapidly screening samples. On the advanced end, being able to "generate" samples of ciliary motion that adhere to certain motion statistics would be an incredibly useful research and diagnostic tool.
How can cilia be automatically identified in video samples? This may sound like a straightforward application of semantic video segmentation (we thought the same!), but it turns out that for cilia this is a surprisingly difficult challenge to do well[3] (Fig. 4). Identifying cilia requires clever combinations of both spatial and temporal features: cilia have a texture (sometimes), and also motion (sometimes), but neither is definitive on its own. Requiring researchers or clinicians to manually annotate samples is not only extremely labor-intensive, it's also very error-prone.
How can crowdsourcing be leveraged to include expert input while still controlling for subjectivity? One of the biggest drawbacks of the current process for ciliopathy identification is that it relies heavily on manual inspection. Nevertheless, the extensive clinical and/or laboratory training that researchers undergo should not be discounted; rather, it should be included while being kept in context. Metric learning provides a promising framework for how to approach the inclusion of manual annotations into an automated pattern recognition pipeline, but there is also physical infrastructure that is required for this: how would the interface be designed not only to encourage user recruitment and retainment, but also to incentivize high-quality feedback?
How can researchers and clinicians be encouraged to share their data and analyses? Notably, no open datasets exist around cilia research, genomic or image. Furthermore, of the little bit of software developed around ciliary motion or structure analysis, none--including ours from the 2015 paper-- is available as open source. We aim to build an integrated web platform, CiliaWeb, that is a one-stop-shop for aggregating datasets (with permission, of course), building reproducible ciliary analysis pipelines, and providing high-quality interactive visualizations and feedback. We also aim to open source the analytics and visualization engines developed as part of this project, so researchers can deploy their own versions of CiliaWeb. Finally, we're looking to generate a small amount of control and experimental genomic and image data that can be openly and publicly released for others to validate our results.
Citations
This project will always be recruiting! If you are interested in joining some aspect of the project, regardless of your experience level, please contact me!
Some questions that have both been asked, or which I'm hopefully cutting off at the pass.
I'm interested in the project, but HOLY CRAP that list of topics in the postdoc job ad is HUGE! Can I still apply?
YES! That list is meant to convey the rich variety of topics spanned by this 5-year research project, and to encourage people with a variety of backgrounds to apply! Do you have highly theoretical machine learning expertise in image representations? Apply! Are you an expert on web frameworks and user interface design? Apply! Did you do some bench work and computational analysis outside of imaging? Apply!
I want to apply but my imposter syndrome is in full swing and you'll probably get more qualified candidates than me. Why should I apply?
Speaking as someone who at times has been wholesale paralyzed by imposter syndrome, I can say with confidence: you're more qualified than you think. Like any person suffering from imposter syndrome, it's far more likely that you'll be among the most qualified. So please apply! Perhaps we could jointly plot ways to keep fooling everyone around us while we do some really neat work studying cilia!
Great! Here's my CV. When do I start getting paid?
 The bottom line is that I can't guarantee funding until we've at least had a chance to speak in real-time. History (not just mine) has demonstrated that while background and experience are certainly important, far more important is how well you and I (and the rest of my research group) can work together. That can only be assessed by setting up some time to chat. Ideally this would entail taking a course with me, though I know that's not always possible. Suffice to say, we should set aside time to discuss things if you absolutely have to be guaranteed funding before you'll even consider applying.
[NOTE: The above largely applies only to doctoral student applicants. Postdoctoral candidates go through a much more formal application and interview process.]
I'm not really a team player; rather, I'm a wicked good coder who will spend nights and weekends knocking down these research questions. When can I start?
Never. The tech sector and academia at large may still be enamored with the "difficult but talented" individual, but that goes against our group ethos. Plus, "talent" and "decency" are most assuredly not mutually exclusive! We absolutely work hard, but we also explicitly focus on communication, respect, and inclusiveness.
Is this project only for doctoral students and postdocs?
Not at all! I've had quite a few very successful undergraduate students conduct research with me for course credit, for CURO, and even for transitioning into Double Dawgs. Not only that, but I'm also an active participant in the UGA Young Dawgs program and recruited students from high schools in the Athens area. My only preference for recruiting undergraduates is that you start working with me in your second or third year, so we have time to develop some momentum and develop a good professional rapport.
If you're an undergraduate and want to work on this project, just shoot me an email!
I'm a life sciences student/graduate with little to no computational experience. Should I still apply?
As long as you are open to and enthusiastic about picking up at least some computational skills, then absolutely yes! You will be expected to pick up some fundamental skills in machine learning and coding, and this will certainly comprise the majority of your work, but there will also be opportunities to do some bench and wet lab work.
I have a question that isn't answered here. How do I get it answered?
| Abstract | #1845915 |
|---|---|
| NSF Directorate | Biological Sciences (BIO) |
| NSF Division | Biological Infrastructure (DBI) |


The Glyph Of The Moon :: ver.
0.0.0
Motto:
Natal positions:
Options:
Refresh Glyph
Save to SVG
Save to PNG
Glyph
© 2016 All right reserved.


Semi Radradra reportedly willing to take a massive pay cut to return to rugby league
by Online EditorsFormer Australian winger Semi Radradra is reportedly willing to take a $2 million pay cut to join South Sydney Rabbitohs.
Radradra, who starred for Fiji at the Rugby World Cup in Japan, is homesick in France and wants to return to the NRL, according to The Daily Telegraph.
France’s cold weather and family reasons are cited as other reasons for the 27-year-old’s willingness to take a major pay cut in order to switch codes once again.
The Season: Hamilton Boys High School – Episode 2
Radradra scored 82 tries in 94 matches for Parramatta between 2013 and 2017, before joining Toulon in 2017.
Last year, he signed for Bordeaux.
The Fiji union international has been linked with the Canterbury-Bankstown Bulldogs and his former club the Eels, but reportedly prefers a move to the Rabbitohs.
“Apparently Souths are looking at every player, but first we’ve got to sort out what the go is with Sam (Burgess),” Souths hooker Damien Cook told Sporting News.
“But Semi Radradra is a quality player and he did a great job when he was in the NRL. He’d be a great asset to most clubs.
“Who knows? We will see how it plays out.”
Radradra made history at the Rugby World Cup in Japan, becoming the first tier two player to be involved in five tries in a single World Cup match in Fiji’s 45-10 win over Georgia.
He has scored five tries in 10 international Tests since making his Fiji debut last year.
AAP
In other news:


module Time:sig
..end
Time in msec.
typet =
int
val now : unit -> t
Time elapsed from the initialization of SDL (roughly, since the start of your program).
val adaptive_fps : int -> (unit -> unit) * (unit -> unit)
Create helper functions to help controlling the frame rate of the graphics
loop. This is only useful if you have your own graphics loop, and do not
use Main.run
.
adaptive_fps 60
returns two functions start,fps
. The statement
start ()
will start the timing.
At each iteration of your loop, you should call
fps ()
, which will try to sleep long enough to achieve the desired 60FPS
rate. It works on average: if some frames take longer, it will shorten the
next frame to keep up. However, it tries to be nice to the CPU: even if one
is really too slow, it will guarantee a 5ms sleep to the CPU and not
try to keep up.


Former Fed Chair Janet Yellen says odds of a recession are ‘higher than normal’
by Ben Winck, Business Insider US- Former Federal Reserve Chair Janet Yellen doesn’t anticipate a recession in the next year, but cited two factors in why she thinks “odds of a recession are higher than normal,” CNBC reported.
- Yellen pointed to growing wealth inequality and the US-China trade war as critical drivers of a potential downturn.
- Both factors drag on consumer spending through higher prices from tariffs and diminished purchasing power. A drop in consumer spending can kick off an economic contraction as companies see revenue fall and subsequently cut jobs.
- The former central bank chief also warned that the Fed may not have “as much scope” to keep the economy growing after its three rate cuts through 2019.
- Visit the Business Insider homepage for more stories.
Former Federal Reserve Chair Janet Yellen doesn’t expect a recession in 2020, but mentioned two drivers of a potential downturn in a Thursday speech, CNBC reported.
Though recession fears have subsided from their summer highs, there are still risks coming together, Yellen said. She pointed to wealth inequality and the US-China trade war as two key threats to the record-long economic expansion, and signaled that the converging risks are setting a dim tone for investors moving forward.
“I would bet there would not be a recession in the coming year,” the former central bank chief said at the World Business Forum. “But I would have to say that the odds of a recession are higher than normal and at a level that frankly I am not comfortable with.”
The growing wealth gap is keeping many Americans from reaping the benefits of economic expansion, and it’s leaving “a very substantial share of the US workforce feeling like they’re not getting ahead,” Yellen said. Greater wealth inequality can harm consumer spending and kick off a recession as companies earn less and subsequently cut jobs.
“It’s a serious economic problem and social problem because it means the gains of our economic system are not being widely shared,” the former Fed chair said.
The US-China trade war represents another major pressure on economic growth, Yellen added. The back-and-forth tariff hikes drove prices higher for consumers in both countries, and while talks of a partial trade deal have brought markets some positive news, investors are still in the dark as to when the conflict could be fully resolved.
“These tariffs are taxes on American consumers and businesses,” Yellen said. “It’s making it more difficult and more expensive to do business, to control costs, and consumers are seeing higher prices from it.”
Yellen’s stint as Fed chair from 2014 to 2018 leaves her with a better-than-usual understanding of how monetary policy can keep an economy on a healthy path. The former chief noted that, after the central bank’s three rate cuts through 2019, there’s “not as much scope as I would like to see” for the Fed to respond to a recession. She added that the current situation creates “good reason to worry.”
Now read more markets coverage from Markets Insider and Business Insider:
Xerox threatens to take its acquisition bid directly to shareholders if HP doesn’t rethink its offer
The world’s best-performing stock of 2019 just lost 98% of its value in a single morning


'Code For - 'Communities are citizens of the community gathered for the development of local communities.
80 cities in about 11 countries, including the Republic of Korea, including the US, Germany and Japan are also networking and cooperation in the name of Code for All
Developers and designers are the main open data activists, and an open source project by default.
Korea has been working with the Code for Seoul
'Code For Incheon Communities are citizens of the community gathered for the development of local communities
Start with one member on May 1, 2015, and is currently working with more than 30 people.
Gathered in one place over a week Hack night to discuss the development, design, planning and the
like will create several stunning project based on personal interests and concerns. Incheon port code is open to anyone!
Participation is voluntary groups.
Organizer, Engineer, Planner and Dancer.
Co-Organizer, Jr.Dev, Student.
Between bytes and space travel.
대전에서 막 올라온 한국 사람
Student Developer & Engineer
입코더
우주를 담다
학생 개발자
Developer
Organizer, Engineer, Planner and Dancer.
웹개발을 공부하고 있는 학생입니다.
Between bytes and space travel.
English teacher by day, super human web developer by night.
인천에서도 코딩문화가 있었으면 하는 흔한 개발자입니다. ㅋ
대전에서 막 올라온 한국 사람
3D프린팅관련된 일을 하고 코딩하는 것을 잘 모르지만 관심이 많은 메이커가 되고 싶은 사람입니다.
Co-Organizer, Jr.Dev, Student.


[INFO] 2021-02-18 21:45:30,788 com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue: Start Up:
***************************Starting Up***************************
* com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue:compareJsonArrayContains:(0) *
*****************************************************************
[DEBUG] 2021-02-18 21:45:30,789 com.thegoate.expect.ExpectEvaluator: :starting executor to evaluate expectations.
[DEBUG] 2021-02-18 21:45:30,789 com.thegoate.expect.Expectation: Expectation:evaluating expectations.

[DEBUG] 2021-02-18 21:45:30,812 com.thegoate.expect.Expectation: Expectation:evaluating expectations.
[INFO] 2021-02-18 21:45:30,814 com.thegoate.expect.validate.ValidateGoate: Expect:evaluating:actual([{'a':false,'b':3.14159'}]) contains [{'b':1.159','a':false, 'c':42}, {'b':3.14159','a':true, 'c':42}]
[DEBUG] 2021-02-18 21:45:30,815 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.json.utils.compare.tools.CompareJsonContains
[DEBUG] 2021-02-18 21:45:30,816 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.bool.CompareBooleanEqualTo
[DEBUG] 2021-02-18 21:45:30,817 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,818 com.thegoate.json.utils.compare.tools.CompareJsonContains: :b: the objects values were not equal. 3.14159' != 1.159'
[DEBUG] 2021-02-18 21:45:30,818 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.bool.CompareBooleanEqualTo
[DEBUG] 2021-02-18 21:45:30,818 com.thegoate.json.utils.compare.tools.CompareJsonContains: :a: the objects values were not equal. false != true
[DEBUG] 2021-02-18 21:45:30,819 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,820 com.thegoate.json.utils.compare.tools.CompareJsonContains: :the object was not found in the other array.

[INFO] 2021-02-18 21:45:30,879 com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue: :Failed as expected.
[INFO] 2021-02-18 21:45:30,879 com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue: Evaluate:Expectations have already been evaluated and will not be re-evaluated.
[INFO] 2021-02-18 21:45:30,880 com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue: Shut Down:
*****************************************************************
* com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue:compareJsonArrayDoesNotContains:(0) *
***************************Finished Up***************************
[INFO] 2021-02-18 21:45:30,881 com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue: Start Up:
***************************Starting Up***************************
* com.thegoate.json.staff.GetJsonByMoreThanOneFieldValue:compareJsonArrays:(0) *
*****************************************************************
[DEBUG] 2021-02-18 21:45:30,882 com.thegoate.expect.ExpectEvaluator: :starting executor to evaluate expectations.
[DEBUG] 2021-02-18 21:45:30,883 com.thegoate.expect.Expectation: Expectation:evaluating expectations.

[DEBUG] 2021-02-18 21:45:30,898 com.thegoate.expect.Expectation: Expectation:evaluating expectations.

[DEBUG] 2021-02-18 21:45:30,914 com.thegoate.expect.Expectation: Expectation:evaluating expectations.
[INFO] 2021-02-18 21:45:30,916 com.thegoate.expect.validate.ValidateGoate: Expect:evaluating:aggregations([{"aggregateFunctionType":"SUM","property":"currentAmount","value":"34146.06"},{"aggregateFunctionType":"COUNT","property":"loan.id","value":"4"}]) == [
{
"aggregateFunctionType": "SUM",
"property": "currentAmount",
"value": "34146.06"
},
{
"aggregateFunctionType": "COUNT",
"property": "loan.id",
"value": "4"
}
]
[DEBUG] 2021-02-18 21:45:30,917 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.json.utils.compare.tools.CompareJsonEqualTo
[DEBUG] 2021-02-18 21:45:30,918 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,918 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,920 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.f.CompareFloatEqualTo
[DEBUG] 2021-02-18 21:45:30,921 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,922 com.thegoate.json.utils.compare.tools.CompareJsonEqualTo: :aggregateFunctionType: the objects values were not equal. COUNT != SUM
[DEBUG] 2021-02-18 21:45:30,923 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,924 com.thegoate.json.utils.compare.tools.CompareJsonEqualTo: :property: the objects values were not equal. loan.id != currentAmount
[DEBUG] 2021-02-18 21:45:30,925 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.l.CompareLongEqualTo
[DEBUG] 2021-02-18 21:45:30,927 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.f.CompareFloatEqualTo
[DEBUG] 2021-02-18 21:45:30,927 com.thegoate.json.utils.compare.tools.CompareJsonEqualTo: :value: the objects values were not equal. 4 != 34146.06
[DEBUG] 2021-02-18 21:45:30,929 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,930 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,931 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.l.CompareLongEqualTo
[DEBUG] 2021-02-18 21:45:30,932 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,933 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,933 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.f.CompareFloatEqualTo
[DEBUG] 2021-02-18 21:45:30,934 com.thegoate.utils.compare.Compare: Compare:Found comparator: class com.thegoate.utils.compare.tools.CompareObjectEqualTo
[DEBUG] 2021-02-18 21:45:30,935 com.thegoate.json.utils.compare.tools.CompareJsonEqualTo: :aggregateFunctionType: the objects values were not equal.


A group of bits can be used to store a number as we saw in the previous section. Moreover these numbers can be manipulated by hardware to perform arithmetic operations as we will see later. However, there are other basic operations that can be performed on bits and groups of bits which we will explore in this topic and the next topics.
Note that processors rarely provide operations on individual bits, but operate on groups of bits of byte size and higher. In the following discussion we will talk about byte operations, but operations that work on 16-bit and larger values are common and behave analogously.
When performing boolean operations on bytes, words etc each bit is operated on independently. In other words there is no interaction between the bits as there is in addition or shifts.
Boolean arithmetic has some similarities to arithmetic with numbers but there are some significant differences. When performing numeric arithmetic the possible operands are infinite; when performing boolean arithmetic there are just two possible values: "TRUE" and "FALSE". (Actually we are just dealing with a special case of a more general Boolean algebra often called "set theory" where the number of operands is infinite.)
The most important boolean operations are called AND, OR and NOT. These have meanings somewhat like their meaning when used in the English language. However, as English can be imprecise we need to define their meanings exactly.
The NOT Operation
The simplest boolean operation is NOT. It takes one operand (hence it is called a unary operation) and produces the opposite value. Hence NOT(TRUE) is FALSE and NOT(NOT(TRUE)) is TRUE etc.
|
A |
NOT A |
|
0 |
1 |
|
1 |
0 |
Table 1. NOT
The AND and OR Operations
The boolean operations AND and OR take two boolean values and produces a boolean result. They are called binary operations, for the same reason that addition is called a binary operation. That is, they are "binary" because they take two operands not because they operate on binary values. To avoid this confusion they are often called "dyadic" operations which again simply means they take two operands.
The AND of two values is TRUE only if both values are TRUE; if either or both are FALSE then the result is FALSE. Similarly the OR of two values is FALSE only if both values are FALSE; if either or both are TRUE then the result is TRUE.
|
A |
B |
A AND B |
|
0 |
0 |
0 |
|
0 |
1 |
0 |
|
1 |
0 |
0 |
|
1 |
1 |
1 |
Table 2. AND
|
A |
B |
A OR B |
|
0 |
0 |
0 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
1 |
Table 3. OR
As an example consider the statements:
A. Daniel is big.
B. Daniel is strong
Hence the statement "Daniel is big AND strong" (which in English is a shorthand for "Daniel is big AND Daniel is strong") is only true if Daniel is both of these. But the statement "Daniel is big OR strong" is true if he is either (and possibly both) of these.
If you look closely at the table above for AND you will notice that AND is similar to multiplication if you consider TRUE to be one and FALSE to be zero. Similarly OR is like addition (except that 1+1 is 2). When evaluating numeric expressions traditionally multiplication has a higher precedence than addition, hence in a boolean expression AND is considered to have higher precedence than OR in many programming languages such as C (and hence in HexEdit Pro's expression evaluation). So in the statement:
A AND B OR C AND D
the AND operations are evaluated first:
(A AND B) OR (C AND D)
De Morgan's Theorem
Boolean arithmetic is unlike numeric arithmetic in many ways. For example, there is an interesting symmetry between AND and OR -- if you swap TRUE and FALSE in the above tables then all operations are the same if you also swap AND with OR.
De Morgan's Theorem is another with no analogy in numeric arithmetic. It simply states that:
NOT(A OR B) is equivalent to NOT(A) AND NOT(B)
And, by symmetry:
NOT(A AND B) is equivalent to NOT(A) OR NOT(B)
You can verify this theorem yourself by considering all possibly values in the above boolean expressions.
An example, of De Morgan's theorem is the statement:
Daniel is NOT big OR strong
which is equivalent, by De Morgan's Theorem, to:
Daniel is NOT big AND Daniel is NOT strong.
De Morgan's theorem is very useful in simplifying boolean expressions.
The Exclusive-OR Operation
In English the meaning of OR can be ambiguous. It can mean OR as discussed above but more often means exclusive-OR. For example, consider the statements:
A. Emma went by bus.
B. Emma went by train.
The statement "Emma went by bus OR train" would typically mean that she took either the bus or the train but not both. This is called exclusive-OR since one statement being TRUE automatically excludes the other. In other words, Emma can't travel by bus and train at the same time, these conditions being mutually exclusive.
To differentiate the normal OR we discussed above from exclusive-OR it is sometimes predictably called inclusive-OR. In English, if you want to use inclusive-or to explicitly include both conditions then this is often written as "and/or". For example, "Emma went by train and/or bus", which means she could have taken both (presumably changing from one to the other at some point in the journey).
Exclusive-OR is often abbreviated to "XOR" or "EOR". Similarly inclusive-OR may be abbreviated to IOR. However, plain OR always means inclusive OR.
|
A |
B |
A XOR B |
|
0 |
0 |
0 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
0 |
Table 4. Exclusive-OR
An interesting property of the exclusive-OR operation is that there is no lost information, unlike when AND or OR is used. For example, if you XOR a byte with a certain value you can get back the original value by simply XOR'ing again with the same value. In other words:
(A XOR B) XOR B is equivalent to A
This property has uses in many areas such as encryption and drawing. For example, it is common to draw cursors in XOR mode so that to erase them it is simply a matter to draw them again.
You can also use XOR for flipping selective bits in a byte. This is done by simply XORing with a byte that has the bit on for all bits to be flipped and the bit off for all bits to be unchanged.
Next topic: Numeric Operations


You've come to the right place if you want to start building F2 containers. Before continuing, make sure you've cloned the F2 repository on GitHub or downloaded the latest framework build (v1.1.1). Secondly, read about the F2 Framework. There are a few important concepts to help you better understand apps, containers and context.
To help you get started building an F2 container, browse through the resources below. To jump start your F2 container and app development, download the F2 template (which now includes a basic container) or follow the instructions below.
Download Basic F2 Container Template
To begin, you do not need to build F2 as described in the readme on GitHub. Simply download Bootstrap and save a local copy of F2.js. Also ensure you're properly configured.
Download F2.js Download Bootstrap
Create your basic container HTML template:
<!DOCTYPE html>

<title>F2 Container</title>
<link rel="stylesheet" href="/path/to/your/bootstrap.css">

Hello F2

In developing a more advanced container, the HTML document's body
element would contain additional markup and allow for specific positioning or placement of apps. Additionally, more advanced containers could introduce features and functionality to their apps in the form of authentication APIs, streaming data feeds, federated search, etc. All containers must follow the F2 design guidelines.
Create your basic F2 app manifest and save it as /path/to/your/manifest.js
using this code below. Note the path to this file should be specified in the manifestUrl
property within the _appConfigs
array in your basic container (shown above).
F2_jsonpCallback_com_your_app_id({
"scripts": [],
"styles": [],
"apps": [{
"data": {},
"html": "

Hello, world. I'm an F2 app.

"
}]
})
Note You can download the F2 container/app template instead of creating the basic app by hand.
Now with a basic container and a basic app, you can load your F2 container and expect to see:
In getting to this point, you've only scratched the surface of F2 containers and apps. Continue reading and understanding the F2 spec to build exactly the financial solutions that our customers want.
Good news! In the project repo on GitHub, you will find a basic container along with a number of sample apps which demonstrate functionality far beyond the basic app above. Once you clone or download the project repository, open the sample container by pointing your browser at:
http://localhost/F2/examples/container/
It is assumed you will be developing an F2 container locally and have a localhost
setup. The URLs mentioned in this specification also assume you have configured your F2 container to run at http://localhost/F2/
. The examples provided as part of the project repository demonstrate apps written in different languages (PHP, JavaScript, C#). While it is not a requirement you have a web server configured on your computer, it will certainly allow you to more deeply explore the sample apps.
To better understand F2 and the role of containers, you need to understand the role of apps. If you haven’t already, read more about apps in the Framework.
To get started working with or developing apps, browse to the documentation for developing apps.
Ready to start coding?
Developing F2 Containers F2.js SDK Reference
Design considerations are an important first step when creating a new container. Content can range from news to research to multimedia, and content should be presented using Progressive Enhancement, Mobile First and Responsive Design methodologies. That is to say multimedia content, for example, should be shown plugin-free (using HTML5 video or audio elements) for capable browsers and fallback to Flash-based players for browsers that do not yet support HTML5 related technologies. (VideoJS is good example of open-source JavaScript and CSS "that makes it easier to work with and build on HTML5 video, today.")
If App Developers embed URLs back to their own websites or to third party sites, URLs must be opened in a new window as to not interrupt the experience of someone using the container. If authentication is required on an App Developer's site, this can be accomplished with pass-through authentication using encrypted URLs as discussed in Single Sign On.
In order to ensure that apps built using F2 are successful, they must be accessible. As such, F2 made choices for which open-source libraries and frameworks would be leveraged to reduce the level of effort across F2 adopters.
Read more about those choices in the Framework.
Ultimately, the responsibility of app design falls on either the Container or App Developer. In many cases, Container Developers will provide App Developers will visual designs, style guides or other assets required to ensure apps have the form and function for a given container. Container Developers may also provide CSS for App Developers to adhere to—which should be easy since F2 enforces a consistent HTML structure across all containers and apps.
A container is a browser-based desktop-like application which brings F2 apps together onto a seamless user interface. It also can provide horsepower to its apps in the form of request-response web services or streaming data feeds.
For a webpage to be considered an F2 container, it must first include the F2.js JavaScript SDK. This is as simple as downloading the F2 project from GitHub and adding a script
tag to the page.

You will find a basic container in the project repo on GitHub along with a number of sample apps.
Once the script tag has been added, it is up to the Container Developer to configure and customize the container. The first step is getting a ContainerID.
To develop a production F2 container, you need a unique identifier called a ContainerID. This ContainerID will be unique to your container across the entire open financial framework ecosystem. The format of the ContainerID looks like this: com_container_companyName_containerName
, where the companyName
"namespace" is your company name and containerName
is the name of your container.
As an example, your ContainerID could look like this:
com_container_acmecorp_watchlist
If you built more than one container while working at Acme Corporation, you could create more ContainerIDs. All of these are valid:
com_container_acmecorp_activetrader
com_container_acmecorp_retail
com_container_acmecorp_mobilestreamer
To guarantee uniqueness, we will provide a ContainerID generation service that allows customization of your ContainerID in the Developer Center.
Once you have your ContainerID, start by setting up your container project. You will need at least one configuration in addition to an HTML page: the app configs. (In the GitHub repository, an example is found in /examples/container/js/sampleApps.js
.) This doesn't need to be a static javascript file like sampleApps.js
but the structure and format of the app configs is important.
An F2 Container Provider must deliver the app configs to its container before calling F2.init()
. The app configurations are represented quite simply as a list of AppConfig objects. These could be stored in a JavaScript array or in an enterprise-class database. AppConfig objects contain app meta data provided by the App Developer when he creates his app in the Developer Center.
Example AppConfig
object from an individual app:
{
appId: "com_companyName_appName",
description: "App description",
height: 500,
manifestUrl: "http://www.domain.com/manifest.js",
name: "App name"
}
Example array of AppConfig
objects for a collection of apps:
var _appConfigs = [
{
appId: "com_companyName_appName",
description: "App description",
height:500,
manifestUrl: "http://www.domain.com/manifest.js",
name: "App name"
},
{
appId: "com_companyName_appName2",
description: "App2 description",
height:100,
manifestUrl: "http://www.domain2.com/manifest.js",
name: "App2 name"
},
{
appId: "com_companyName_appName3",
description: "App3 description",
height:200,
manifestUrl: "http://www.domain3.com/manifest.js",
name: "App3 name"
}
];
The F2.js JavaScript SDK provides an API for providers to configure their containers. Every container must be setup using ContainerConfig
and the methods available.
In the container's $(document).ready()
, add the F2.init()
:
$(document).ready(function(){
F2.init({
//define ContainerConfig properties
appRender: function(appConfig, html){ ... },
beforeAppRender: function(appConfig, html){ ... },
afterAppRender: function(appConfig){ ... }
});
});
To see an more detailed example of F2.init()
, look at the sample container javascript file in the F2 repo on GitHub.
The appRender()
method allows the container to wrap an app in extra HTML. The function should accept an F2.AppConfig
object and also a string of HTML
. The extra HTML can provide links to edit app settings and remove an app from the container. See F2.Constants.Css
for CSS classes that should be applied to elements.
The beforeAppRender()
method allows the container to render HTML for an app before the AppManifest
for an app has loaded. This can be useful if the design calls for loading spinners to appear for each app before each app is loaded and rendered to the page.
The afterAppRender()
method allows the container to override how an app's HTML is inserted into the page. The function should accept an F2.AppConfig
object and also a string of HTML
.
For more information on F2.ContainerConfig
, browse to the F2.js SDK docs.
Container Developers have the opportunity to customize some user interface (UI) elements which propagate to the App Developers' toolkit in F2.js. One of those is F2.UI.Mask
. The Mask
object contains configuration defaults for the F2.UI.showMask()
and F2.UI.hideMask()
methods.
An example of setting the mask in F2.init()
:
$(document).ready(function(){
F2.init({
//define ContainerConfig properties
appRender: function(appConfig, html){ ... },
beforeAppRender: function(appConfig, html){ ... },
afterAppRender: function(appConfig){ ... },
//setup UI
UI:{
Mask:{
loadingIcon:'./img/spinner.gif',
backgroundColor: '#fff',
opacity: 0.5
}
}
});
});
Included in the F2.UI.Mask
configuration object are the following properties: backgroundColor
, loadingIcon
, opacity
, useClasses
, and zIndex
. Each of these F2.UI.Mask
properties is detailed in the F2.js SDK docs.
For more information on F2.UI
, browse to the F2.js SDK docs.
If you're looking for sample container HTML template code, jump to the Get Started section. There is also a basic F2 container/app template available for download on GitHub.
F2 is a web integration framework which means apps are inherently insecure—at least those non-secure apps. Following this spec, App Developers must avoid CSS collisions and JavaScript namespace issues to provide users with the best possible experience.
Note Continue reading for more specifics about secure apps.
As discussed in Developing F2 Containers: F2 ContainerID, to develop an F2 container, you need a unique identifier called an ContainerID. This ContainerID will be unique to your container across the entire open financial framework ecosystem. The format of the ContainerID looks like this: com_container_companyName_appName
, where the companyName
"namespace" is your company name and appName
is the name of your app.
To avoid styling conflicts or other display issues related to app-provided style sheets, App Developers must namespace their CSS selectors. While there are strict rules for App Developers, the same rules apply to Container Developers. This is especially true when implementing mutliple containers.
In the event there are multiple containers, every CSS selector in container-provided style sheets must look like this:
.com_container_companyName_appName p {
padding:5px;
}
.com_container_companyName_appName .alert {
color:red;
}
Note .com_container_companyName_appName
is prefixed on both p
and .alert
selectors.
While the CSS cascade will assign more points to IDs and prefixing F2 ContainerIDs on CSS selectors isn't required, it is recommended.
.com_container_companyName_appName #notice {
background-color:yellow;
}
Adhering to one of the OpenAjax Alliance goals, F2 also promotes the concept of an uncluttered global javascript namespace. For Container and App Developers alike, this means following this spec closely and ensuring javascript code is contained inside closures or is extended as a new namespace on F2
.
The F2.js SDK was designed with extensibility in mind and therefore custom logic can be added on the F2
namespace.
Example:
F2.extend('YourPluginName', (function(){
return {
doSomething: function(){
F2.log("Something has been done.");
}
};
})());
For more information, read Extending F2.
Apps are capable of sharing "context" with the container and other nearby apps. All apps have context which means the app "knows" who is using it and the content it contains. It is aware of an individual's data entitlements and user information that the container is requested to share (name, email, company, etc).
This means if a user wants to create a ticker-focused container so they can keep a close eye on shares of Proctor & Gamble, the container can send "symbol context" to any listening apps that are smart enough to refresh when ticker symbol PG is entered in the container's search box.
While apps can have context themselves, the responsibility for managing context switching or context passing falls on the container. The container assumes the role of a traffic cop—managing which data goes where. By using JavaScript events, the container can listen for events sent by apps and likewise apps can listen for events sent by the container. To provide a layer of security, this means apps cannot communicate directly with other apps on their own; apps must communicate via an F2 container to other apps since the container controls the F2.Events API.
Each container will be responsible for hosting the F2.js JavaScript SDK. The F2 SDK not only provides the consistent mechanism app developers have come to expect for loading their apps on the container, but also contains an event API for handling context.
Important It is important to note that while apps can have context themselves, the responsibility for managing context switching or context passing falls on the container. The container assumes the role of a traffic cop—managing which data goes where. By using JavaScript events, the container can listen for events sent by apps and likewise apps can listen for events sent by the container. This means apps cannot communicate directly with other apps on their own; apps communicate via the container to other apps since the container controls the F2.Events
API.
Let's look at some code.
In this example, the container broadcasts, or emits, a javascript event defined in F2.Events.Constants
. The F2.Events.emit()
method accepts two arguments: the event name and an optional data object.
F2.Events.emit(
F2.Constants.Events.CONTAINER_SYMBOL_CHANGE,
{
symbol: "AAPL",
name: "Apple, Inc."
}
);
To listen to the F2.Constants.Events.CONTAINER_SYMBOL_CHANGE
event inside your F2 app, you can use this code to trigger an alert dialog with the symbol:
F2.Events.on(
F2.Constants.Events.CONTAINER_SYMBOL_CHANGE,
function(data){
F2.log("The symbol was changed to " + data.symbol);
}
);
The F2.Events.on()
method accepts the event name and listener function as arguments. Read the SDK for more information.
Note For a full list of support event types, browse to the SDK for F2.Constants.Events.
Often times containers will want to send context to apps during app registration. This is possible through the AppConfig.context
property. This property can contain any javascript object—a string, a number, an array or an object.
//define app config
var _appConfigs = [
{
appId: "com_acmecorp_news",
description: "Acme Corp News",
manifestUrl: "http://www.acme.com/apps/news-manifest.js",
name: "Acme News App",
context: {
sessionId: myApp.sessionId,
someArray: [value1,value2]
}
}
];
When F2.registerApps()
is called, the appConfig
is serialized and posted to the app's manifest URL. The serialized object converts to stringified JSON:
{"appId":"com_acmecorp_news","description":"Acme Corp News","manifestUrl":"http://www.acme.com/apps/news-manifest.js","name":"Acme News App","context":{"sessionId":"12345", "someArray":["value1","value2"]}}
The appConfig
object is sent to the server using the params
querystring name as shown in the example below. This is the complete app manifest request sent by F2.registerApps()
with the appConfig
URL-encoded, of course:
http://www.acme.com/apps/news-manifest.js?params=%7B%22appId%22%3A%22com_acmecorp_news%22%2C%22description%22%3A%22Acme%20Corp%20News%22%2C%22manifestUrl%22%3A%22http%3A%2F%2Fwww.acme.com%2Fapps%2Fnews-manifest.js%22%2C%22name%22%3A%22Acme%20News%20App%22%2C%22context%22%3A%7B%22sessionId%22%3A%2212345%22%2C%20%22someArray%22%3A%5B%22value1%22%2C%22value2%22%5D%7D%7D
This demonstrates complete flexibility of passing arbitrary context values from the container to any F2 app.
In this example, your app emits an event indicating a user is looking at a different stock ticker within your app. Using F2.Events.emit()
in your code, your app broadcasts the new symbol. As with container-to-app context passing, the F2.Events.emit()
method accepts two arguments: the event name and an optional data object.
F2.Events.emit(
F2.Constants.Events.APP_SYMBOL_CHANGE,
{
symbol: "MSFT",
name: "Microsoft, Inc."
}
);
The container would need to listen to your apps' broadcasted F2.Constants.Events.APP_SYMBOL_CHANGE
event using code like this:
F2.Events.on(
F2.Constants.Events.APP_SYMBOL_CHANGE,
function(data){
F2.log("The symbol was changed to " + data.symbol);
}
);
Note For a full list of support event types, browse to the SDK for F2.Constants.Events.
Apps can also pass context between apps. If there are two or more apps on a container with similar context and the ability to receive messages (yes, through event listeners, context receiving is opt-in), apps can communicate with each other. To communicate with another app, each app will have to know the event name along with the type of data being passed. Let's take a look.
Within "App 1", context is sent using F2.Events.emit()
:
F2.Events.emit(
"buy_stock", //custom event name
{
symbol: "GOOG",
name: "Google Inc",
price: 682.68,
isAvailableToPurchase: true,
orderType: "Market Order"
}
);
Within "App 2", context is received using F2.Events.on()
:
F2.Events.on(
"buy_stock",
function(data){
if (data.isAvailableToPurchase){
F2.log("Trade ticket order for " + data.symbol + " at $" + data.price);
} else {
F2.log("This stock is not available for purchase.")
}
}
);
The examples above demonstrate simple Context objects. In the event more complex data and/or data types are needed, F2 Context can support any JavaScript object—a string, a number, a function, an array or an object.
This is an example Context object demonstrating arbitrary JavaScript objects:
F2.Events.emit(
"example_event", //custom event name
{
//number
price: 100,
//string
name: 'John Smith',
//function
callback: function(){
F2.log('Callback!');
},
//array
watchlist: ['AAPL','MSFT','GE'],
//object
userInfo: {
name: 'John Smith',
title: 'Managing Director',
groups: ['Alpha','Beta'],
sessionId:<PHONE_NUMBER>
}
}
);
If two apps want to communicate data for populating a trade ticket and execute a callback
, appclass.js code might look like this:
F2.Events.emit(
"buy_stock", //custom event name
{
symbol: "GOOG",
name: "Google Inc",
price: 682.68,
isAvailableToPurchase: true,
orderType: "Market Order",
//define callback
callback: function(data){
alert('Trade ticket populated');
}
}
);
The F2 app listening for the buy_stock
event would fire the callback
function.
F2.Events.on(
"buy_stock",
function(data){
F2.log("Trade ticket order for " + data.symbol + " at $" + data.price);
//..populate the trade ticket...
//fire the callback
if (typeof data.callback === 'function'){
data.callback();
}
}
);
Context is a term used to describe the state of an F2 container and its apps. At the same time, context is also the information passed from Container-to-App or from App-to-App or from App-to-Container. In the examples shown above, two types of context were shown: symbol and trade ticket context. It is important to realize F2.js allows client-side messaging between third parties using a collection of arbitrary name-value pairs. This provides the utmost flexibility and affords container providers the option to define context within their container.
Said another way, while { symbol:"AAPL", name: "Apple, Inc" }
can be used to communicate symbol context, developers could also use { symbol: "123456789" }
to identify Apple, Inc. The latter is more likely given not all apps would programmatically understand AAPL
but—given symbol lookup services—would understand 123456789
as the universal F2 identifier for Apple, Inc. It is clear Container and App Developers alike would prefer to communicate with a guaranteed-to-never-change universal ID for all instrument types across all asset classes. Further details will be forthcoming as the F2 specification evolves.
The process of loading apps on a container happens through a method called F2.registerApps()
. The Container Developer must call this method—which accepts two arguments, one required, one optional— after F2.init()
is called. If this method isn't called, no apps can be loaded on the container.
The two arguments provided to registerApps()
are an array of AppConfig
objects and, optionally, an array of AppManifest
objects. As F2.js parses each AppConfig
, the apps are validated, hydrated with some additional properties, and saved in F2 memory on the container.
Regardless of where the container's AppConfig comes from, integrating apps is a simple process. For the purposes of this example, we will use an Acme Corp news app.
Let's look at some container code.
First, we define the AppConfigs
in a hard-coded _appConfigs
array. Secondly, when the document is ready, we call F2.init()
and subsequently F2.registerApps()
with the single argument.
//define app config
var _appConfigs = [
{
appId: "com_acmecorp_news",
description: "Acme Corp News",
manifestUrl: "http://www.acme.com/apps/news-manifest.js",
name: "Acme News App"
}
];
$(document).ready(function(){
//init F2 container
F2.init({
//define ContainerConfig properties
appRender: function(appConfig, html){ ... },
beforeAppRender: function(appConfig, html){ ... },
afterAppRender: function(appConfig){ ... },
//setup UI
UI:{
Mask:{
loadingIcon:'./img/spinner.gif',
backgroundColor: '#fff',
opacity: 0.5
}
}
});
//load apps
F2.registerApps(_appConfigs);
});
This javascript code will insert the Acme Corp news app into the container's DOM, provided the appRender
method is configured correctly.
Alternatively, AppConfigs
could live in a database—eventually the F2 Store—at which time container developers could provide their containers with AppManifests
instead of relying on each AppConfig.manifestUrl
property to be retrieved and parsed at run time.
Such an implementation would require the container developer to make a HTTP call to a Store web service to retrieve AppConfigs
and AppManifests
. You are already familiar with what the AppConfig
looks like, but if you aren't sure what an AppManifest
looks like, take note of this empty manifest.
{
"inlineScripts":[],
"scripts":[],
"styles":[],
"apps":[{
"data":{},
"html":"",
"status":""
}]
}
Note Read more about the AppManifest.
An example of a container making a request to the F2 Store for AppConfigs
and AppManifests
:
(function(){
var _appConfigs = [], _appManifests = [];
//make request to Store web service
var $req = $.ajax({
url: 'https://store.openf2.org/getApps',
dataType: 'jsonp'
});
//parse successful response
$req.done(function(jqxhr,txtStatus){
jqxhr = jqxhr || {};
if (jqxhr.status == "good"){
_appConfigs = jqxhr.appConfigs || [];
_appManifests = jqxhr.appManifests || [];
//load
loadContainer();
} else {
F2.log("Store web service did not do something 'good'.", jqxhr, txtStatus);
}
});
//handle errors
$req.fail(function(jqxhr,txtStatus){
F2.log("Store web service failed.", jqxhr, txtStatus);
});
//wrap this up so we can call it in $req.done()
var loadContainer = function(){
$(document).ready(function(){
//init F2 container
F2.init({
//define ContainerConfig properties
appRender: function(appConfig, html){ ... },
beforeAppRender: function(appConfig, html){ ... },
afterAppRender: function(appConfig){ ... },
//setup UI
UI:{
Mask:{
loadingIcon:'./img/spinner.gif',
backgroundColor: '#fff',
opacity: 0.5
}
}
});
//load apps
F2.registerApps(_appConfigs, _appManifests);
});
}//loadContainer
})();
Important The _appConfigs
and _appManifests
arrays must be of equal length, and the object at each index must be a parallel reference. This means the AppConfig
and AppManifest
for Acme Corp's news app must be in _appConfigs[0]
and _appManifests[0]
.
There are numerous benefits to dynamic app configuration, most notably performance and security. In the dynamic model, AppManifests
have already been requested and loaded before a user opens the container reducing the overall number of outbound HTTP requests. Security is improved because Container Developers have the opportunity to parse and scrub AppManifest
contents before F2.js injects markup in the AppManifest.html
property into the container DOM.
Security is a fundamental requirement of any F2 container and many F2 apps. With that in mind, the integration of secure apps on a container requires more attention and effort. The process of app integration remains largely the same for integrating secure apps with one significant addition: a second container.
To support a secured container environment, one of the choices made when writing this specification was the inclusion of an open-source cross-domain in-browser secure messaging library. For this, F2 relies on easyXDM. EasyXDM helps front-end developers safely work around the Same Origin Policy using browser-supported techniques without compromising the user experience. For all browsers, the easyXDM transport stack offers bi-directionality, reliability, queueing and sender-verification.
The process of configuring an F2 container to be secure is identical to that of an unsecure container. As such, every container must be setup using ContainerConfig
and the methods available.
In the secure container's $(document).ready()
, add the F2.init()
:
$(document).ready(function(){
F2.init({
//define ContainerConfig properties
appRender: function(appConfig, html){ ... },
beforeAppRender: function(appConfig, html){ ... },
afterAppRender: function(appConfig){ ... }
});
});
For secure containers, an additional property must be set on the ContainerConfig
within F2.init()
. Assuiming the container is hosted at https://www.domain.com/container
, the following config would be appropriate:
$(document).ready(function(){
F2.init({
//define ContainerConfig properties
appRender: function(appConfig, html){ ... },
beforeAppRender: function(appConfig, html){ ... },
afterAppRender: function(appConfig){ ... },
secureAppPagePath: "https://secure.domain.com/container" //define secure page path
});
});
This secureAppPagePath
property allows the container to specify which page is used when loading secure apps. To guarantee security, the page must reside on a different domain than the parent container.
Important Therefore Container Developers need two containers: one non-secure (parent), one secure (child). The parent container can follow the basic template style and must call F2.init()
and F2.registerApps()
appropriately. Per the above, it must also define the secureAppPagePath
property in its ContainerConfig
. To see a working container, browse to the examples in the project repo on GitHub.
Since it will be loaded in an iframe and like its parent, the secure child container must also include a copy of the F2.js SDK. Additionally, it must also call F2.init()
with a unique ContainerConfig
.
F2.init({
appRender:function(appConfig, html) {
return [
'
',
html,
'
'
].join('');
},
afterAppRender:function(appConfig, html) { ... },
//now set this property to true to tell F2 this is the secure child frame.
isSecureAppPage:true
});
When the parent container calls registerApps()
, F2 looks at each AppConfig
for the isSecure
bool. If the property is set to true
, F2 inserts the secure app inside an iframe and instantiates the easyXDM transport stack. To see a working secure container, browse to the examples in the project repo on GitHub.
The F2.js JavaScript SDK provides utility methods for Container Developers. These are available within the F2
namespace and complete details are in the Reference documentation.
There are some utility methods provided within F2.js in the UI
namespace. These helpers are for controlling layout, showing (or hiding) loading spinners, modals, managing views within apps, and more. To see which UI
helpers are available to App Developers, read about F2.UI for apps.
For Container Developers, the use of F2's UI
is more than likely limited to customizing the design aesthetic (CSS) and configuring the UI properties.
For complete details on F2.UI
, browse to the SDK docs.
User or content entitlements are the responsibility of the App developer. Many apps will need to be decoupled from the content that they need. This could include apps like research aggregation, news filtering, streaming market data, etc. Similarly to how companies build their own websites today with their own authentication and access (or content) entitlements, F2 apps are no different.
Further details around app entitlements will be forthcoming as the F2 specification evolves.
Single sign-on (SSO) will be a shared responsibility between the Container and App Developer. In some cases, containers will want all its apps to be authenticated seamlessly for users, and that will have to be negotiated between Container and App Developers. For the purposes of this documentation, it is assumed Container Developers will build and host authentication for access to their container(s).
Once a user is authenticated on the container, how is the user then authenticated with all of the apps? Encrypted URLs.*
Note The Container Developer is free to utilize any app authentication method they deem fit. Container Developers and App Developers will need to work together to finalize the authentication details.
Implementing SSO using encrypted URLs is a simple and straight-forward authentication mechanism for securing cross-domain multi-provider apps. To guarantee security between the Container and App Developers, secure API contracts must be negotiated. This includes, but is not limited to, the choice of cryptographic algorithm (such as AES
) and the exchange of public keys.
When the Container Developer calls F2.registerApps()
, custom logic should be added to append encrypted user credentials—on a need-to-know basis—to each app requiring authentication.
Authentication is a critical part of any container-app relationship. There are a plethora of SSO implementations and there are many considerations for both Container and App Developers alike.
Further details around container and app single sign-on will be forthcoming as the F2 specification evolves.


public class Ke2Gems
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
static int |
ALIGNED_WITH_DIAMONDS
Gem is aligned with Yellow/Blue.
|
static int |
ALIGNED_WITH_ITSELF
Gem is aligned with itself.
|
static int |
ALIGNED_WITH_NOBODY
Gem isn't aligned yet, lost/emerged.
|
static int |
ALIGNED_WITH_PLAYERS
Gem is aligned to one or more players.
|
static int |
ALIGNED_WITH_REBELS
Gem is aligned with Pink/Rose/Steven.
|
static int |
BASIC_BLACK
Dye damage is 15, block meta is 0.
|
static int |
BASIC_BLUE
Dye damage is 11, block meta is 4.
|
static int |
BASIC_BROWN
Dye damage is 12, block meta is 3.
|
static int |
BASIC_CYAN
Dye damage is 9, block meta is 6.
|
static int |
BASIC_GRAY
Dye damage is 7, block meta is 8.
|
static int |
BASIC_GREEN
Dye damage is 13, block meta is 2.
|
static int |
BASIC_LIGHTBLUE
Dye damage is 3, block meta is 12.
|
static int |
BASIC_LIME
Dye damage is 5, block meta is 10.
|
static int |
BASIC_MAGENTA
Dye damage is 2, block meta is 13.
|
static int |
BASIC_ORANGE
Dye damage is 1, block meta is 14.
|
static int |
BASIC_PINK
Dye damage is 6, block meta is 9.
|
static int |
BASIC_PURPLE
Dye damage is 10, block meta is 5.
|
static int |
BASIC_RED
Dye damage is 14, block meta is 1.
|
static int |
BASIC_SILVER
Dye damage is 8, block meta is 7.
|
static int |
BASIC_WHITE
Dye damage is 0, block meta is 15.
|
static int |
BASIC_YELLOW
Dye damage is 4, block meta is 11.
|
static int |
BLOCK_BLACK
Dye damage is 15, block meta is 0.
|
static int |
BLOCK_BLUE
Dye damage is 11, block meta is 4.
|
static int |
BLOCK_BROWN
Dye damage is 12, block meta is 3.
|
static int |
BLOCK_CYAN
Dye damage is 9, block meta is 6.
|
static int |
BLOCK_GRAY
Dye damage is 7, block meta is 8.
|
static int |
BLOCK_GREEN
Dye damage is 13, block meta is 2.
|
static int |
BLOCK_LIGHTBLUE
Dye damage is 3, block meta is 12.
|
static int |
BLOCK_LIME
Dye damage is 5, block meta is 10.
|
static int |
BLOCK_MAGENTA
Dye damage is 2, block meta is 13.
|
static int |
BLOCK_ORANGE
Dye damage is 1, block meta is 14.
|
static int |
BLOCK_PINK
Dye damage is 6, block meta is 9.
|
static int |
BLOCK_PURPLE
Dye damage is 10, block meta is 5.
|
static int |
BLOCK_RED
Dye damage is 14, block meta is 1.
|
static int |
BLOCK_SILVER
Dye damage is 8, block meta is 7.
|
static int |
BLOCK_WHITE
Dye damage is 0, block meta is 15.
|
static int |
BLOCK_YELLOW
Dye damage is 4, block meta is 11.
|
static int |
CONTROLLED_BY_WHITE
Gem is controlled and owned by White.
|
static int |
CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_DIAMONDS
Gem is controlled by White but reverts to Yellow/Blue's ownership.
|
static int |
CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_ITSELF
Gem is controlled by White but reverts to self ownership.
|
static int |
CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_PLAYERS
Gem is controlled by White but reverts to player ownership.
|
static int |
CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_REBELS
Gem is controlled by White but reverts to Pink/Rose/Steven's ownership.
|
static java.util.HashMap<ItemGemstone,ItemGemstone> |
CRACKED_TO_NORMAL |
static float |
EMOTION_ANGER
The pure power that causes those to fight.
|
static float |
EMOTION_DOUBT
When your brain is deciding to fight or flee.
|
static float |
EMOTION_DREAD
The pure terror that causes those to flee.
|
static float |
EMOTION_GRIEF
The feeling of having lost something.
|
static float |
EMOTION_HAPPY
The feeling of being content and satisfied.
|
static float |
EMOTION_HYPED
Sudden barrage of input that speeds up a gem.
|
static float |
EMOTION_LIMIT
Used to reset the emotional spectrum.
|
static float |
EMOTION_PRIDE
Self-justification that increases attack potency.
|
static float |
EMOTION_SHAME
Self-deprecation that lowers attack potency.
|
static int[] |
EMOTIONAL_WAVELENGTHS
Used for colormatching to emotional deficiencies.
|
static int |
GEMSTONE_BACK
Back placement; analogous to Virgo.
|
static int |
GEMSTONE_BACK_OF_HEAD
Back of head placement; analogous to Taurus.
|
static int |
GEMSTONE_CHEST
Chest placement; analogous to Cancer.
|
static int |
GEMSTONE_FOREHEAD
Forehead placement; analogous to Aquarius.
|
static int |
GEMSTONE_LEFT_EYE
Eye placement; analogous to Scorpio.
|
static int |
GEMSTONE_LEFT_FOOT
Foot placement; analogous to Pisces.
|
static int |
GEMSTONE_LEFT_HAND
Hand placement; analogous to Gemini.
|
static int |
GEMSTONE_LEFT_KNEE
Knee placement; analogous to Capricorn.
|
static int |
GEMSTONE_LEFT_SHOULDER
Shoulder placement; analogous to Libra.
|
static int |
GEMSTONE_LEFT_THIGH
Thigh placement; analogous to Sagittarius.
|
static int |
GEMSTONE_NAVEL
Navel placement; analogous to Leo.
|
static int |
GEMSTONE_NOSE
Nose placement; analogous to Aries.
|
static int |
GEMSTONE_RIGHT_EYE
Eye placement; analogous to Scorpio.
|
static int |
GEMSTONE_RIGHT_FOOT
Foot placement; analogous to Pisces.
|
static int |
GEMSTONE_RIGHT_HAND
Hand placement; analogous to Gemini.
|
static int |
GEMSTONE_RIGHT_KNEE
Knee placement; analogous to Capricorn.
|
static int |
GEMSTONE_RIGHT_SHOULDER
Shoulder placement; analogous to Libra.
|
static int |
GEMSTONE_RIGHT_THIGH
Thigh placement; analogous to Sagittarius.
|
static java.util.ArrayList<ItemGemstone> |
GEMSTONES |
static java.util.HashMap<ItemGemstone,ItemGemstone> |
NORMAL_TO_CRACKED |
static java.util.HashMap<net.minecraft.util.ResourceLocation,java.lang.Class<? extends EntityGem>> |
REGISTRY |
static java.util.HashMap<java.lang.Class<? extends EntityGem>,net.minecraft.util.ResourceLocation> |
REGISTRY_REVERSE |
| Constructor and Description |
|---|
Ke2Gems() |
| Modifier and Type | Method and Description |
|---|---|
static void |
registerGemEntity(net.minecraft.util.ResourceLocation loc,
java.lang.Class<? extends EntityGem> entity) |
public static final java.util.HashMap<net.minecraft.util.ResourceLocation,java.lang.Class<? extends EntityGem>> REGISTRY
public static final java.util.HashMap<java.lang.Class<? extends EntityGem>,net.minecraft.util.ResourceLocation> REGISTRY_REVERSE
public static final java.util.ArrayList<ItemGemstone> GEMSTONES
public static final java.util.HashMap<ItemGemstone,ItemGemstone> NORMAL_TO_CRACKED
public static final java.util.HashMap<ItemGemstone,ItemGemstone> CRACKED_TO_NORMAL
public static final int ALIGNED_WITH_NOBODY
public static final int ALIGNED_WITH_PLAYERS
public static final int ALIGNED_WITH_DIAMONDS
public static final int ALIGNED_WITH_REBELS
public static final int ALIGNED_WITH_ITSELF
public static final int CONTROLLED_BY_WHITE
public static final int CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_PLAYERS
public static final int CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_DIAMONDS
public static final int CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_REBELS
public static final int CONTROLLED_BY_WHITE_BUT_ALIGNED_WITH_ITSELF
public static final int GEMSTONE_FOREHEAD
public static final int GEMSTONE_BACK_OF_HEAD
public static final int GEMSTONE_RIGHT_EYE
public static final int GEMSTONE_LEFT_EYE
public static final int GEMSTONE_NOSE
public static final int GEMSTONE_RIGHT_SHOULDER
public static final int GEMSTONE_LEFT_SHOULDER
public static final int GEMSTONE_RIGHT_HAND
public static final int GEMSTONE_LEFT_HAND
public static final int GEMSTONE_CHEST
public static final int GEMSTONE_BACK
public static final int GEMSTONE_NAVEL
public static final int GEMSTONE_RIGHT_THIGH
public static final int GEMSTONE_LEFT_THIGH
public static final int GEMSTONE_RIGHT_KNEE
public static final int GEMSTONE_LEFT_KNEE
public static final int GEMSTONE_RIGHT_FOOT
public static final int GEMSTONE_LEFT_FOOT
public static final float EMOTION_DREAD
public static final float EMOTION_GRIEF
public static final float EMOTION_DOUBT
public static final float EMOTION_SHAME
public static final float EMOTION_HYPED
public static final float EMOTION_HAPPY
public static final float EMOTION_PRIDE
public static final float EMOTION_ANGER
public static final float EMOTION_LIMIT
public static final int[] EMOTIONAL_WAVELENGTHS
public static final int BASIC_WHITE
public static final int BASIC_ORANGE
public static final int BASIC_MAGENTA
public static final int BASIC_LIGHTBLUE
public static final int BASIC_YELLOW
public static final int BASIC_LIME
public static final int BASIC_PINK
public static final int BASIC_GRAY
public static final int BASIC_SILVER
public static final int BASIC_CYAN
public static final int BASIC_PURPLE
public static final int BASIC_BLUE
public static final int BASIC_BROWN
public static final int BASIC_GREEN
public static final int BASIC_RED
public static final int BASIC_BLACK
public static final int BLOCK_WHITE
public static final int BLOCK_ORANGE
public static final int BLOCK_MAGENTA
public static final int BLOCK_LIGHTBLUE
public static final int BLOCK_YELLOW
public static final int BLOCK_LIME
public static final int BLOCK_PINK
public static final int BLOCK_GRAY
public static final int BLOCK_SILVER
public static final int BLOCK_CYAN
public static final int BLOCK_PURPLE
public static final int BLOCK_BLUE
public static final int BLOCK_BROWN
public static final int BLOCK_GREEN
public static final int BLOCK_RED
public static final int BLOCK_BLACK
public static void registerGemEntity(net.minecraft.util.ResourceLocation loc, java.lang.Class<? extends EntityGem> entity)


This demo page shows how to use the Media Capture and Streams API for capturing photos from webcam video streams through a canvas. There are three major steps:
When there are multiple webcam devices, you can switch the webcams when you are using a browser that supports the API for capture device enumeration and selection.


--- redirect_from: - /fhir/CodeSystem/ ---
| SHR Namespace | Name | Definition |
| Adverse | AttributionCategoryCS | Whether the adverse event is attributed to a treatment, course of the disease, medical error, unrelated to either, or unknown. |
| Base | ProposedStatusCS | The status of a proposal. |
| Behavior | AlcoholUseScreeningToolCS | |
| Behavior | DietFollowedCS | |
| Behavior | DietNutritionConcernCS | |
| Behavior | PhysicalActivityLimitationCS | |
| Behavior | ReligiousPracticeStatusCS | |
| Behavior | ReligiousRestrictionCS | Includes religious restrictions that could impact care, other than dietary restrictions (handled elsewhere). |
| Behavior | SleepQualityCauseCS | |
| Behavior | SubstanceAbuseTreatmentTypeCS | |
| Condition | ConditionCategoryCS | |
| Core | CodingQualifierCS | |
| Core | PerformanceGradingScaleCS | A simple performance grading scale. Also useful for grading quality. |
| Core | QualitativeDateTimeCS | |
| Core | QualitativeFrequencyCS | |
| Core | QualitativeLikelihoodCS | The likelihood of an event or state, expressed qualitatively. Qualitative likelihoods are associated with judgments and assessments. Values are based on US Intelligence Community's standard language used to describe judgements of likelihood. |
| Core | QualitativeValueScaleCS | |
| Core | SemiquantitativeDurationCS | |
| Core | SemiquantitativeFrequencyCS | |
| Core | SettingCS | What type of place is found at a given location. More than one descriptor may be applicable. |
| Core | ThreePriorityCS | |
| Core | YesNoCS | |
| Core | YesNoUnknownCS | |
| Device | RespiratoryAssistDeviceCS | |
| Device | RespiratoryRateSettingCS | |
| Encounter | EpisodeOfCareCompletionCS | |
| Encounter | ReasonEncounterDidNotHappenCS | |
| Encounter | ReferralSourceTypeCS | |
| Encounter | TreatmentCooperationCS | |
| Entity | LanguageQualifierCS | |
| Entity | TelecomQualifierCS | |
| Environment | CoinhabitantCS | |
| Environment | CommonAnimalCS | |
| Environment | ExposureReasonCS | The reason that an exposure occurred. |
| Environment | HomeEnvironmentRiskCS | |
| Environment | IncomeSourceCS | |
| Environment | NonCashBenefitCS | |
| Environment | ResourceStabilityCS | |
| Financial | InsuranceProviderTypeCS | |
| Finding | ValueAbsentReasonCS | Reasons that a value associated with a test or other finding is missing. |
| Lifehistory | EducationalAttainmentCS | |
| Lifehistory | EmploymentStatusCS | |
| Lifehistory | MilitaryServiceDischargeStatusCS | |
| Lifehistory | MilitaryServiceEraCS | Values were taken from Final HMIS Data Standards March 2010 (Homeless Management Information System), field 5.05E Veteran’s Information. See: https://www.onecpd.info/resources/documents/FinalHMISDataStandards_March2010.pdf. |
| Lifehistory | MilitaryStatusCS | |
| Lifehistory | TeratogenCS | |
| Lifehistory | USMilitaryBranchCS | |
| Medication | MedicationChangeReasonCS | |
| Medication | MedicationChangeTypeCS | |
| Medication | MedicationNotUsedReasonCS | |
| Oncology | BrcaReceptorStatusCS | Classification of receptor status in breast cancer. |
| Oncology | DecileCS | Division of percentages into 10% intervals. |
| Oncology | DegreeOfLymphaticInvolvementCS | |
| Oncology | HER2MethodCS | |
| Oncology | StagingMethodCS | The methodology or standard used to do the staging. |
| Oncology | StagingTimeCS | When staging was done, relative to treatment events. |
| Research | ResearchSubjectTerminationReasonCS | The reason for a research subject leaving a research study. |
| Research | StudyArmTypeCS | The role of each arm in the clinical trial. |
| Sex | ContraceptiveMethodCS | |
| Sex | ContraceptiveMethodReasonCS | |
| Sex | ContraceptiveNotUsedReasonCS | |
| Sex | GenderIdentityCS | |
| Skin | SupportSurfaceBodyPositionCS | |
| Skin | SupportSurfaceCategoryCS | |
| Skin | SupportSurfaceComponentCS | |
| Skin | SupportSurfaceFeatureCS | |
| Skin | WoundAssociationCS | |
| Vital | BloodPressureMethodCS | The method used to measure blood pressure. |
| Vital | BloodPressureQualifierCS | Code further describing the blood pressure measurement. |
| Vital | BodyHeightQualifierCS | |
| Vital | BodyTemperatureQualifierCS | |
| Vital | BodyWeightQualifierCS | |
| Vital | HeartRateMethodCS | Method of measuring heart rate. |
| Vital | HeartRateQualifierCS | Details of a heart rate measurement. |
| Vital | RespiratoryRateMethodCS | Methods of measuring respiratory rate. |
| Vital | RespiratoryRateQualifierCS | Details of a respiratory rate measurement. |


|
NCT00374309
|
Phase I
|
| Sept 2006 |
31 |
Ad5 IM
2 × 10
9 or 2 × 10
10 VP Antigen: GP EBOV and SUDV
|
Safety:
Acceptable safety profile
Immunogenicity:
- Antibody responses in 100% (SUDV GP) and 55% (EBOV GP) of subjects in the higher dose group- No significant induction of VNTs - T cell responses in 82% (SUDV GP) and 64% (EBOV GP)
Of note: Reduced immunogenicity in participants with pre-existing immunity against Ad5
|
|
NCT02326194
|
Phase I
|
| Dec 2014 |
120 |
Ad5 IM
4 × 10
10 or 1.6 × 10
11 VP Antigen: GP EBOV (2014)
|
Safety: No serious adverse events.
Immunogenicity:
- Antibody responses in all but two participants (lower dose) and all (higher dose group) by d28
- Specific T cell responses (by ELISPOT and ICS);
Of note: high dose of Ad5 vector able to overcome negative effects of pre-existing immunity
|
|
NCT02575456
|
Phase II
|
| Oct 2015 |
500 |
Ad5 IM
8 × 10
10 or 1.6 × 10
11 VP Antigen: GP EBOV (2014)
|
Results not yet publicly available |
|
NCT02269423; NCT02280408
|
Phase I
|
| Oct 2014 |
78 |
VSV, attenuated
one or two doses IM 1 × 10
6, 2 × 10
7 and 1 × 10
8 PFU Antigen: GP EBOV (1995)
|
Safety:
Mild adverse events, no cases of arthritis
Immunogenicity:
- Antibody titers in all participants by day 28
- Increased levels of total and VNTs upon delivery of higher doses
|
|
NCT02231866; NCT02240875
*
; NCT02267109
*
|
Phase I
|
| Aug 2014–Aug 2017 |
325 |
ChAd3, replication deficient
Single dose IM 1 × 10
10, 2.0 × 10
10, 2.5 × 10
10, 5 × 10
10, 1 × 10
11, 2.0 × 10
11 VP Antigen: GP EBOV (1976) ± GP SUDV (1977)
|
Safety:
Acceptable safety profile, mild to moderate adverse events.
Immunogenicity:
- Antibody responses in almost all subjects; indications for durability (significant antibody titers detectable up to 48 weeks post vaccination)
- VNTs in some subjects
- Antigen-specific CD4
+ and CD8
+ T cells in some subjects
- Increased immune responses upon MVA boost
|
|
NCT02289027; NCT02344407
**
; (NCT02485301); (NCT02548078)
|
Phase I/II
|
Oct 2014
- Nov 2015
|
5244 |
ChAd3, replication deficient
Single dose IM 2.5 × 10
10, 5 × 10
10, 1 × 10
11 VP Antigen: GP EBOV (1976)
|
Safety:
NCT02289027: Acceptable safety profile NCT02344407: serious adverse events within 12 months after inj. in 8.0% (40/500) of participants (9.4% in rVSV-ZEBOV)
Immunogenicity:
NCT02289027
- Antibody responses peaked at d28 (51 μg/ml high dose group); still significantly over placebo at d180 (25.5 μg/ml)
- CD4
+ and CD8
+ T cell responses in 57% (28/49) and 67% NCT02344407
- Antibody responses in 70.8 and 63.5% of the participants at 1 and 12 months, respectively (83.7 and 79.5% for VSV-ZEBOV)
|
|
NCT02283099; NCT02296983; NCT02287480
|
Phase I; Phase I/II
|
| Nov 2014 |
158 |
VSV, attenuated
single dose IM 3 × 10
5, 3 × 10
6, 1 × 10
7, 2 × 10
7, 5 × 10
7 PFU Antigen: GP EBOV (1995)
|
Safety:
Doses of 1 × 10
7 PFU or higher:
- Arthralgia in 22% (11/51) participants of Geneva cohort; arthritis confirmed in 9/ 11 cases; maculopapular rash in 27% (3/11) of these cases
- Self-limiting cases of arthritis in 3.4% (2/60) participants in Germany and Kenya cohort Dose of 3 × 10
5 PFU:
- Reduced adverse events in mild to moderate range with arthralgia in 23% (13/56) participants
Immunogenicity:
- Antibody responses in all subjects; persisted for 6 months
- Dose dep. VNTs in 85% (107/126) of vaccinees
|
|
NCT02378753
|
Phase II/III
|
| March 2015 |
7651 |
VSV, attenuated
single dose IM 2 × 10
7 PFU Antigen: GP EBOV (1995)
|
Safety:
Acceptable, one serious adverse event
Immunogenicity:
- Ring vaccination approach; 48 clusters (4,123 people) and 42 clusters (3528 people) randomly assigned to immediate and delayed vaccination (21 days later)
- No cases of Ebola virus disease with symptom onset at least 10 days after randomization (immediate vaccination), 16 cases from seven clusters (delayed vaccination) 100% vaccination efficacy
|
This table exclusively lists exemplary clinical trials discussed in the text. Ad5, Adenovirus 5; EBOV, Ebola virus; GP, Glycoprotein; ICS, intracellular staining; IM, intramuscular; N, number of study participants; PFU, Plaque Forming Unit; SUDV, Sudan virus; VNT, virus neutralization titers; VSV, vesicular stomatitis virus; VP, viral particles.
*
Boost with MVA based vaccine evaluated;
**
Direct comparison with rVSV-ZEBOV arm.


Which feminist icon are you?
Take the quiz to find out!
QUIZ
Scroll down for more...
Home
Contact
About
SHARE