# Introduction to Reactive Programming
This is a fast, non-technical introduction to functional reactive programming in
Javascript. We start with a quick overview of the idea, look at some
pseudocode, discuss why any of this matters; then we look at some popular
libraries; finally, we implement one ourselves, to really drive the concept
home.
In the process, we'll implement a small project: #whargarbl.
Buckle up: this is a fun ride.
# Table of Contents
1. [What is `reactive programming`](#what-is-reactive-programming-)?
1. TL;DR (Too Long; Didn't Read)
1. No, seriously, what is `reactive`?
1. Spreadsheet example
1. Relationships vs values; time
1. What is `functional reactive programming` ?
1. What we'll do
1. Popular JS `reactive` libraries
1. Well established libraries
1. Bacon.js
1. Kefir.js
1. Reactivex
1. Summary
1. Building a modest one ourselves
1. Getting Started
1. The plan (ish)
1. Building a rig
1. Milestones
1. Step 1 - Can read const `reactive`ly
1. Step 2 - Mutable JRV
1. Step 3 - Values propagate and cache
1. Step 4 - Values have handlers
1. Step 5 - Dirty flag for lazy recalc
1. Step 6 - pure call handler
1. Step 7 - JRV options
1. Option 1 - should re-handle/debounce for same-assign?
1. Option 2 - should immediate recalc w/o handler?
1. Taking it for a spin
1. Implementing a Side Project Revenue calculator
1. Worldview issues
1. Benefits
2. Detriments
3. Alternatives
4. Paradigms
1. Conclusion
# What is reactive programming?
Reactive programming is about declaring relationships outside of time, not
current values.
Reactive relationships keep their results up to date.
## TL;DR (Too Long; Didn't Read)
*Generally speaking, `reactive` means "things are kept up to date."*
It's what you're used to from Excel.
### No, seriously, what is `reactive`?
In standard imperative and other non-reactive programming, we set variables to
values at any given time.
```javascript
const A = 1, B = 2, Sum = A+B;
console.log(`Old sum: ${Sum}`);
A = 10;
console.log(`New sum: ${Sum}`);
```
1. That first `console.log` should say that `Sum` is `11`.
1. The second `console.log` should still say that `Sum` is `11`, because the
addition was done at a specific time, before the change happened.
1. *In languages with a `reactive` notation*, like in spreadsheets, `Sum` would
change to `21` in the second `console.log`.
That is, in `reactive` languages, *what `Sum` expresses is addition of `A` and
`B` as a continuing relationship*, not the immediate result value.
Many of the features of programming languages aim to remove burden from
programmers, such as manual memory management, loop control, or socket handling.
Reactive programming aims to allow programmers to remove updating related values
from their workload.
## Spreadsheet example
Spreadsheets have come up often already; let's make a direct example.
Spreadsheets are, essentially, reactive programming systems. For example, in
Excel, this would be written as
| | A | B |
|:---:|:------------- |:-------- |
| 1 | `5` | JS "A" |
| 2 | `6` | JS "B" |
| 3 | `=SUM(A1,A2)` | JS "Sum" |
This should render with `11` in `A3`. If you then change the value in `A1` to
`15`, in response `A3` should change to `21` on its own - without prompting.
This is simple `reactive` programming.
Our goal in this tutorial is to understand programming in this fashion, and then
to implement a practical such system in Javascript.
## Relationships vs values; time
Reactive programming is a fair shift in mindset. One useful early way to look
at it as "binding relationships, instead of values."
Think about CSS for a moment. Many of its values are ratios (percentages in
columns and tables, particularly.) Computed values are explicitly functions
that get kept up to date. Transitions and animations are relationships
described by labels that are kept up to date through a time process for you.
Reactive programming is, in one sense, programming independent of time. If I
can say that a value bears this relationship to these other values, and then
trust that the relationships are maintained, then I don't need to worry whether
a given value is up to date, or implement keeping it so.
A large proportion of many programs has to do with updating, maintaining, and
propogating values throughout the app. Having this supported underneath means
less work in management, and removes a bunch of opportunities for error.
## What is `functional reactive programming` ?
We're not going to cover FRP here, but, the short version is, if you're going
to the extent that a `Haskell`, `OCaml`, or `LISP` person would, and nailing
your RP system down with math, then you're probably doing one of the forms of
FRP. Arrows-based FRP is an example, if you want to go Googling, but for now,
let's just keep it friendly and simple.
Mostly this topic is here to clarify that no, we are not going to that level of
strictness in our system.
## What we'll do
This tutorial will give a quick overview of Reactive solutions already out there
for Javascript, then dive into a direct, simple implementation of Reactive
programming in JS. It's much easier to understand Reactive after one has gotten
one's hands dirty in building a system directly.
After that, we'll move ahead to make a project with our Reactive system, to see
how it feels in practice.
# Popular JS `reactive` libraries
To be clear, if you're going to use this stuff in production, you're much better
off with a well established `reactive` library with a long history, battle
scars, and an active community. We're just building one from scratch because
that's how one learns these best.
## Well established libraries
Generally I would advocate one of three libraries in the JS world.
### Bacon.js
Bacon arguably popularised RP in the Javascript world. Bacon has a very
strictly defined order of events, meaning that even strange edge cases are
handled in a very well defined (although frequently hard to suss out) fashion.
If you're a bank, use Bacon.
### Kefir.js
Kefir is less uptight. Bacon pays a price in speed for its strictness; Kefir
is what you'll want to use for less agonizingly strict work. It also has a
rather nicer API, in my opinion.
### Reactivex
Reactivex' biggest advantage is that it's been implemented in more than a dozen
languages. You can rely of Reactivex to be present not only in today's backend,
but if it's not hipster nonsense, most likely in tomorrow's as well. If you're
trying to use reactive in complex service situations, this is oftentimes an
absolute necessity, and Reactivex then becomes the only game in town.
## Summary
As you can see from even this brief glimpse, there are tradeoffs to be had in
your choice of implementation.
Either way, it's time to get on to the meat of the project: implementing our
own.
# Building a modest one ourselves
A person often won't understand a thing until they've hacked one together.
Let's do a low-quality `reactive` system. We won't put much effort in; as a
result it will be slow, vulnerable to injection attack, and very easy to kill
with cycles.
On the bright side, it'll be easy, and then `reactive` should be clearer.
Let's toss something together.
## Getting Started
To begin with, let's put three other Github repos on your radar:
1. Each major step in the tutorial process has a step in the
[JRV Tutorial](https://github.com/StoneCypher/jrv_tutorial/) repo.
1. The current final up to date version is
[distributed on NPM as `jrv`](https://www.npmjs.com/package/jrv), from a
[Github repo named `jrv`](https://github.com/StoneCypher/jrv).
With that out of the way, it's time to take steps through the process. 😆
### The plan (ish)
We're going to start by implementing this in *just an* ***awful*** way,
initially. Then, piece by piece, we'll refine it into something quite usable.
1. Initially, the system will calculate the entire chain every time it's asked,
with relationships unchangeable after created.
1. In the second step, we'll make relationships changeable.
1. Next, we'll teach the values to update themselves when things change, and
to cache the values we receive, for better performance.
1. Afterwards, we'll trim the propogations back to only what's actually needed
("lazy updates,") and set up the dirty flag system that makes that possible.
1. Next, we'll create "handlers" - routines that are called as values change.
After this step, the library will become genuinely useful.
1. Following that, we'll support "chain" or "fluent" notation, like one expects
from `d3` and `jquery`, which will lead to a much more pleasant API.
Let's get started, shall we?
### Building a rig
`TODO COMEBACK this should be and refer to a github page`
We can avoid almost the entirety of building a rig, this time around. The
[tutorial repo](https://github.com/StoneCypher/jrv_tutorial/) has a series of
HTML files, for each step in the implementation. These HTML files load the
library, and then you can just work with the library in your browser console of
choice (better instructions in each [HTML file](#todo_comeback))
## Milestones
So, let's start walking through the aforementioned milestones, one by one.
### Step 1 - Can read const `reactive`ly
To begin with, let's go for the genuinely horrid implementation we discussed.

Smart, well written, efficient reactive systems tend to be either subscription
or broadcast models, which propagate changes as they happen.
We're not starting with a smart, well written, efficient system. We're starting
with modest tools.
Because this is `Built On Works` ™ technology, we're taking the slow-mode
route and doing the entire computation exhaustively on every request (which is
easier to implement, but extremely wasteful.)
It's a start. We'll do better quickly.
#### What do we need?

#### Let's do it
```javascript
class JRV { // js reactive variable
constructor(comp) { this.comp = comp; }
get v() { return this.comp() }
}
```
This is "barely counts" reactive. Fundamentally, this is the rudimentary sole
piece of `reactive`: having a computation that's always up to date on request.
(It's just that this is awful slow, and can't be updated, and doesn't have any
of the API we'd want from a nice implementation.)
All this really does is take a function in the constructor, then offer a
`getter` which runs the function when gotten. The `getter`, `.v`, represents
the "value" of the `JRV`, and with time will have more complex behavior.
But, for now, this is pretty much just a lame wrapper of a provided function.
#### Results
> As a quick reminder, a function that adds `A` and `B` and returns the result
> can be expressed briefly in JavaScript as an arrow by writing
>
> ```javascript
> () => A+B
> ```
This isn't exactly elegant, but it gets the job done, per our earlier example:
```javascript
var A = 5,
B = 6,
Sum = new RN( () => A+B );
console.log( Sum.v ); // 11
A = 15;
console.log( Sum.v ); // 21
```
#### Current code
The full implementation now looks like
```javascript
class JRV { // js reactive variable
constructor(comp) { this.comp = comp; }
get v() { return this.comp() }
}
```
There's a [playground here](https://stonecypher.github.io/jrv_tutorial/1_readable/index.html) if you'd like to
experiment before continuing.
#### Problem
This is technically `reactive`, though it is not yet "there" in spirit. But,
one step at a time, especially during the learning process. We'll get there
in this document.
![](http://i0.kym-cdn.com/photos/images/original/000/909/991/48c.jpg)
Note that this doesn't do the thing that most people expect from `reactive`
systems, yet - it doesn't actually "react" to changes. It just has updates in
place at all times. But the "react" part is the part people want, and where the
name comes from.
It's coming up.
The first thing we should fix is making the value computation updatable.
### Step 2 - Mutable JRV
It's important to be able to change the value of a JRV. Currently, we cannot.
#### What do we need?
To do this, we'll need to add a `setter` to complement the `getter` for `.v`.
#### Let's do it
```javascript
class JRV {
constructor(comp) { this.comp = comp; }
set v(newComp) { this.comp = newComp; }
get v() { return this.comp(); }
}
```
#### Results
Not a huge or shocking change here, since we're early on. We use the same
example, but now we change some underlying computations and show that the change
took, as well.
We're going to implement all the variables as `JRV`s this time, so that we have
something to change, and something derived from them to call.
```javascript
var A = new JRV( () => 0 ),
B = new JRV( () => 5 ),
X = new JRV( () => A.v + B.v );
console.log( X.v );
A.v = () => 10; console.log( X.v );
A.v = () => 20; console.log( X.v );
A.v = () => 30; console.log( X.v );
X.v = () => (A.v*2) + (B.v*2);
console.log( X.v );
```
And, that works. But, honestly, it'd be nice if we didn't have to write arrows
to return simple values, like in A and B there; we should be able to just have
constants there. We can't, currently, because the `getter` assumes that the
thing in `.comp` storage is a function, and can be called. So, if you pass an
integer to the `constructor`, the `JRV` will try to call the integer - say,
```javascript
5();
```
... which is nonsense. The shell will see it this way:
```javascript
> var X = new RN( () => 42 );
undefined
> X.v;
42
> X.v = 10;
10
> X.v;
VM198:5 Uncaught TypeError: this.comp is not a function(…)
get v @ VM198:5(anonymous function) @ VM278:1
> X.v = () => 10;
() => 10
> X.v;
10
```
So, let's make the thing more convenient to use.
There are a bunch of possible responses to this: make two setters, one for
values; test the type on the way in and wrap it with a reader if it's not a
function; check if the thing is a value on emit, and emit safely if not. There
are ups and downs to each.
The easiest way is to check, in the getter, whether the thing in `.comp` is a
function; if so to call it; if not, to return it directly.
So, we'll change
```javascript
get v() { return this.comp(); }
```
To
```javascript
get v() {
var isFunc = (typeof this.comp === 'function');
return isFunc? this.comp() : this.comp;
}
```
As a result, we can now write
```javascript
var A = new JRV(0),
B = new JRV(5),
X = new JRV( () => A.v + B.v );
console.log( X.v );
A.v = 10; console.log( X.v );
A.v = 20; console.log( X.v );
A.v = 30; console.log( X.v );
X.v = () => (A.v*2) + (B.v*2);
console.log( X.v );
```
And that's rather nicer.
#### Current code
The full implementation now looks like
```javascript
class JRV {
constructor(comp) { this.comp = comp; }
set v(newComp) { this.comp = newComp; }
get v() {
var isFunc = (typeof this.comp === 'function');
return isFunc? this.comp() : this.comp;
}
}
```
There's a [playground here](https://stonecypher.github.io/jrv_tutorial/2_mutable_jrv/index.html) if you'd like to
experiment before continuing.
#### Problem
At this point, we have an adequate notation. However, this approach is very
slow.
Consider the case of a system where `F` depends on `E`, which depends on `D`,
and so on back to `A`.
In our current system, if we make a change to `D` then inspect `F`, every
computation back to `A` will be repeated, wastefully.
Let's fix that, with propagation and caching.
### Step 3 - Values propagate and cache
So for efficiency's sake, let's have the values cache. To do that, we'll also
need the values to update themselves (because if they cached without updating)
themselves, they'd just be out of date all the time, and then what's the point?
#### What do we need?
Getting values to cache means storing the last value we've seen from them, and
reporting that from the getter, instead of executing directly.
This also means that `JRV`s need to know what depends on them, so that they can
notify the dependencies of a change.
To do that, we'll build a `notifier factory` to make `notifier`s for the
dependant, and we'll make a method on the dependency called `.should_notify`
that tells it to call the `notifier` that we pass to it.
One significant consequence of this approach is that ***`JRV`s must now rely on
other `JRV`s***, because normal variables don't know to call notifiers when
they're set.
(You could alter the `__prototype__` of the primitive types to change that, but
that'd be awful, and would trigger all kinds of security and practical problems,
so, don't.)
#### Let's do it
We start by adding a method `.update`, which can update an internally stored
value to its new state.
```javascript
update() {
var isFunc = (typeof this.comp === 'function');
return this.value = (isFunc? this.comp() : this.comp);
}
```
This is roughly the same as the previous `getter`: check if the stored
computation is a `function`; assign to `value` either the function, called,
or the non-function; return what was assigned. In this way, `.value` becomes
our value cache.
Following that, the `getter` is reduced to the much simpler returning of the
cached value:
```javascript
get v() {
return this.value;
}
```
Next, we need to make the `notifier factory`. This turns out to be quite
straightforward: it's just a `function` that returns another `function` that
we make on the spot, which just calls `.update` on this `JRV`. We will call
what we return `notifier`s, which is not a technical term, but helps clarify
what's being done.
```javascript
make_notifier() {
return (() => this.update());
}
```
To use this, the dependency will need to be made aware of the notifier. We can
set that up with `.should_notify`, a method we can pass the notifier to.
```javascript
should_notify(cb) {
this.callbacks = this.callbacks.concat(cb);
}
```
Looks like we're just going to push it onto the back of an array called
`this.callbacks`. Of course, `this.callbacks` doesn't exist yet, so, let's
make sure to init that in the `JRV`'s constructor, to an empty array:
```javascript
constructor(comp) {
this.comp = comp;
this.callbacks = [];
this.update();
}
```
As you can see, we also added an `.update()` at the end of the constructor, to
make sure that the `JRV` was entirely up to date once set up.
Finally, we should modify the `setter` to make an `.update` call and then notify
the dependencies manually:
```javascript
set v(newComp) {
this.comp = newComp;
this.update();
this.callbacks.map(cb => cb());
}
```
#### Results
Now we have `JRV`s which actively update themselves, and cache their values,
eliminating one large source of inefficiency: wasted recalculation.
```javascript
var A = new JRV(0),
B = new JRV(5),
Sum = new JRV( () => A.v + B.v );
A.should_notify(Sum.make_notifier());
B.should_notify(Sum.make_notifier());
console.log( Sum.v );
A.v = 10; console.log( Sum.v );
A.v = 20; console.log( Sum.v );
A.v = 30; console.log( Sum.v );
Sum.v = () => (A.v*2) + (B.v*2);
console.log( Sum.v );
```
That's kinda gross, though, that `.should_notify` bit.
Most problematically, it puts the conceptual burden of the dependency on the
sources, instead of on the conclusion. This means that one has to go manually
handle every single dependency one at a time, instead of just giving a list of
what's upstream of the thing you're thinking about at the time.
We can make a method `.needs` to fix the problem.
All `.needs` will do is accept an array of the `JRV`s that are upstream, and
walk their `.should_notify` methods with our caller's `notifier`. (For
convenience it'll also accept a non-array single upstream parent.)
```javascript
needs(Dep) {
if (Array.isArray(Dep)) { Dep.map(d => d.should_notify(this.make_notifier())); }
else { Dep.should_notify(this.make_notifier()); }
return this;
}
```
As a result, instead of writing
```javascript
var Sum = new JRV( () => A.v + B.v );
A.should_notify(Sum.make_notifier());
B.should_notify(Sum.make_notifier());
```
We may now write
```javascript
var Sum = new JRV( () => A.v + B.v ).needs([A,B]);
```
Which leads to a much more pleasant and readable authoring experience:
```javascript
var A = new JRV(0),
B = new JRV(5),
X = new JRV( () => A.v + B.v ).needs([A,B]);
console.log( X.v );
A.v = 10; console.log( X.v );
A.v = 20; console.log( X.v );
A.v = 30; console.log( X.v );
X.v = () => (A.v*2) + (B.v*2);
console.log( X.v );
```
#### Current code
The full implementation now looks like
```javascript
class JRV { // reactive node
constructor(comp) {
this.comp = comp;
this.callbacks = [];
this.update();
}
should_notify(cb) {
this.callbacks = this.callbacks.concat(cb);
}
needs(Dep) {
if (Array.isArray(Dep)) { Dep.map(d => d.should_notify(this.make_notifier())); }
else { Dep.should_notify(this.make_notifier()); }
return this;
}
make_notifier() {
return (() => this.update());
}
set v(newComp) {
this.comp = newComp;
this.update();
this.callbacks.map(cb => cb());
}
get v() {
return this.value;
}
update() {
var isFunc = (typeof this.comp === 'function');
return this.value = (isFunc? this.comp() : this.comp);
}
}
```
There's a [playground here](https://stonecypher.github.io/jrv_tutorial/3_update_and_cache/index.html) if you'd like to
experiment before continuing.
#### Problem
The nice part of `reactive` programming is having your variables just trigger
their own behaviors after they're changed. We don't have that yet, but, let's
see what happens when we do.
In particular, all that `console.log`ging in the example is pretty grimy, no?
Fix it time.
### Step 4 - Values have handlers
We'd like for variables to have associated behaviors by which to "react" to
changes, thereby earning the conceptual (if not the definitive) part of the
name.
Those behaviors will be functions, which we'll call `change handler`s.
#### What do we need?
We just need to associate a `change handler`, and call it at the right times.
#### Let's do it
First, let's add a method that lets us change the `change handler` on an
existing `JRV`.
```javascript
onchange(newOnChange) {
this.change_handler = newOnChange;
return this;
}
```
Next, let's initialize that member in the `constructor`, and take it from a
`constructor` argument we'll add. We'll also give it a default of a function
that does nothing but return `true`, so that we don't have to go find out if
there's something to call.
```javascript
constructor(comp = (() => true), onchange = (() => true)) {
this.comp = comp;
this.change_handler = onchange;
this.callbacks = [];
this.update();
}
```
Finally, we improve `.update` to the following algorithm:
1. Locally store the old cache
1. Update the cache
1. If the updated cache is different than the local store,
1. Call the `change handler`.
Aaaaand, that can be implemented like this:
```javascript
update() {
var isFunc = (typeof this.comp === 'function'),
oldValue = this.value;
this.value = (isFunc? this.comp() : this.comp);
if (this.value !== oldValue) {
this.change_handler(this.value, oldValue);
}
return this.value;
}
```
#### Results
We can now just associate the `console.log` as the behavior of `Sum` when it
changes. This creates a *far* cleaner example:
```javascript
var logger = NewData => console.log(`Changed: ${NewData}`),
A = new JRV(0),
B = new JRV(5),
Sum = new JRV( () => A.v + B.v )
.needs([A,B])
.onchange(logger);
console.log( `Initial value: ${Sum.v}` );
A.v = 10;
A.v = 20;
A.v = 30;
Sum.v = () => (A.v*2) + (B.v*2);
```
Now, you will see an initial value, and a bunch of "Changed:" notices, without
their being called for. The output in a Chrome console should read
Initial value: 5 VM102:10
Changed: 15 VM102:1
Changed: 25 VM102:1
Changed: 35 VM102:1
Changed: 70 VM102:1
The ***real*** value of `reactive` programming is beginning to deliver.
#### Current code
The full implementation now looks like
```javascript
class JRV { // reactive node
constructor(comp = (() => true), onchange = (() => true)) {
this.comp = comp;
this.change_handler = onchange;
this.callbacks = [];
this.update();
}
should_notify(cb) {
this.callbacks = this.callbacks.concat(cb);
}
needs(Dep) {
if (Array.isArray(Dep)) { Dep.map(d => d.should_notify(this.make_notifier())); }
else { Dep.should_notify(this.make_notifier()); }
return this;
}
make_notifier() {
return (() => this.update());
}
onchange(newOnChange) {
this.change_handler = newOnChange;
return this;
}
set v(newComp) {
this.comp = newComp;
this.update();
this.callbacks.map(cb => cb());
}
get v() {
return this.value;
}
update() {
var isFunc = (typeof this.comp === 'function'),
oldValue = this.value;
this.value = (isFunc? this.comp() : this.comp);
if (this.value !== oldValue) {
this.change_handler(this.value, oldValue);
}
return this.value;
}
}
```
There's a [playground here](https://stonecypher.github.io/jrv_tutorial/4_values_have_handlers/index.html) if you'd like to
experiment before continuing.
#### Problem
Consider again the same case of a system where `F` depends on `E`, which depends
on `D`, and so on back to `A`.
This time, suppose that `E`, `F`, and `G` are generally unused except initially.
We're mostly interested in `D`. (We've attached a handler to `D` so the handler
always needs to be current, we'll say.)
If we change `A`, then we care that `D` gets re-cached. Unfortunately, we also
keep eagerly updating `E`, `F`, and `G`, which (if we aren't using them) is
another (probably lesser) form of waste.

### Step 5 - Dirty flag for lazy recalc
So, now we just want to update the stuff that actually needs to be updated.
#### What do we need?
We need to know which things *actually need* to be updated, and we need to
update those immediately. For the rest, we just want to mark that the cache
is out of date, then move on.
In our current system, something "needs" to be kept up to date if it has a
handler on it. Otherwise, it can calc back to the last known cache, on call,
updating everything in its wake.
We would also like to skip this entirly if there's no reason to believe the
current cache is out of date. That's hard if the system is no longer eagerly
forward-pushing values, though.
The way we'll accomplish this is to change what the `notifier` does. In the
older versions of `JRV`, when a variable was notified of a change, it would
immediately call `.update`, summoning the new value.
In new `JRV`, the `notifier` will instead call a function that flags the `JRV`
as needing an update (which we call "flagging it `dirty`,") and let the `JRV`
proceed.
#### Let's do it
Initially, a `JRV` should be `dirty`, reflecting that it needs update (we have
been updating from start all along, so this is just the natural new modelling.)
As such we add to the constructor
```javascript
this.dirty = true;
```
Next, we'll need a mechanism to flag a `JRV` as `dirty`.
What this mechanism will do is to set a local flag member called `.dirty` to
`true`, then to call `.update` immediately if the `JRV` has a `change handler`
(because those need immediate update,) then finally to dirty all downstream
dependencies.
```javascript
flag_dirty() {
this.dirty = true;
if (this.change_handler) { this.update(); }
this.callbacks.map(cb => cb());
return this;
}
```
Now that we have `JRV`s that are born `dirty` and can be made `dirty`, we also
need a way to un`dirty` them. This will happen in our newer, beefier `.update`:
```javascript
update() {
var compIsFunc = (typeof this.comp === 'function'),
valIsObj = (typeof this.value === 'object'),
oldVal = valIsObj? NaN : this.value;
this.dirty = false;
this.value = (compIsFunc? this.comp() : this.comp);
if (this.value !== oldVal) {
this.change_handler(this.value, oldVal);
}
return this.value;
}
```
We've added a line `this.dirty = false` to suggest that after that line in an
`.update`, the `JRV` is no longer dirty. However, if you're paying attention,
you'll notice we've also replaced the old-value comparison with something weird
and gross that involves the Not-a-Number `NaN`. (Guh?)
We're exploiting some grossness in Javascript to get around an unmentioned bug
in version four.
See, in version four, where we assign the current `this.value` to `oldVal`,
if `this.value` was an object, what we'd do would be to make both those names
point at the same object, rather than to get a clone of that object (because
Javascript is gross.)
Now, we could write a deep clone algorithm (because Javascript doesn't have one,
because Javascript is gross,) and also a deep compare algorithm (because... ,)
and *also* take the time to make some difficult choices about what happens when
there's certain complex cases inside, like websockets, or badly written objects
that don't make copy construction possible.
Oooooor. We could just say "if it's an object, fail the match and issue a
change." Which is what we'll do here, because, bleh, let's just get on with it.
We could rewrite the path to say "if it's an object, recalc and change;
otherwise cache, recalc, compare, and maybe change." But that's complicated
and brittle.
Instead we'll exploit a very gross choice in Javascript: `NaN === NaN` is
`false`, not `true` like common sense dictates.
That means that if we use `NaN` as our placeholder, then nothing the comparator
can return will strict-compare true, and therefore we can keep the old algorithm
by dint of Javascript dark magic.
So now that we have a complete dirty flagging system, we can change the
`notifier factory` to return the `dirty flag`ger, instead of the `update`r.
```javascript
make_notifier() {
return (() => this.flag_dirty());
}
```
And we're done.
#### Results
We now have a `JRV` implementation that caches results, automatically pushes
values exactly as far as they need to go, and keeps dirty flagging all the way
out the tree.
Using the browser debugger, we can witness the dirty flagging and caching
in action:
```javascript
var log = data => console.log(`Active leaf received: ${data}`),
Root = new JRV(0),
Middle = new JRV( () => Root.v * 2 ).needs(Root),
ActiveLeaf = new JRV( () => Middle.v * 3 ).needs(Middle).onchange(log),
PassiveLeaf = new JRV( () => Middle.v * 3 ).needs(Middle);
Root.v = 1;
```
`ActiveLeaf` will log as expected. On looking in the browser's debugger, one
will see that `PassiveLeaf` is flagged `dirty`, and has an out of date
`cache value` on record. Hurrah!
![](http://i.imgur.com/3WvSgSy.png)
#### Current code
The full implementation now looks like
```javascript
```
There's a [playground here](https://stonecypher.github.io/jrv_tutorial/5_dirty_and_lazy/index.html) if you'd like to
experiment before continuing.
#### Problem
One problem we'll ignore for the moment: the `.onchange` handler is being called
on `ActiveLeaf` *twice*, which is either a subtle bug, or something the user
should be expected to handle, depending on how you look at it. We'll look at
that later.
For now, the API could use some work. You can construct a value in place, you
can assign a value in place, but you can't fluent-call a value in place, which
prevents you from doing everything in fluent, if you want to. Same observation
holds for the change handler. Let's go full fluent (while also supporting our
entire current interface.)
### Step 6 - pure call handler
#### What do we need?
#### Let's do it
#### Results
#### Current code
The full implementation now looks like
```javascript
```
There's a [playground here](#todo_comeback_whargarbl) if you'd like to
experiment before continuing.
#### Problem
### Step 7 - JRV options
#### What do we need?
#### Let's do it
#### Results
#### Current code
The full implementation now looks like
```javascript
```
There's a [playground here](#todo_comeback_whargarbl) if you'd like to
experiment before continuing.
#### Problem
#### Option 1 - should re-handle/debounce for same-assign?
#### Option 2 - should immediate recalc w/o handler?
## Taking it for a spin
### Implementing a Side Project Revenue calculator
# Worldview issues
1. Worldview issues
1. Benefits
2. Detriments
3. Alternatives
4. Paradigms
## Paradigms
We occasionally discuss "paradigms" of programming.
![](https://i.imgflip.com/16yfmw.jpg)
A paradigm is, in broad strokes, a way of looking at authoring software.
Object oriented, functional, logical, constraint based (like SQL and CSS,) and
dozens of others are paradigms of programming. Many languages, like C++ and
Javascript, support multiple programming paradigms.
When one discusses paradigms, one discusses entirely different worldviews of
how software is made. By example, imperative software (BCPL / C family) tends
to be small algorithms as functions, built up into successively larger
functions, generally largely heirarchally. Contrasting, object oriented
software tends to be built in mostly-discrete pieces, separated by interfaces.
Constraint based software tends to be "under these circumstances, fulfill these
requirements, or list for me the possibilities."
Paradigms are inherently sort of a blurry concept, and people often get into
arguments about whether this one or that one "really counts."
# Conclusion
1. Conclusion


Utility functions, constants, internals, etc.
|
|
property_RO(method)
Decorator for Read_Only class/instance property. |
|
|
|
|
bytes2repr(bytestr)
Represent bytes or str as
b"..." .


Gluten-Free Carrot Cake
From: Bon Appetit • Print this Recipe
Search Results
Ingredients:
Cake
- ½ cup virgin coconut oil, melted, plus more for pans
- 3 cups almond flour, plus more for dusting pans
- 1½ tsp. kosher salt
- 1 tsp. baking powder
- 1 tsp. ground cardamom
- 1 tsp. ground cinnamon
- 1 tsp. ground ginger
- ½ tsp. baking soda
- 5 large eggs
- 1¼ cups (packed) dark brown sugar
- 1 tsp. vanilla extract
- 10 oz. carrots, peeled, coarsely shredded, squeezed firmly to expel excess water
Optional:
- ¾ cup shredded unsweetened coconut
- ¾ cup walnuts, finely chopped
- ½ cup golden raisins
Frosting and Assembly
- 8 oz. cream cheese, room temperature
- ½ cup (1 stick) unsalted butter, room temperature
- 1¼ cups gluten-free powdered sugar
- ⅓ cup Greek yogurt
- 1 tsp. vanilla extract
- Pinch of kosher salt
Directions:
Cake
- Preheat oven to 350°F. Grease two 8” parchment-lined round cake pans with oil, then dust with almond flour, tapping out excess.
- Whisk salt, baking powder, cardamom, cinnamon, ginger, baking soda, and remaining 3 cups flour in a medium bowl.
- Using an electric mixer on medium-high speed, beat eggs and brown sugar in a large bowl until more than tripled in volume and mixture holds a ribbon for several seconds when drizzled over itself, 5–7 minutes. (Beating the eggs thoroughly in this stage goes a long way toward creating an aerated, light crumb, which is critical when using gluten-free ingredients.) Beat in vanilla.
- Toss carrots, coconut, walnuts, raisins, and remaining ½ cup oil in another medium bowl.
- Reduce mixer speed to low.
- Add flour mixture in 3 additions, alternating with carrot mixture in 3 additions, to egg mixture, beating well after each addition.
- Divide batter between prepared pans.
- Bake cake until lightly browned across the top, a tester inserted into the center comes out clean, and the top springs back when gently poked, 33–36 minutes.
- Let cool 10 minutes. Carefully run a knife around edges of pans to release cake, then invert onto a wire rack. Let cool completely.
Frosting and Assembly
- Using electric mixer on medium-high speed, beat cream cheese and butter in a large bowl, scraping down as needed, until very smooth, about 2 minutes.
- Reduce mixer speed to low and add powdered sugar. Beat until combined.
- Add yogurt, vanilla, and salt and increase speed to medium-high.
- Beat, scraping down occasionally, until light and airy, about 4 minutes.
- Chill 10 minutes if needed to stiffen slightly to a spreadable consistently.
- Arrange one cake round domed side down on a large plate or platter. Cover top and sides with one-third of frosting.
- Top with remaining cake layer, domed side up. Coat top and sides with remaining frosting.


Semana de Tecnologia da Informação - SETI UFLA
João Lucas P Santana - @jlucasps
Java Developer
Ruby/Rails Developer
JavaScript Developer
twitter |
github |
fb |
gtalk : jlucasps
“I hope to see Ruby help every programmer in the world to be productive, and to enjoy programming, and to be happy. That is the primary purpose of Ruby language.”Yukihiro “Matz” Matsumoto
Feb. 23 1993
"... object-oriented scripting language. I knew Perl (Perl4, not Perl5), but I didn't like it
really, because it had smell of toy language (it still has)."
"I knew Python then. But I didn't like it, because I didn't think it was a true object-oriented language."
"So, I decided to make it." Matz
"It took several months to make the interpreter run. [...]
I posted Ruby 0.95 to the Japanese domestic newsgroups in Dec. 1995. " Matz
4.even? # => true
3.upto(8).to_a # => [3, 4, 5, 6, 7, 8]
"A string literal".length() # => 16
[].methods
=> [:inspect, :to_s, :to_a, :to_ary, :frozen?, :==, :eql?, :hash, :[],
:[]=, :at, :fetch, :first, :last, :concat, :<<, :push, :pop, :shift,
:unshift, :insert, :each, :each_index, :reverse_each, :length, :size,
:empty?, :find_index, .... ]
10.methods
=> [:to_s, :inspect, :-@, :+, :-, :*, :/, :div, :%, :modulo, :divmod, :fdiv,
:**, :abs, :magnitude, :==, :===, :<=>, :>, :>=, :<, :<=, :~, :&, :|, :^,
:[], :<<, :>>, :to_f, :size, :zero?, :odd?, :even?, :succ, :integer?,
:upto, :downto, :times, :next, :pred, :chr, :ord, :to_i, :to_int, :floor,
:ceil, :truncate, :round, :gcd, :lcm, :gcdlcm, :numerator, :denominator,
:to_r, :rationalize, :singleton_method_added, :coerce, :i, :+@, :eql?, ... ]
true.class
=> TrueClass
1.4.class
=> Float
'1+3i'.to_c.class
=> Complex
'1+3i'.to_c.class.ancestors
=> [Complex, Numeric, Comparable, Object, Kernel, BasicObject]
'1+3i'.to_c.class.class
=> Class
class InfoCompMagazine
# ...
end
Métodos e variáveis usam snake_case
def number_of_pages
# some code here ...
end
def web_magazine?
# more code ...
end
def change_folder!
# code code code ...
end
class Book
def initialize(title)
@title = title
end
def title
@title
end
end
book = Book.new "Eloquent Ruby"
puts book.title # "Eloquent Ruby"
puts book.send :title # "Eloquent Ruby"
book = Book.new( "Eloquent Ruby" )
puts book.title() # "Eloquent Ruby"
puts book.send( :title ) # "Eloquent Ruby"
// Java class
public class Person {
private int age;
public int getAge() {
return this.age
}
public void setAge(int age) {
this.age = age;
}
}
# Ruby class
class Person
attr_accessor :age
end
class Magazine
MAX_PAGES = 30 # contants
end
class Magazine
def initialize
@max_pages = 30 # instance variable
end
end
class Magazine
@@max_pages = 30 # class variable
def initialize
# ...
end
end
class Fixnum
def +( num )
self - num
end
end
puts 2 + 3
=> -1
Armando Fox, University of California, Berkeley
def print_user_info( info )
puts "Info about user:"
info.each_pair { |key, value| puts "#{key}: #{value}" }
end
print_user_info( { name: "Joao lucas", email<EMAIL_ADDRESS>} )
# Info about user:
# name: Joao lucas
# email<EMAIL_ADDRESS>print_user_info( name: "Joao lucas", email<EMAIL_ADDRESS>)
print_user_info name: "Joao lucas", email<EMAIL_ADDRESS>Armando Fox, University of California, Berkeley
user.age.should(be() >= 18)
user.age.should be >= 18
if !logged_in?() # unless logged_in?()
( redirect_to( login_page() ) ) and return()
end
# ...
( redirect_to( login_page() ) and return() ) unless logged_in?()
# ...
( redirect_to login_page and return ) unless logged_in?
class Car
end
car = Car.new
car.run # undefined method `run' for #<Car:0x00000001c8d970> (NoMethodError)
# singleton method
def car.run
puts "wooowww Car running now!"
end
car.run # wooowww Car running now!
car2 = Car.new
car2.run # undefined method `run' for #<Car:0x00000002292898> (NoMethodError)
class User
attr_accessor :name, :age, :city
def initialize name, age, city
@name, @age, @city = name, age, city
end
end
user = User.new "João Lucas", 25, "BH"
puts "#{user.name}, #{user.age()} years old, from #{user.city}."
puts user.move( "BH", "POA" )
# Joao Lucas, 25 years old, from BH.
# undefined method `move' for #<User:0x994cee8 @name="João Lucas", @age=25, @city="BH"> (NoMethodError)
class User
def method_missing( method, *args, &block)
puts "ops.. you can not call #{method}(..) with params #{args.to_a} right now."
puts "Try again next week! :-D"
end
end
puts user.move( "BH", "POA" )
# Joao Lucas, 25 years old, from BH.
# ops.. you can not call move(..) with params ["BH", "POA"] right now.
# Try again next week! :-D
class User
MOVE_OPTIONS = [:trip, :travel, :move, :go]
MOVE_OPTIONS.each do | name |
define_method( name ) do | *args |
puts "Method #{name}(..) called with args #{args.inspect}"
end
end
end
puts user.move( "BH", "POA" )
# Method move(..) called with args ["BH", "POA"]
github.com/markets/awesome-ruby
github.com/bayandin/awesome-awesomeness
quora.com/What-are-some-highly-trafficked-sites-built-in-Ruby-on-Rails
Semana de Tecnologia da Informação - SETI UFLA
João Lucas P Santana - @jlucasps


The assumption is similar to Post-Set but a tie is defined as being between all people who contributed at least 3 posts or comments to a thread.
Individuals who withdrew (were deleted) are not counted; other analysis will rely on role information, which is not available for these people (although it could be imputed as access_group_id=4).
## Saved to Whole-T 3.RData
| id | nodes | edges | isolates | graph density*1000 | diameter | degree | closeness | betweenness |
|---|---|---|---|---|---|---|---|---|
| aiplan | 499 | 128 | 439 | 1.0302 | 4 | 0.0715 | 4e-04 | 0.0072 |
| astro | 3889 | 4543 | 3297 | 0.6009 | 8 | 0.0295 | 1e-04 | 0.0015 |
| crit | 4688 | 4039 | 4322 | 0.3676 | 5 | 0.0270 | 0e+00 | 0.0014 |
| edc | 2544 | 3404 | 2126 | 1.0523 | 6 | 0.0344 | 1e-04 | 0.0031 |
| equine | 6244 | 2362 | 5717 | 0.1212 | 8 | 0.0170 | 0e+00 | 0.0011 |
| intro | 6989 | 13101 | 5930 | 0.5365 | 7 | 0.0408 | 0e+00 | 0.0029 |
The density is the proportion of possible edges that actually exist. Dyads are node pairs (all mutual because the network is undirected. Diameter is the longest path between two people, in this case the direction of edges is significant. The degree statistics give a relative measure (relative to the theoretical maximum for the network size, and comparable between courses) of the extent to which ties are concentrated. A value of zero would imply all people have the same degree centrality. A value of 1 would indicate that one person is maximally central.
Degree, closeness and betweenness for an individual differ as follows:
## Saved to Whole-T I3.RData
| id | nodes | edges | isolates | graph density*1000 | diameter | degree | closeness | betweenness |
|---|---|---|---|---|---|---|---|---|
| aiplan | 34 | 0 | 34 | 0.0000 | 0 | 0.0000 | 0 | 0.0000 |
| astro | 2292 | 1011 | 2124 | 0.3851 | 7 | 0.0184 | 0 | 0.0012 |
| crit | 1493 | 148 | 1452 | 0.1329 | 2 | 0.0093 | 0 | 0.0000 |
| edc | 293 | 6 | 284 | 0.1403 | 1 | 0.0068 | 0 | 0.0000 |
| equine | 5101 | 847 | 4934 | 0.0651 | 7 | 0.0111 | 0 | 0.0002 |
| intro | 4535 | 1648 | 4340 | 0.1603 | 5 | 0.0146 | 0 | 0.0001 |
## Saved to Whole-T noI3.RData
| id | nodes | edges | isolates | graph density*1000 | diameter | degree | closeness | betweenness |
|---|---|---|---|---|---|---|---|---|
| aiplan | 481 | 128 | 421 | 1.1088 | 4 | 0.0742 | 4e-04 | 0.0078 |
| astro | 2797 | 3594 | 2301 | 0.9191 | 8 | 0.0352 | 1e-04 | 0.0027 |
| crit | 3952 | 3892 | 3620 | 0.4985 | 5 | 0.0319 | 0e+00 | 0.0018 |
| edc | 2440 | 3398 | 2029 | 1.1420 | 6 | 0.0358 | 1e-04 | 0.0033 |
| equine | 2851 | 1529 | 2450 | 0.3764 | 8 | 0.0326 | 1e-04 | 0.0028 |
| intro | 4374 | 11466 | 3454 | 1.1989 | 7 | 0.0626 | 1e-04 | 0.0044 |


Guesses Left: {{ guesses }}
Word To Guess: {{ displayWord }}
Incorrect Letters: {{ letter }}
Correct Letters: {{ letter }}


A community of developers run by the students of IIIT Bangalore.
We work to build things and sometimes break them too. We organise events and promote open source culture at IIITB. We are tech enthusiasts and are looking to work with those of our kind.


visualize sorting algorithms
bubble sort
selection sort
insertion sort
merge sort
quick sort (rand)
quick sort (mo3)
sort it
generate random array


---
layout: post
title: 6/10 progress and freak-out
date: '2014-06-10T22:55:00.001-06:00'
author: Jacob .
tags:
- progress-reports
modified_time: '2014-06-10T22:55:40.412-06:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-8029801285784573322
blogger_orig_url: http://www.svlark.com/2014/06/610-progress-and-freak-out.html
---
8 days left.
Crazy to look at all the stuff that's still here that needs to go away.
We dodged a bullet on that landlady. She called in the midst of a manic episode just in time for us to stop payment on the check that would have committed us to sharing a wall with a full-on nut job with a key to our home. Only problem is we still have nowhere to live in Ft. Pierce. There's always the boat of course...


# dashing/ros-distro.inc
# General configuration settings that are dependent on ROS_DISTRO.
#
# Copyright (c) 2019-2020 LG Electronics, Inc.
ROS_DISTRO_CODENAME = "Dashing Diademata"
ROS2_DISTRO = "dashing"
# The platform release that the metadata for this ROS distro targets. This determines the versions of the platform packages that
# OE must provide. It must be one of the values of ROS_DISTRO_RELEASE_PLATFORMS (which is set in
# generated/superflore-ros-distro.inc).
ROS_DISTRO_BASELINE_PLATFORM = "ubuntu-bionic"
require conf/ros-distro/include/dashing/generated/superflore-datetime.inc
require conf/ros-distro/include/dashing/generated/superflore-ros-distro.inc
require conf/ros-distro/include/dashing/ros-distro-recipe-blacklist.inc
require conf/ros-distro/include/dashing/ros-distro-preferred-versions.inc
require conf/ros-distro/include/dashing/ros-distro-preferred-providers.inc
# alternative not yet supported implementation for fastrtps
ROS_WORLD_SKIP_GROUPS += "connext"
# alternative not yet supported implementation for fastrtps
# https://github.com/ADLINK-IST/opensplice
ROS_WORLD_SKIP_GROUPS += "opensplice"
# alternative not yet supported implementation for fastrtps, there is no recipe for gurumdds-2.6
ROS_WORLD_SKIP_GROUPS += "gurumdds"
# Can't build these until we figure out how to build clang-format, clang-tidy without building all of clang.
ROS_WORLD_SKIP_GROUPS += "clang"
# Depends on python3-docker which is available in meta-virtualization, but we don't want to add the
# dependency on this layer to meta-ros yet
ROS_WORLD_SKIP_GROUPS += "docker"
# Needs work to launch qemu to run tests on image on build machine.
ROS_WORLD_SKIP_GROUPS += "launch"
# behaviortree-cpp-v3 and behaviortree-cpp are mutually exclusive because they install files in the same locations. Unlike
# behaviortree-cpp, nothing depends on behaviortree-cpp-v3, so exclude it.
ROS_WORLD_SKIP_GROUPS += "behaviortree-cpp-v3"
# recipes depending on python3-matplotlib
# there is python2 version in meta-ros-common/recipes-devtools/python/python-matplotlib_2.1.1.bb
# but no python3 version yet
ROS_WORLD_SKIP_GROUPS += "python3-matplotlib"
# There is recipe for glfw in meta-oe in dunfell:
# http://cgit.openembedded.org/meta-openembedded/commit/meta-oe/recipes-core/glfw/glfw_3.3.bb?id=a7464eaa69a7ee4734001aab2e232102e7135772
# but we don't have a backports layer from dunfell yet, lets skip it for now
ROS_WORLD_SKIP_GROUPS += "glfw"
# recipes depending on gazebo, for which there is no OE recipe
ROS_WORLD_SKIP_GROUPS += "gazebo"
# recipes depending on gst-python
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains('DISTRO_FEATURES', 'gobject-introspection-data', '', 'gst-python', d)}"
# recipes depending on pugixml
ROS_WORLD_SKIP_GROUPS += "pugixml"
# recipes depending on something from meta-qt5 layer
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains('BBFILE_COLLECTIONS', 'qt5-layer', '', 'qt5', d)}"
# recipes depending on something from meta-qt4 layer
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains('BBFILE_COLLECTIONS', 'qt4-layer', '', 'qt4', d)}"
# recipes depending on 'x11' in DISTRO_FEATURES
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains('DISTRO_FEATURES', 'x11', '', 'x11', d)}"
# recipes depending on 'opengl' in DISTRO_FEATURES
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains('DISTRO_FEATURES', 'opengl', '', 'opengl', d)}"
# recipes depending on 'ffmpeg' which is restricted by 'commercial' LICENSE_FLAG
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains_any('LICENSE_FLAGS_WHITELIST', ['commercial', 'ffmpeg', 'commercial_ffmpeg'], '', 'ffmpeg', d)}"
# recipes depending on 'x264' (ffmpeg does depend on it by default as well) which is restricted by 'commercial' LICENSE_FLAG
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains_any('LICENSE_FLAGS_WHITELIST', ['commercial', 'x264', 'commercial_x264'], '', 'x264', d)}"
# recipes depending on python*-pyqt5 from meta-qt5 layer
# Use separate group, because e.g. webOS OSE has meta-qt5 layer included, but python*-pyqt5
# is blacklisted, because webOS OSE is missing newer meta-qt5 from warrior with older meta-oe thud which has
# incompatible old sip
ROS_WORLD_SKIP_GROUPS += "${@bb.utils.contains('BBFILE_COLLECTIONS', 'qt5-layer', '', 'pyqt5', d)}"
# do_configure failures
ROS_WORLD_SKIP_GROUPS += " \
lanelet2-traffic-rules \
"
# do_compile failures
ROS_WORLD_SKIP_GROUPS += " \
rc-dynamics-api \
"
# Override settings from generated/superflore-ros-distro.inc here.
# Since superflore doesn't know when it's generating a recipe that it will be for a build tool, it can't know that what's in
# ROS_EXEC_DEPEND are also build tools. Manually add them here.
ROS_SUPERFLORE_GENERATED_BUILDTOOLS += " \
ament-lint-native \
builtin-interfaces-native \
poco-vendor-native \
rcpputils-native \
rcutils-native \
rmw-native \
rmw-fastrtps-cpp-native \
rmw-fastrtps-dynamic-cpp-native \
rmw-fastrtps-shared-cpp-native \
rmw-implementation-cmake-native \
rmw-implementation-native \
rosidl-actions-native \
rosidl-adapter-native \
rosidl-default-runtime-native \
rosidl-typesupport-fastrtps-c-native \
uncrustify-vendor-native \
"
# Used by generated-recipes/geographic-info/geodesy_1.0.1-1.bb
# use python3 version because python2 is EOL
ROS_UNRESOLVED_PLATFORM_PKG_python-pyproj = "python3-pyproj"
# Used by generated-recipes/phidgets-drivers/libphidget22_2.0.1-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libusb-1.0 = "libusb1"
# Used by generated-recipes/marti-common/swri-transform-util_3.0.3-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_proj = "proj"
# Used by generated-recipes/rosbridge-suite/rosbridge-library_1.0.2-1.bb
# and bson is now provided by pymongo
ROS_UNRESOLVED_PLATFORM_PKG_python3-bson = "python3-pymongo"
# Used by generated-recipes/teleop-tools/mouse-teleop_1.0.1-1.bb
# use python3 version because python2 is EOL
ROS_UNRESOLVED_PLATFORM_PKG_python-tk = "python3-tkinter"
# Used by generated-recipes/hls-lfcd-lds-driver/hls-lfcd-lds-driver_2.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libboost-system-dev = "boost"
# Used by generated-recipes/transport-drivers/udp-driver_0.0.5-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libboost-system = "boost"
# Used by generated-recipes/navigation2/nav2-util_0.2.6-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libboost-program-options = "boost"
# Used by generated-recipes/marti-common/swri-geometry-util_3.0.3-1.bb
# generated-recipes/marti-common/swri-transform-util_3.0.3-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libgeos++-dev = "geos"
# Used by generated-recipes/rosbridge-suite/rosbridge-library_1.0.2-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-pil = "python3-pillow"
# Used by generated-recipes/kinesis-manager/kinesis-manager_2.0.1-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_log4cplus = "log4cplus"
# Used by generated-recipes/gps-umd/gpsd-client_1.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libgps = "gpsd"
# Used by generated-recipes/navigation2/nav2-map-server_0.2.6-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_graphicsmagick = "graphicsmagick"
# Used by generated-recipes/navigation2/nav2-system-tests_0.2.6-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_lcov = "lcov"
# Used by generated-recipes/rosbridge-suite/rosbridge-server_1.0.2-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-twisted = "python3-twisted"
# Used by generated-recipes/rosbridge-suite/rosbridge-server_1.0.2-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-tornado = "python3-tornado"
# Used by generated-recipes/tts/tts_2.0.1-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_gstreamer1.0-plugins-good = "gstreamer1.0-plugins-good"
ROS_UNRESOLVED_PLATFORM_PKG_gstreamer1.0 = "gstreamer1.0"
ROS_UNRESOLVED_PLATFORM_PKG_gstreamer1.0-alsa = "gstreamer1.0-plugins-base"
ROS_UNRESOLVED_PLATFORM_PKG_python-gst-1.0 = "gstreamer1.0-python"
ROS_UNRESOLVED_PLATFORM_PKG_python3-boto3 = "python3-boto3"
# Used by:
# generated-recipes/py-trees-ros-tutorials/py-trees-ros-tutorials_1.0.5-1.bb
# generated-recipes/py-trees-js/py-trees-js_0.5.0-1.bb
# generated-recipes/py-trees-ros-viewer/py-trees-ros-viewer_0.1.3-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_pyqt5-dev-tools = "python3-pyqt5"
# Used by:
# generated-recipes/py-trees-ros-tutorials/py-trees-ros-tutorials_1.0.5-1.bb
# generated-recipes/py-trees-js/py-trees-js_0.5.0-1.bb
# generated-recipes/py-trees-ros-viewer/py-trees-ros-viewer_0.1.3-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_qttools5-dev-tools = "python3-pyqt5"
# Used by:
# generated-recipes/py-trees-ros-tutorials/py-trees-ros-tutorials_1.0.5-1.bb
# generated-recipes/py-trees-js/py-trees-js_0.5.0-1.bb
# generated-recipes/py-trees-ros-viewer/py-trees-ros-viewer_0.1.3-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-qt5-bindings = "python3-pyqt5"
# Used by:
# generated-recipes/py-trees-js/py-trees-js_0.5.0-1.bb
# generated-recipes/py-trees-ros-viewer/py-trees-ros-viewer_0.1.3-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-pyqt5.qtwebengine = "python3-pyqt5"
# tango-icon-theme isn't available, but adwaita-icon-theme should be compatible
# Used by:
# generated-recipes/qt-gui-core/qt-gui_1.0.7-1.bbb
ROS_UNRESOLVED_PLATFORM_PKG_tango-icon-theme = "adwaita-icon-theme"
# Used by:
# generated-recipes/slam-toolbox/slam-toolbox_2.0.2-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_tbb = "tbb"
# Used by:
# generated-recipes/rqt-tf-tree/rqt-tf-tree_1.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-rospkg = "python3-rospkg"
# Used by generated-recipes/ament-virtualenv/ament-virtualenv_0.0.5-5.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-packaging = "python3-packaging"
ROS_UNRESOLVED_PLATFORM_PKG_python3-packaging-native = "python3-packaging-native"
ROS_UNRESOLVED_PLATFORM_PKG_python-virtualenv = "python3-virtualenv"
ROS_UNRESOLVED_PLATFORM_PKG_python-virtualenv-native = "python3-virtualenv-native"
# Used by:
# generated-recipes/mapviz/tile-map_2.0.0-1.bb
# generated-recipes/mapviz/mapviz_2.0.0-1.bb
# generated-recipes/swri-console/swri-console_2.0.0-1.bb
# generated-recipes/mapviz/multires-image_2.0.0-1.bb
# generated-recipes/mapviz/mapviz-plugins_2.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libqt5-opengl-dev = "qtbase"
# Used by:
# generated-recipes/mapviz/mapviz_2.0.0-1.bb
# generated-recipes/mapviz/tile-map_2.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libglew-dev = "glew"
# Used by:
# generated-recipes/mapviz/mapviz_2.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libxmu-dev = "libxmu"
# Used by:
# generated-recipes/mapviz/mapviz_2.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libxi-dev = "libxi"
# Used by:
# generated-recipes/mapviz/tile-map_2.0.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libjsoncpp = "jsoncpp"
ROS_UNRESOLVED_PLATFORM_PKG_libjsoncpp-dev = "jsoncpp"
# Used by:
# generated-recipes/ifm3d-core/ifm3d-core_0.17.0-12.bb
ROS_UNRESOLVED_PLATFORM_PKG_libxmlrpc-c++ = "xmlrpc-c"
# Used by:
# generated-recipes/rc-genicam-api/rc-genicam-api_2.3.5-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libpng-dev = "libpng"
# Used by:
# generated-recipes/marti-common/swri-transform-util_3.2.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_tf2_py = ""
# Used by:
# generated-recipes/marti-common/swri-transform-util_3.2.0-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_launch_xml = ""
# Used by:
# generated-recipes/rc-dynamics-api/rc-dynamics-api_0.10.2-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_protobuf = "protobuf"
# Used by:
# enerated-recipes/cartographer/cartographer_1.0.9001-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libboost-iostreams-dev = "boost"
# Used by:
# generated-recipes/cartographer/cartographer_1.0.9001-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-sphinx = "python3-sphinx"
# Used by:
# generated-recipes/mrt-cmake-modules/mrt-cmake-modules_1.0.8-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_lcov = "lcov"
# Needs https://lists.openembedded.org/g/openembedded-devel/message/86162
ROS_UNRESOLVED_PLATFORM_PKG_lcov-native = "lcov-native"
ROS_UNRESOLVED_PLATFORM_PKG_python3-rospkg-native = "python3-rospkg-native"
# Used by:
# generated-recipes/grbl-ros/grbl-ros_0.0.15-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_python3-serial = "python3-pyserial"
# Used by:
# generated-recipes/lanelet2/lanelet2-python_1.1.1-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libboost-python-dev = "boost"
# Used by:
# generated-recipes/image-pipeline/image-view_2.1.1-1.bb
ROS_UNRESOLVED_PLATFORM_PKG_libboost-dev = "boost"
# XXX Temp until superflore fixed.
# Must use a _pn- override in this file to override the ROS_BUILD_TYPE of a generated recipe,
# because we need to set this variable before the "inherit" line in the recipe is parsed,
# and having it in a .bbappend sets it too late.
ROS_BUILD_TYPE_pn-async-web-server-cpp = "ament_cmake"
ROS_BUILD_TYPE_pn-astuff-sensor-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-automotive-autonomy-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-automotive-navigation-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-automotive-platform-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-behaviortree-cpp-v3 = "ament_cmake"
ROS_BUILD_TYPE_pn-delphi-esr-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-delphi-mrr-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-delphi-srr-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-derived-object-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-fmilibrary-vendor = "ament_cmake"
ROS_BUILD_TYPE_pn-geographic-info = "ament_cmake"
ROS_BUILD_TYPE_pn-gps-umd = "ament_cmake"
ROS_BUILD_TYPE_pn-ibeo-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-kartech-linear-actuator-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-ml-classifiers = "ament_cmake"
ROS_BUILD_TYPE_pn-mobileye-560-660-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-neobotix-usboard-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-pacmod-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-radar-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-ros-workspace = "ament_cmake"
ROS_BUILD_TYPE_pn-sros2-cmake = "ament_cmake"
ROS_BUILD_TYPE_pn-web-video-server = "ament_cmake"
# superflore doesn't resolve the build_type conditions correctly:
# https://github.com/lgsvl/lgsvl_msgs-release/blob/release/foxy/lgsvl_msgs/package.xml#L32
# catkin
# ament_cmake
ROS_BUILD_TYPE_pn-lgsvl-msgs = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-projection = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2 = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-maps = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-validation = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-io = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-python = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-traffic-rules = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-core = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-examples = "ament_cmake"
ROS_BUILD_TYPE_pn-lanelet2-routing = "ament_cmake"
ROS_BUILD_TYPE_pn-mrt-cmake-modules = "ament_cmake"


NYC Space/Time Directory - Architecture
This diagram shows the architecture of NYPL’s NYC Space/Time Directory project — it shows how tools and components work together, and how they share data. Parts of the NYC Space/Time Directory are based on Histograph, a search engine for historical place names built by Waag Society.
Click on any of the project’s components to open it’s GitHub README file. The project’s Documentation repository on GitHub provides more details about the dependencies of various components of the project.
Datasets & their Dependencies
NYC Space/Time Directory’s Orchestrator runs all ETL modules in the right order, and takes their dependencies into account. For example, to create a dataset of historical addresses (e.g. 23½ Myrtle Avenue), the ETL module etl-addresses
combines the locations of historical house numbers with a list of NYC’s streets. For more information about this process, see our tutorial on historical addresses.
This architecture diagram itself can be found on GitHub, too. And it’s easy to make a similar diagram for your own project!


Bivalve Genomics, Mollusca, Genomes, Systematics.
Smithsonian Institution Global Genome Initiative
Unearthed Blogs and link to Research Gate.
Insert Paragraph here.
Recent Publications:
V.L. González et al. 2015. Bivalvia Phylogenomics
V.L. González et al. 2015. Archiheterodonta Phylogeny
S. Lemer et al. 2015. Sipuncula Phylogenomics
P.P. Sharma et al. 2014. Arachnida Phylogenomics
For more publications:
Visit Research Gate PageEducation:
Ph.D. Department of Organismic and Evolutionary Biology, Harvard University, MA, November 12, 2013
M.S. California State University, Los Angeles, CA (Biological Sciences), June 22, 2007
B.S. University of California, Los Angeles, CA (Marine Biology), June 17, 2005
Update this paragraph to link to Blogs and link to Research Gate.


Paid
Free
Top
Bookmarks
Reading List
Shared Links
Active
Disabled
Inactive
Active
Disabled
Inactive
Facebook
Instagram
Slack
Home
Call
Person


| io.ktor.org.apache.commons.collections4.map.AbstractHashedMap |
An abstract implementation of a hash-based map which provides numerous points for subclasses to override. This class implements all the features necessary for a subclass hash-based map. Key-value entries are stored in instances of the Overridable methods are provided to change the default hashing behaviour, and to change how entries are added to and removed from the map. Hopefully, all you need for unusual subclasses is here. NOTE: From Commons Collections 3.1 this class extends AbstractMap. This is to provide backwards compatibility for ReferenceMap between v3.0 and v3.1. This extends clause will be removed in v5.0. |
| io.ktor.org.apache.commons.collections4.map.AbstractLinkedMap |
An abstract implementation of a hash-based map that links entries to create an ordered map and which provides numerous points for subclasses to override. This class implements all the features necessary for a subclass linked hash-based map. Key-value entries are stored in instances of the Overridable methods are provided to change the default hashing behaviour, and to change how entries are added to and removed from the map. Hopefully, all you need for unusual subclasses is here. This implementation maintains order by original insertion, but subclasses may work differently. The The All the available iterators can be reset back to the start by casting to The implementation is also designed to be subclassed, with lots of useful methods exposed. |
| io.ktor.util.AttributeKey |
Specifies a key for an attribute in Attributes |
| io.ktor.util.Attributes |
Map of attributes accessible by AttributeKey in a typed manner |
| io.ktor.util.ByteBufferBuilder |
Helper class for building ByteBuffer with the specific content |
| io.ktor.cio.ByteBufferPool | |
| kotlinx.coroutines.experimental.io.ByteReadChannel (extensions in package io.ktor.cio) | |
| kotlinx.coroutines.experimental.io.ByteReadChannel (extensions in package io.ktor.util) | |
| kotlinx.coroutines.experimental.io.ByteWriteChannel (extensions in package io.ktor.cio) | |
| kotlinx.coroutines.experimental.io.ByteWriteChannel (extensions in package io.ktor.util) | |
| io.ktor.util.CaseInsensitiveMap |
A map with case insensitive String keys |
| io.ktor.cio.ChannelIOException | |
| io.ktor.cio.ChannelReadException | |
| io.ktor.cio.ChannelWriteException | |
| io.ktor.pipeline.ContextDsl | |
| kotlin.coroutines.experimental.CoroutineContext (extensions in package io.ktor.cio) | |
| io.ktor.pipeline.InvalidPhaseException | |
| io.ktor.cio.KtorDefaultPool | |
| org.slf4j.Logger (extensions in package io.ktor.util) | |
| kotlin.ranges.LongRange (extensions in package io.ktor.util) | |
| io.ktor.cio.NoPool | |
| io.ktor.cio.NoopContinuation | |
| kotlinx.io.pool.ObjectPool (extensions in package io.ktor.cio) | |
| io.ktor.pipeline.Pipeline | |
| io.ktor.pipeline.PipelineContext | |
| io.ktor.pipeline.PipelineInterceptor | |
| io.ktor.pipeline.PipelinePhase | |
| io.ktor.cio.PoolTicket | |
| io.ktor.cio.ReleasablePoolTicket | |
| kotlin.String (extensions in package io.ktor.util) | |
| io.ktor.util.ValuesMap |
Provides data structure for associating a String with a List of Strings |
| io.ktor.util.ValuesMapBuilder |


werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr
werwerwerwerwerwerewrwerwerewr werwerwerwerwerwerewrwerwerewr


EVP_RAND-HMAC-DRBG - The HMAC DRBG EVP_RAND implementation
Support for the HMAC deterministic random bit generator through the EVP_RAND API.
"HMAC-DRBG" is the name for this implementation; it can be used with the EVP_RAND_fetch() function.
The supported parameters are:
These parameters work as described in "PARAMETERS" in EVP_RAND(3).
A context for HMAC DRBG can be obtained by calling:
EVP_RAND *rand = EVP_RAND_fetch(NULL, "HMAC-DRBG", NULL);
EVP_RAND_CTX *rctx = EVP_RAND_CTX_new(rand, NULL);
EVP_RAND *rand;
EVP_RAND_CTX *rctx;
unsigned char bytes[100];
OSSL_PARAM params[3], *p = params;
unsigned int strength = 128;
rand = EVP_RAND_fetch(NULL, "HMAC-DRBG", NULL);
rctx = EVP_RAND_CTX_new(rand, NULL);
EVP_RAND_free(rand);
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_MAC, SN_hmac, 0);
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_DIGEST, SN_sha256, 0);
*p = OSSL_PARAM_construct_end();
EVP_RAND_instantiate(rctx, strength, 0, NULL, 0, params);
EVP_RAND_generate(rctx, bytes, sizeof(bytes), strength, 0, NULL, 0);
EVP_RAND_CTX_free(rctx);
NIST SP 800-90A and SP 800-90B
EVP_RAND(3), "PARAMETERS" in EVP_RAND(3)
Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at https://www.openssl.org/source/license.html.


''Mod //A Streetcar Named Desire//'' by Ian Effendi based on the original play by Tennessee Williams.
Workshop Partner(s): Sean Arnold & Cameron Chin
Scene Three (Stage Play) pp. 45-61.
[[Begin Mod|Beat 1]] | [[References]]''References''
Williams, Tennessee (1947). //A Streetcar Named Desire//. A Signet Book. Print.
[[Play Again|Beat 1]].''Beat 1''
Mitch ''flirts'' with Blanche instead of playing the poker game. `[`"You may teach school but you're certainly not an old maid." (pp. 56).`]`
//Mitch and Blanche continue to hold their discussion to the dismay of Stanley, who is frustrated Mitch has not returned to the poker game.//
Stanley ''orders'' Mitch to return to the poker game. `[`"Stanley `[`//bellowing//`]`: //Mitch!//" (pp. 56).`]`
//Blanche and Mitch continue to entertain each other, [[just when Stella exits the bathroom|Beat 2]]//.''Beat 2''
Blanche, noticing her sister has returned from the bathroom, decides to put the music back on. `[` "Oh! Have you finished? Wait - I'll turn on the radio." (pp. 57).`]`
"Wien, Wien, nur du allein," begins to pool from the small white radio in the bedroom. Blanche, arms outstretched, begins to waltz with an invisible partner. With a sway, her eyes spill over Mitch, and her hips move suggestively. Welcoming of this fine display, Mitch lights up, more than happy to join Blanche in this slow dance. `[`Blanche ''entertains'' Mitch, hoping to keep him interested. "Blanche waltzes to the music with romantic gestures. Mitch is delighted and moves in awkward imitation like a dancing bear" (pp. 57).`]`
A storm rolling in from the kitchen, Stanley seizes the radio from the nighttable, shouting unforgivable words.  It is done. Stanley, with a terrible face heavy with breath, pulls in his outstretched arm. `[`Stanley, frustrated with how the evening has gone, ''interrupts'' the dance between Blanche and Mitch, ending the noise distracting him. "Stanley stalks fiercely through the portieres into the bedroom. He crosses to the small white radio and snatches it off the table. With a shouted oath, he tosses the instrument out the window" (pp. 57).`]`
Blanche is so shocked, she considers what might happen next. If this was a typical night, [[Stella might choose to rush the poker table|Beat 3]]; but Blanche is convinced this won't end well for anyone.
Blanche thinks that it is worth a shot to try [[soothing|Alt 1]] Stanley, herself. Of course, if that doesn't work, she can always [[scold|Alt 2]] Stanley in the heat of the moment. If she's feeling particularly brave, she could outright [[defy|Alt 3]] Stanley's desire and sing the same song that was playing on the radio; surely, she and Mitch were enjoying it!''Alternative 1''
Blanche: "Stanley, if that's how the music made you feel, you must let us know!" `[`//Blanche believes her best chance at diffusing the tension in the room is by ''soothing'' Stanley. Before Stella can even react, Blanche apologizes for her disturbance.//`]`
Blanche: "I'm sorry for pushing it!" `[`//She shoots Mitch a strong glance of concern//.`]` "Mitch, go finish your game. There will be other times for us to talk." `[`//Mitch nods in contemplative understanding. Stanley, calmer, steps back from the nighttable.//`]`
Stanley `[`//Mumbling//`]`: "I said stop the racket..."
Mitch: "Suppose your right--I'll finish up." `[`//Gripping Stanley's arm.//`]` "Come, let's leave Ms. DuBois to it."
//Blanche gains peace but loses the opportunity to speak to Mitch and no longer has access to the radio by choosing to ''soothe'' Stanley. Now much calmer, Stanley is allowed to finish his poker game. Blanche and Stella turn in for the night. Although everything has been resolved without tension, this doesn't make for a great, explosive turning point.//
''[[The End|References]]''.''Alternative 2''
Blanche: "A grown man like you? Acting like a wild dog!"
Stanley: "Stop the racket, woman!" `[`//He raises his arm, prepared to bring the full weight of it down on Blanche's cheek.//`]`.
Blanche `[`//Frightened, eyes closed//`]`: "Lord, is this how you treat your wife's sister?"
Stella `[`//Wildly//`]`: "//Stanley! Let her alone!//"
`[`//Stanley hesitates, giving Mitch a chance to grab his arm, stopping it inches from Blanche's face.//`]`
Mitch: "What's gotten into you?"
Stella: "It was just a little bit of music..." `[`//Stanley realizes everyone is looking at him. By now, everyone at the poker table has shuffled into the doorway of the bedroom.//`]`
Stella `[`//Sighing//`]`: We'll have to get a new one."
Stanley: "Alright, shows over." `[`//He begins to wave and shoo the other players away.//`]` "Get on home with you. I'm going to bed."
//Blanche feels good about standing up to Stanley and ''scolding'' him. Stanley does not finish his poker game, balking under the embarassment. Stella, more than ready for this night to come to an end, encourages him to wash his face before bed.  `[`//He flings out a wild punch towards Blanche that Mitch manages to push off.//`]`.
Blanche `[`//Unflinching//`]`: "~nur du allien~" `[`//Stanley tries to grab Blanche's arm to pull her out the room, but, Mitch stands his ground between them.//`]`
Stella `[`//Shouting//`]`: "//Stanley! Don't you touch her!//"
`[`//Stanley, still angry, punches Mitch square in the nose.//`]`
Mitch `[`//Clutching face//`]`: "You //f**k!//"
Stanley `[`//Slurring//`]`: "Don't tell me what I can and can't do in my house."
`[`//By now, the others have mobilized, moving from the poker table to pin Stanley down to the floor to prevent him from hurting others or himself.//`]`.
Mitch `[`//Nasally//`]`: "Y-you //broke// it. My nose."
//Blanche, unintimidated by Stanley’s drunken attempt at subjugation, breaks out into song, ''defying'' his wishes. If she couldn’t have the music from the radio, she would still have the music in her heart. Lovely as her voice may be, it does little to stop the drunkard from flying into a fit of rage. Luckily, with Mitch’s quick-thinking, Stanley’s fist is stopped short of harming Blanche, but, it meant he bore the brunt of the attack instead.//
''[[The End|References]]''.''Turning Point''
Blanche, in the end, chooses to do nothing different. The night plays out in a typical, explosive fashion.
Stella, furious with her husband's wanton destruction, decides to put an end to the night's action herself. Armed with nothing but her frustrations, she bears toward the poker table, declaring it is time to leave, but not before calling her husband a stinking drunkard. `[`Stella ''rushes'' the poker table to curse Stanley out and kick out his friends. "//Drunk-drunk-animal thing, you!// `[`//She rushes through to the poker table//`]` All of you-please go home! If any of you have one spark of decency in you-" (pp. 57).`]`.
Stanley, drunk and angry, doesn't like being compared to a stinking animal. Like any feral man who refuses to see his faults, there is no pause to ponder the situation nor ounce of restraint in his action. By the time he reaches Stella, it is too late. Blanche's warning does not stop his fists and his colleagues are too slow to prevent the inevitable. `[`Blanche `[`//wildly//`]`: Stella, watch out, he's-- `[`//Stanley charges after Stella//.`]` ... `[`//There is the sound of a blow//`]` (pp. 57).`]`.
But you already knew this was going to happen.
''[[The End|References]]''.
|fh>[Farah] squints at the sharp, black numbers dotting the |sp>[spreadsheet] in front of her.
{
(click: ?fh)[(display: "Farah Kassab")]
}
{
(click: ?sp)[She is struggling to parse the immediate meaning behind the numbers. (transition: "dissolve")[|gn>[Where exactly had more than $120,000 of the company's funds gone over the past ten years]?]]
}
(click: ?gn)[(transition: "dissolve")[Her eyes enlarge in shock; her jaw slack and awed. "|on>[Oh no.]"]]
(click: ?on)[(transition: "dissolve")[It dawned upon Farah. Naseem had been taking the extra funds. If these numbers are correct, he pays less in taxes than most middle-class families do. (transition: "dissolve")[|ds>[She has to do something.]]]]
(click: ?ds)[|prompt>[Farah can either |shred>[shred these documents] or |keep>[confront Nasseem with them intact].]]
{
(click: ?shred)[
(set: $documents to "shredded")
(replace: ?prompt)[Farah has decided to shred the documents.]
All that's left is to [[confront Nasseem|Confrontation]].]
(click: ?keep)[
(set: $documents to "saved")
(replace: ?prompt)[Farah has decided to keep the documents.]
All that's left is to [[confront Nasseem|Confrontation]].]
}Farah found the job offer on a Craigslist post, of all places. "**Need Accountant ASAP!**" was written out with a couple paragraphs explaining why the last one had suddenly left the company. Sure, the post looked a little seedy - but Farah needed the money. Rent has been rising and her $20,000 balance on those student loans won't pay themselves.Naseem Gerges, the big boss of the company, is not a quiet man. The sound of his laughter can shake the windows on a good day. His anger? It's not *enjoyable* to think about.
Apparently, he started the company in the early aughts, right at the turn of the century.  It isn't quite clear how or why. It's a different story each time.
Was it inconsistent? He might admit it if you asked him on a good day, the words rolling off the tongue with a subtle hint of pride: "Of course it was: *it's just business*." Farah rushes into Naseem's office. |ns>[Naseem's brow is furrowed, an inquisitive look painted across his face].
(click: ?ns)["Farah? What's going on?" His eyebrows are raised.
Farah grills Naseem. "How long have you been taking money from the endowment fund?"
Naseem opens his mouth to speak, the words stopping just short of being said. He ponders the noise outside the office for a moment. |shut>["Farah, can you please shut the door?"]]
(click: ?shut)[Quickly and quietly, Farah shuts the door.
The breeze shuffles a stack papers on the CEO's desk. Naseem readjusts the pile - all neat and orderly and static - before looking up again.
"Where did you hear about this?" Naseem asks, deflecting the question.
[[Farah will have to interrogate|Interrogation]].]"Naseem, I have been preparing for the |aud>[audit] all month." Farah sighs. "Did you think I |find>[wouldn't find out]?" (if: $documents is "saved")[Farah's hand grips the papers in her hand tightly. "The financial data that gives you away is from the first ten years; you've been in business for far longer"].
{
(click: ?aud)[Six weeks ago, Farah had been asked by the company's legal advisor to collect the last decade's worth of financial reports. They also suggested that they start looking for work elsewhere. At first, Farah thought it was a threat.
It all makes sense now.]
}
(click: ?find)[
Silence. Naseem stares blankly at the stack of papers in front of him.
"How long have you been taking the *fucking* money Naseem?"
*SLAM*. The sound of Naseem's fist hammering the table reverberates around the room.
"You don't get to talk to me like that!" Flustered, red, and steaming, Naseem huffs, already out of breath. "|obv>[You obviously read the numbers wrong and need to go back-]"
]
(mouseover: ?obv)["Don't you dare," Farah interrupts, finger pointing at the suspect in the room.
Naseem brings gestures with two open hands. "Calm, calm."
"[[Let's figure this one out|Caution]]."]
Double-click this passage to edit it.


Offers a variety of tools, such as specific plots and regression model approaches, for analyzing different patient reported questionnaires. Specially, mixed-effects models based on the beta-binomial distribution are implemented to deal with binomial data with over-dispersion (see Najera-Zuloaga J., Lee D.-J. and Arostegui I. (2017) <doi:10.1177/0962280217690413>).
| Version: | 1.0 |
| Imports: | fmsb, car, RColorBrewer, matrixcalc, rootSolve, numDeriv, Matrix |
| Published: | 2017-05-06 |
| Author: | Josu Najera, Dae-Jin Lee, Inmaculada Arostegui |
| Maintainer: | Josu Najera <jnajera at bcamath.org> |
| License: | GPL-2 | GPL-3 [expanded from: GPL] |
| NeedsCompilation: | no |
| CRAN checks: | PROreg results |
| Reference manual: | PROreg.pdf |
| Package source: | PROreg_1.0.tar.gz |
| Windows binaries: | r-devel: PROreg_1.0.zip, r-release: PROreg_1.0.zip, r-oldrel: PROreg_1.0.zip |
| OS X binaries: | r-release: PROreg_1.0.tgz, r-oldrel: PROreg_1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=PROreg to link to this page.


Lesson 1 - Setup
In this article we will be setting up the infrastructure to build the JavaScript file that will be served to the players, the main game loop, and the capability to draw things on the screen.
Setting up the tools
In a web browser context, all JavaScript code that needs to be executed by the end user must ultimately be served through a   Pay particular attention to the

Now that the PixiJS container exists, we can go ahead and add the PixiJS code to our game, in the src/engine.js
file.
It should look something like this:
const MainLoop = require("mainloop.js"); const PIXI = require("pixi.js"); let pixiApp = new PIXI.Application({antialias: true}); let pixiContainer = document.getElementById("pixi-container"); pixiContainer.appendChild(pixiApp.view); let loopCounter = 0; MainLoop.setUpdate(() => { console.log("The game loop has been executed " + loopCounter + " times."); loopCounter++; }).start();After building the game and refreshing the page, you should see a black rectangle, which is the default PixiJS background color. We can also inspect the page using the browser's development tools, and it should look something like this:
Drawing things on the screen with PixiJS
Let's draw something a bit more interesting than a black screen.
One of the features of PixiJS is the ability to draw primitive shapes, such as lines, circles, rectangles, and other polygons.
This is done using the PIXI.graphics
class, and all we have to do is make an instance of that class and attach it to the default PixiJS stage.
Here's how our engine.js
file would look like:
const MainLoop = require("mainloop.js"); const PIXI = require("pixi.js"); let pixiApp = new PIXI.Application({antialias: true}); let pixiContainer = document.getElementById("pixi-container"); let pixiGraphics = new PIXI.Graphics(); pixiApp.stage.addChild(pixiGraphics); pixiContainer.appendChild(pixiApp.view); let loopCounter = 0; MainLoop.setUpdate(() => { console.log("The game loop has been executed " + loopCounter + " times."); loopCounter++; }).start();If the browser console is not giving out any errors, we've successfully added the graphics object to PixiJS.
Drawing using the PIXI.graphics
class is quite easy. Let's draw a triangle and examine the details:
pixiGraphics.beginFill(0x00FF00); pixiGraphics.drawPolygon([60,70,190,50,40,200]); pixiGraphics.endFill();We should see a green triangle on the black canvas.
Notice the three methods, beginFill()
, drawPolygon()
, and endFill()
.
beginFill()
initializes the PIXI.graphics
drawing method, and also sets the fill color of the drawn shape.
In our case, the first parameter of beginFill()
is a hexadecimal code representing the color green in the RGB color space.
drawPolygon()
is responsible for actually drawing the triangle on the screen. It's accepts an array of numbers as an argument.
These numbers are the coordinates of the vertices of the triangle, and are ordered such that the first element of the array is the x coordinate of the first point,
the second element is the y coordinate of the first point, the third element is the x coordinate of the second point, and so on.
endFill()
finishes drawing the polygon. This function is needed so that subsequent calls to beginFill()
will draw other polygons instead of continuing the current polygon.
The final version of the engine.js
file should look like this:
const MainLoop = require("mainloop.js"); const PIXI = require("pixi.js"); let pixiApp = new PIXI.Application({antialias: true}); let pixiContainer = document.getElementById("pixi-container"); let pixiGraphics = new PIXI.Graphics(); pixiGraphics.beginFill(0x00FF00); pixiGraphics.drawPolygon([60,70,190,50,40,200]); pixiGraphics.endFill(); pixiApp.stage.addChild(pixiGraphics); pixiContainer.appendChild(pixiApp.view); let loopCounter = 0; MainLoop.setUpdate(() => { console.log("The game loop has been executed " + loopCounter + " times."); loopCounter++; }).start();
Conclusion
The web and JavaScript hold great promise as gaming platforms. The ability to distribute games and updates just by sharing a link is unmatched by any platform, and is the reason for the web's dominance in business and productivity apps. I hope to show that the same capability is present in web games as well, and that JavaScript is mature enough to be not just a teaching tool, but a primary development language for games.


@ParametersAreNonnullByDefault
org.eclipse.core.runtime
package
of the Eclipse Platform.See: Description
| Interface | Description |
|---|---|
| PluginConsole |
Plug-in console capable of printing various kinds of messages.
|
| PluginConsoleFactory |
The
PluginConsoleFactory creates PluginConsole instances. |
| Class | Description |
|---|---|
| CoreExceptions | |
| ExtendedPlugin |
An abstract plug-in with extended basic capabilities.
|
| ForwardingPluginConsole |
A plug-in console which forwards all its method calls to another plug-in
console.
|
| PlatformBundles |
Static utility methods pertaining to standard Eclipse bundles.
|
| PluginConsoles |
Static utility methods pertaining to
PluginConsole instances. |
| Products |
Static utility methods pertaining to Eclipse products.
|
| TimeHookConsole |
| Enum | Description |
|---|---|
| StatusSeverity |
Status severities.
|
| Exception | Description |
|---|---|
| RuntimeCoreException |
org.eclipse.core.runtime
package
of the Eclipse Platform.


three.js
pathtracer -
three-gpu-pathtracer
See
main project repository
for more information and examples on high fidelity path tracing.
This software uses the LDraw Parts Library


Before Change
running_sum += samples.sum().item()
running_sum_of_squares += samples.pow(2).sum().item()
N = float(num_time_steps * num_chains) // total number of samples
mean = running_sum / N
variance = running_sum_of_squares - ((running_sum ** 2) / N)
variance /= N - 1
std_error = np.sqrt(variance / N)
After Change
running_mean = 0.0
running_variance = 0.0
running_length = 0
chains = None
num_chains = num_chains if num_chains != 0 else num_samples
num_time_steps = int(np.ceil(num_samples / num_chains))
for i in range(num_time_steps):
num_gibbs_steps = burn_in if i == 0 else steps
chains = nn_state.sample(
num_samples=num_chains,
k=num_gibbs_steps,
initial_state=chains,
overwrite=True,
)
samples = self.apply(nn_state, chains).data
current_mean = samples.mean().item()
current_variance = samples.var().item()
running_mean, running_variance, running_length = self._update_statistics(
running_mean,
running_variance,
running_length,
current_mean,
current_variance,
num_chains,
)
N = running_length // total number of samples
std_error = np.sqrt(running_variance / N)


public static class NotificationCompat.Action
extends NotificationCompatBase.Action
PendingIntent
to be fired when the action is
selected by the user. Action buttons won't appear on platforms prior to Android 4.1.
Apps should use NotificationCompat.Builder.addAction(int, CharSequence, PendingIntent)
or NotificationCompat.Builder.addAction(NotificationCompat.Action)
to attach actions.
| Modifier and Type | Class and Description |
|---|---|
static class |
NotificationCompat.Action.Builder
Builder class for
NotificationCompat.Action objects. |
static interface |
NotificationCompat.Action.Extender
Extender interface for use with
NotificationCompat.Builder.extend(android.support.v4.app.NotificationCompat.Extender) . |
static class |
NotificationCompat.Action.WearableExtender
Wearable extender for notification actions.
|
| Modifier and Type | Field and Description |
|---|---|
PendingIntent |
actionIntent
Intent to send when the user invokes this action.
|
static Factory |
FACTORY |
int |
icon
Small icon representing the action.
|
java.lang.CharSequence |
title
Title of the action.
|
| Constructor and Description |
|---|
NotificationCompat.Action(int icon,
java.lang.CharSequence title,
PendingIntent intent) |
| Modifier and Type | Method and Description |
|---|---|
protected PendingIntent |
getActionIntent() |
Bundle |
getExtras()
Get additional metadata carried around with this Action.
|
protected int |
getIcon() |
RemoteInput[] |
getRemoteInputs()
Get the list of inputs to be collected from the user when this action is sent.
|
protected java.lang.CharSequence |
getTitle() |
public int icon
public java.lang.CharSequence title
public PendingIntent actionIntent
public static final Factory FACTORY
public NotificationCompat.Action(int icon, java.lang.CharSequence title, PendingIntent intent)
protected int getIcon()
protected java.lang.CharSequence getTitle()
protected PendingIntent getActionIntent()
public Bundle getExtras()
public RemoteInput[] getRemoteInputs()


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.tabuto.jenetic.Dna
public class Dna
Class Dna
Dna
is a class that represent a simple model of DNA as a Gene
Vector.
Add a Gene
into Dna
is simple by using the add(Gene)
,add(double)
add(boolean)
methods.
So the Dna
is just a information's object container, able to save or load itself using an XML file
thanks to methods save(String)
and load(String)
Dna
class also provides a merge(Dna)
method simulating the Dna Genetic Recombination.
During this process it's possible introduce some "noise" using the param
variable.
Gene
,
Serialized Form| Field Summary | |
|---|---|
protected java.util.Vector<Gene> |
DNA
The Vector Gene is a dinamic array where Gene are stored |
private java.lang.String |
Name
The name of this DNA |
protected double |
param
This variable represent the percent of mutation introduced by merge(Dna) method. |
private static long |
serialVersionUID
The serial Version UID |
| Constructor Summary | |
|---|---|
Dna()
This method instance a new empty Dna Object. |
|
Dna(double p)
This method instance a new empty Dna Object with a parameter for Genetic Recombination. |
|
Dna(java.lang.String Name)
This method instance a new Dna Object using a specified name |
|
Dna(java.lang.String Name,
double p)
This method instance a new Dna Object using a specified name
and param |
| Method Summary | |
|---|---|
void |
add(boolean b)
Add a new Boolean Gene into Dna |
void |
add(boolean b,
java.lang.String Name)
Add a new Boolean Gene into Dna by setting his value and his name |
void |
add(boolean b,
java.lang.String Name,
java.lang.String Description)
Add a new Boolean Gene into Dna by setting his value and his name |
void |
add(java.lang.Byte d)
Add a new Byte Gene into Dna |
void |
add(java.lang.Byte d,
java.lang.String Name)
Add a new Byte Gene into Dna by setting his value and his name |
void |
add(java.lang.Byte d,
java.lang.String Name,
java.lang.String description)
Add a new Byte Gene into Dna by setting his value and his name |
void |
add(double d)
Add a new Double Gene into Dna |
void |
add(double d,
java.lang.String Name)
Add a new Double Gene into Dna by setting his value and his name |
void |
add(double d,
java.lang.String Name,
java.lang.String description)
Add a new Double Gene into Dna by setting his value and his name |
void |
add(Gene g)
Append a new Gene into Dna Vector |
void |
add(int d)
Add a new Integer Gene into Dna |
void |
add(java.lang.Integer d)
Add a new Integer Gene into Dna |
void |
add(java.lang.Integer d,
java.lang.String Name)
Add a new Integer Gene into Dna by setting his value and his name |
void |
add(java.lang.Integer d,
java.lang.String Name,
java.lang.String description)
Add a new Integer Gene into Dna by setting his value and his name |
void |
add(int d,
java.lang.String Name)
Add a new Integer Gene into Dna by setting his value and his name |
void |
add(int d,
java.lang.String Name,
java.lang.String description)
Add a new Integer Gene into Dna by setting his value and his name |
protected Gene |
combineGene(Gene g1,
Gene g2)
Return a new Gene as a parametric param combination between they values |
protected Gene |
findGeneByName(java.lang.String name)
Find a Dna's Gene by his Name |
Gene |
getGene(int index)
Return the Gene at specified index |
Gene |
getGene(java.lang.String name)
Return the Gene with specified String name |
java.lang.String |
getName()
|
double |
getParam()
Return the param variable of Dna. |
int |
getSize()
Return the Gene double's value at specific index. |
static Dna |
load(java.lang.String filename)
Static method returns a previusly saved Dna. |
void |
loadXML(java.lang.String fileName)
Deprecated. Use static method load(String) |
Dna |
merge(Dna otherDna)
This method merge this Dna with other and return a new Dna Code. |
static Dna |
merge(Dna firstDna,
Dna secondDna)
Static method returns a new Dna as a parametric merge between two
same-size Dna. |
void |
save(java.lang.String filename)
Save a copy of DNA object in a binary file with .dna extension. |
void |
setName(java.lang.String name)
Set the name of this Dna |
void |
setParam(double p)
Set the param variable of Dna. |
void |
setRandomParam()
Set the param variable of Dna as a random double |
private static Gene |
staticCombineGene(Gene g1,
Gene g2,
double param)
Return a new Gene as a parametric param combination between they values |
java.lang.String |
toString()
|
org.jdom.Document |
toXML()
Return a XML document represent this DNA with description List of ist genes |
void |
toXML(java.lang.String fileName)
Write a XML file represent this DNA with description List of ist genes |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
|---|
private static final long serialVersionUID
protected java.util.Vector<Gene> DNA
Gene
are stored
protected double param
merge(Dna)
method.
The param
value should be between 0 and 1. Default value is 0;
merge(Dna)
,
merge(Dna, Dna)
private java.lang.String Name
| Constructor Detail |
|---|
public Dna()
Dna
Object.
public Dna(double p)
Dna
Object with a parameter for Genetic Recombination.
p
- double
Dna Parameter param
public Dna(java.lang.String Name)
Dna
Object using a specified name
Name
- String
the Dna namepublic Dna(java.lang.String Name, double p)
Dna
Object using a specified name
and param
Name
- String
the Dna Namep
- double
Dna param
| Method Detail |
|---|
public void add(Gene g)
Gene
into Dna
Vector
g
- Gene
newGenepublic void add(double d)
Gene
into Dna
d
- double
Gene Double Valuepublic void add(double d, java.lang.String Name)
Gene
into Dna
by setting his value and his name
d
- double
Gene ValueName
- String
Gene's Namepublic void add(double d, java.lang.String Name, java.lang.String description)
Gene
into Dna
by setting his value and his name
d
- double
Gene ValueName
- String
Gene's Namedescription
- String
Gene's Descriptionpublic void add(java.lang.Integer d)
Gene
into Dna
d
- Integer
Gene int Valuepublic void add(java.lang.Integer d, java.lang.String Name)
Gene
into Dna
by setting his value and his name
d
- Integer
Gene ValueName
- String
Gene's Namepublic void add(java.lang.Integer d, java.lang.String Name, java.lang.String description)
Gene
into Dna
by setting his value and his name
d
- int
Gene ValueName
- String
Gene's Namedescription
- String
Gene's Descriptionpublic void add(int d)
Gene
into Dna
d
- Integer
Gene int Valuepublic void add(int d, java.lang.String Name)
Gene
into Dna
by setting his value and his name
d
- Integer
Gene ValueName
- String
Gene's Namepublic void add(int d, java.lang.String Name, java.lang.String description)
Gene
into Dna
by setting his value and his name
d
- int
Gene ValueName
- String
Gene's Namedescription
- String
Gene's Descriptionpublic void add(java.lang.Byte d)
Gene
into Dna
d
- Byte
Gene Double Valuepublic void add(java.lang.Byte d, java.lang.String Name)
Gene
into Dna
by setting his value and his name
d
- Byte
Gene ValueName
- String
Gene's Namepublic void add(java.lang.Byte d, java.lang.String Name, java.lang.String description)
Gene
into Dna
by setting his value and his name
d
- Byte
Gene ValueName
- String
Gene's Namedescription
- String
Gene's Descriptionpublic void add(boolean b)
Gene
into Dna
b
- boolean
Gene Valuepublic void add(boolean b, java.lang.String Name)
Gene
into Dna
by setting his value and his name
b
- boolean
Gene ValueName
- String
Gene's Namepublic void add(boolean b, java.lang.String Name, java.lang.String Description)
Gene
into Dna
by setting his value and his name
b
- boolean
Gene ValueName
- String
Gene's Namepublic Gene getGene(int index)
Gene
at specified index
index
- int
Dna's Vector Index
Gene
public Gene getGene(java.lang.String name)
Gene
with specified String
name
name
- the name of Gene
public java.lang.String getName()
public double getParam()
param
variable of Dna.
double
Dna Parameter param
public int getSize()
Gene
double's value at specific index.
double
public Dna merge(Dna otherDna)
param
is not equals to zero,
in the merging process in order to simulate a genetic mutation;
otherDna
-
public static Dna merge(Dna firstDna, Dna secondDna)
Static
method returns a new Dna as a parametric merge between two
same-size Dna.
firstDna
- secondDna
-
param
public void loadXML(java.lang.String fileName)
load(String)
save(String)
Can't load Gene containing not primitive objects!!
fileName
- String
public static Dna load(java.lang.String filename)
Static
method returns a previusly saved Dna.
Dna file must be a previusly saved .dna file extension
filename
- file name
Dna
Dna#save(String)}
public void save(java.lang.String filename)
Dna MyNewDna = null; FileInputStream fis = null; ObjectInputStream in = null; try { fis = new FileInputStream(filename); in = new ObjectInputStream(fis); MyNewDna = (Dna)in.readObject(); in.close(); } catch(IOException ex) { ex.printStackTrace(); } catch(ClassNotFoundException ex) { ex.printStackTrace(); }
filename
- public void setName(java.lang.String name)
name
- of this Dnapublic void setParam(double p)
param
variable of Dna.
Should be a double between 0 and 1
p
- double
Dna Parameter param
public void setRandomParam()
param
variable of Dna as a random double
public java.lang.String toString()
toString
in class java.lang.Object
public org.jdom.Document toXML()
load(String)
public void toXML(java.lang.String fileName)
fileName
- String
load(String)
protected Gene combineGene(Gene g1, Gene g2) throws java.lang.NumberFormatException
param
combination between they values
java.lang.NumberFormatException
protected Gene findGeneByName(java.lang.String name)
name
- Gene's Name
private static Gene staticCombineGene(Gene g1, Gene g2, double param) throws java.lang.NumberFormatException
param
combination between they values
java.lang.NumberFormatException
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Info (v. 2.6.0)
This app allows to:
- 1) Access a specific Geological Data service that, according to the position of the device, detected by its GPS sensor, connects to a WCS server operated by BGS and retrieve/display geological data;
- 2) Access a specific Climate Data service that, according to the position of the device, detected by its GPS sensor, connects to a WCS server operated by a MEEO and retrieve/display meteorological and pollution data;
- 3) Use a general-purpose service to connect to different WCS/WMS servers, explore their capabilities and download/display/overlay coverages according to a given bounding box;
- 4) Access a geographically distributed repository of a sample of ESA MERIS multi-format data stored both on local and Grid/Cloud resources.
Credits
This app has been developed by:
- Roberto Barbera
- Antonio Calanducci
- Marco Pappalardo
- Rita Ricceri
- Francesco Rundo
- Vittorio Sorbera
- Mario Torrisi
working at (1) Consorzio COMETA, (2) Division of Catania of the Italian National Institute of Nuclear Physics (INFN) and Software Engineering Italia s.r.l., in the context of the EU FP7 co-funded EarthServer project (Grant Agreement no. 283610).


Trump attorneys file notice of porn actress settlement
by EndPlayCOLUMBUS, Ohio (AP) - Attorneys for President Donald Trump have notified the court overseeing a settlement between Ohio's capital city and porn actress Stormy Daniels of money owed to him by Daniels.
A federal judge last year said Daniels, whose real name is Stephanie Clifford, must pay Trump nearly $293,000 for his attorneys' fees and another $1,000 in sanctions after her defamation suit against him was dismissed.
Earlier this year, the city of Columbus reached a $450,000 settlement with Daniels over the porn actress' arrest at a strip club in 2018.
Her federal lawsuit alleged officers conspired to retaliate against her over her claims she had sex with Trump before he became president.
Trump's lawyers said in a Wednesday filing that Clifford owes him $293,052.
Messages were left for Trump's and Daniels' attorneys.