This chapter describe the functions for creating and managing multiple concurrent tasks (or threads of execution). We will also learn about reactive variables and see how to write multi-core parallel programs.
function: task(f, @key args, suspended, name = void, group)
returns: a new task.
The function `f` is executed in the new task. If `args` are not provided or is false,
`f` is treated as a no-argument function. Otherwise the list of objects `args `is
passed to `f` when it is called. `f` should take as many arguments as there are
elements in `args`. If `suspended` is true the task is created in the suspended
state. It has to be started with a call to `task_run(task)`. If provided, `name` and
`group` identifies the task's name and the group it belongs to.
syntax: !expression
returns: a new task.
`expression` is executed in the new task.
// Example:
!let loop(i = 0) { showln(i); task_sleep(2); loop(i+1) };
//=> <task>
// the task will print the new value of `i` in the background, every two seconds.
//-> 0
1
2 ...
function: root_task(f, @key args, suspended, name = void, group,
input_stream = current_input_stream(),
output_stream = current_output_stream())
returns: a new task.
This function is similar to task() except the created task does not inherit the
dynamic environment from the current task and the base priority is set to 0,
the priority boost is set to 1.0e-6, and the quantum is set to 0.02.
The dynamic environment of the task has the global bindings of the parameter objects,
except current_input_stream which is bound to input_stream,
current_output_stream which is bound to output_stream, and current_directory which is
bound to the initial current working directory of the current process.
function: self()
returns: the current task.
function: is_task(obj)
returns: true if `obj` is a task object, false otherwise.
function: task_run(task)
returns: `task`.
Makes `task` runnable.
// Example:
let a = task(^(x, y) showln(x + y), args = [10, 20], suspended = true);
task_run(a);
//-> 30
function: task_yield()
returns: void
Causes the current task to exit the running state as if its quantum had expired.
function: task_sleep(timeout)
returns: void
Causes the current task to wait until `timeout` is reached. This blocks the task
only if `timeout` represents a point in the future. It is an error for `timeout` to be false.
`timeout` can be exact integers to indicate seconds or fractional numbers to indicate
sub-second timeouts.
function: task_terminate(task)
returns: void
Causes an abnormal termination of `task`. If `task` is not already terminated, all mutexes
owned by it become unlocked/abandoned and a terminated-exception object is stored in its
`end-exception` field. If `task` is the current task, task_terminate does not return.
The actual termination of `task` will occur at some point between the calling of task_terminate
and a finite time in the future (an explicit task synchronization is needed to detect
termination, see task_join).
function: task_join(task, @optional timeout, timeout_val)
returns: `timeout_val`
Causes the current task to wait until `task` terminates (normally or not) or until the
`timeout` is reached (if `timeout` is supplied). If `timeout` is reached, this function
returns `timeout_val` (if it is supplied), otherwise a join-timeout-exception object
is raised. If `task` terminated normally, the content of its end-result field is
returned, otherwise the content of its end-exception field is raised.
function: task_name(task)
returns: the name of `task`.
function: task_set_data(task, obj)
returns: void
Puts an arbitrary object `obj` in task's data field.
function: task_data(task)
returns: the arbitrary object in the task's data field.
function: task_set_base_priority(task, p)
returns: void
Sets the base priority of `task` to the real number `p`.
function: task_base_priority(task)
returns: the base priority of `task`.
function: task_set_priority_boost(task, p)
returns: void
Sets the priority boost of `task` to the non-negative real number `p`.
function: task_priority_boost(task)
returns: the priority boost of `task`.
function: task_base_priority(task)
returns: the base priority of `task`.
function: task_set_quantum(task, q)
returns: void
Sets the quantum of `task` to the non-negative real number `q`.
function: task_quantum(task)
returns: the quantum of `task`.
function: task_send(task, msg)
returns: void
Adds the message `msg` at the end of the mailbox `task`.
`msg` can be any valid Slogan object.
syntax: task !> msg
returns: msg
Adds the message `msg` at the end of the mailbox `task`.
`msg` can be any valid Slogan object.
function: task_receive(@optional timeout, default)
function: task_messages_next(@optional timeout, default)
syntax: !<
returns: a message from the current task's mailbox.
`task_receive` advances the mailbox cursor of the current task to the next message,
removes that message from the mailbox, rewinds the mailbox cursor, and returns the message.
When `timeout` is not specified, the current task will wait until a message is available in the
mailbox. When `timeout` is specified and `default` is not specified,
a mailbox-receive-timeout-exception object is raised if the timeout is reached before a
message is available. When `timeout` is specified and default is specified, `default`
is returned if the timeout is reached before a message is available.
The `!<` operator has the same semantics as task_receive without `timeout` and
`default` specified.
`task_messages_next` behaves like task_receive except that the message remains in
the mailbox and the mailbox cursor is not rewound.
// Examples:
let t1 = task(^let loop (msg = task_receive()) { task_send(head(msg), tail(msg) * 2);
loop(task_receive()) });
task_send(t1, self():10);
task_receive();
//=> 20
task_send(t1, self():2);
task_receive();
//=> 4
// the same program using the shorter ! syntax:
let t2 = !let loop (msg = !<) { head(msg) !> tail(msg) * 2; loop(!<) };
t2 !> self():10;
!<;
//=> 20
t2 !> self():2;
!<;
//=> 4
function: task_messages_rewind(@optional remove_last_read)
returns: void
Rewinds the mailbox cursor of the current task so that the next call to task_messages_next
and task_receive will access the oldest message in the mailbox. Additionally if `remove_last_read`
is true the message most recently accessed by a call to task_messages_next will be removed from
the mailbox. When task_messages_next has not been called since the last call to task_receive or
task_messages_rewind, a call to task_messages_rewind with remove_last_read set to true only
resets the mailbox cursor (no message is removed).
function: task_group(name = void, parent)
returns: a new task group identified by `name` and with the parent group `parent`.
function: is_task_group(obj)
returns: true if `obj` is a task group, false otherwise.
function: task_group_name(tg)
returns: the name of the task group `tg`.
function: task_group_parent(tg)
returns: the parent group of the task group `tg`.
function: task_group_resume(tg)
returns: marks all tasks in the group `tg` as runnable.
function: task_group_suspend(tg)
returns: marks all tasks in the group `tg` as not runnable.
function: task_group_terminate(tg)
returns: marks all tasks in the group `tg` for termination.
function: task_state(task)
returns: returns an object that represents the state of `task`.
The following functions are provided to query various properties of a task state object returned by the task_state
function:
function: task_state_is_uninitialized(ts)
function: task_state_is_initialized(ts)
function: task_state_is_active(ts)
function: task_state_active_waiting_for(ts)
function: task_state_active_timeout(ts)
function: task_state_is_normally_terminated(ts)
function: task_state_normally_terminated_result(ts)
function: task_state_is_abnormally_terminated(ts)
function: task_state_abnormally_terminated_reason(ts)
returns: returns a state variable associated with the task state object `ts`.
function: mutex(name = void)
returns: a new mutex in the unlocked/not-abandoned state.
function: is_mutex(obj)
returns: true if `obj` is a mutex, false otherwise.
function: mutex_name(mutex)
returns: the name of `mutex`.
function: mutex_set_data(mutex, obj)
returns: void
Sets the data field of `mutex` to the arbitrary object `obj`.
function: mutex_data(mutex)
returns: the arbitrary object in the data field of `mutex`.
function: mutex_state(mutex)
returns: information about the state of `mutex`.
Possible states are:
task T: the mutex is in the locked/owned state and task T is the owner of the mutex.
'not_owned: the mutex is in the locked/not-owned state.
'abandoned: the mutex is in the unlocked/abandoned state.
'not_abandoned: the mutex is in the unlocked/not-abandoned state.
function: mutex_lock(mutex, @optional timeout, task)
returns: either true or false.
Locks `mutex`. If `mutex` is currently locked, the current task waits until
`mutex` is unlocked, or until `timeout` is reached (if `timeout` is supplied).
If `timeout` is reached, mutex_lock returns false. Otherwise, the state of
`mutex` is changed as follows:
if task is false `mutex` becomes locked/not-owned,
otherwise, let T be task (or the current task if task is not supplied),
if T is terminated `mutex` becomes unlocked/abandoned,
otherwise `mutex` becomes locked/owned with T as the owner.
After changing the state of `mutex`, an abandoned-mutex-exception object
is raised if `mutex` was unlocked/abandoned before the state change,
otherwise mutex_lock returns true. It is not an error if `mutex` is owned
by the current task (but the current task will have to wait).
function: mutex_unlock(mutex, @optional monitor, timeout)
returns: either true or false.
Unlocks `mutex` by making it unlocked/not-abandoned.
It is not an error to unlock an unlocked mutex and a mutex that is
owned by any task. If the monitor (or condition-variable) monitor is supplied,
the current task is blocked and added to the monitor before unlocking `mutex`;
the task can unblock at any time but no later than when an appropriate call
to monitor_notify or monitor_broadcast is performed (see below), and no later
than the timeout (if timeout is supplied). If there are tasks waiting to lock
this mutex, the scheduler selects a task, the mutex becomes locked/owned or
locked/not-owned, and the task is unblocked. Mutex_unlock returns false when
the timeout is reached, otherwise it returns true.
function: monitor(name = void)
returns: a new monitor.
function: is_monitor(obj)
returns: true if `obj` is a monitor object, false otherwise.
function: monitor_name(monitor)
returns: the name of `monitor`.
function: monitor_set_data(monitor, obj)
returns: void
Sets the data field of `monitor` to the arbitrary object `obj`.
function: monitor_data(monitor)
returns: the arbitrary object in the data field of `monitor`.
function: monitor_notify(monitor)
returns: void
Unblocks a task blocked on `monitor` (if there is at least one).
function: monitor_broadcast(monitor)
returns: void
Unblocks all tasks blocked on `monitor`.
Reactive variables are used in writing declarative concurrent programs. A newly initialized reactive variable will be in an unbound state. If a task requires the value of a reactive variable, it will wait until that variable is bound. This binding can happen only in another task. Thus reactive variables can act as a simple mechanism for passing values between tasks. A reactive variable once assigned cannot be reassigned a new value. It is this property that makes them useful in declarative concurrency.
function: rvar()
syntax: ?
returns: an unbound reactive variable.
function: rbind(r, obj)
syntax: ?r = obj
returns: void
Binds the object `obj` to the reactive variable `r.
function: rget(r, @optional timeout, default)
syntax: ?r
returns: the object bound to the reactive variable `r`.
If `timeout` is not specified, waits till the reactive variable is bound by another task.
If `timeout` is specified and the variable is not bound within it runs-out, rget will return
the value of `default`. If there are no other tasks running this function will raise
a "Deadlock detected" error.
The `?r` syntax has the same semantics as `rget` with no `timeout` and `default` specified.
Example:
let x = ?;
!showln(?x * 100);
?x = 20;
//=> 2000
A reactive variable can be defined an initialized in a single shot as shown below:
let ?x = 20;
Read and write operations on the store (such as reading and writing a variable, an element of an array or a string) are not atomic. It is an error for a task to write a location in the store while some other task reads or writes that same location. It is the responsibility of the application to avoid write/read and write/write races through appropriate uses of the synchronization primitives.
Concurrent reads and writes to streams are allowed. It is the responsibility of the implementation to serialize accesses to a given stream using the appropriate synchronization primitives.
Slogan supports multi-core parallel programming with an API based on a simple message-passing model.
A function can be executed on a separate processor core by calling it within the process
or act
functions.
The main program interacts with the spawned function using message passing.
function: process(f, @optional timeout)
returns: an object that contain information about the newly started process.
Arranges the function `f` to be executed parallely. If `timeout` is specified,
an error is raised if the spawned process does not respond within `timeout`.
function: process_send(pinfo, obj, @optional timeout)
returns: the number of bytes sent to the process represented by `pinfo`.
Send the object `obj` to the process represented by `pinfo`. If `timeout` is specified,
raise an error if the object cannot be sent within that time.
function: process_receive(pinfo, @optional timeout, default)
returns: an object read from the process represented by `pinfo`.
A process can send and receive numbers, symbols, strings, pairs and arrays. More complex objects like functions should be explicitly serialized and de-serialized. The functions `object_to_u8array` and `u8array_to_object` may be used for this.
function: process_close(pinfo)
returns: true if the connection with the process is closed, false otherwise.
Closes the communication channel between the parent and child process. If called from parent,
the child process is terminated.
Example:
let p = process(^(cp) showln("server says: ", process_receive(cp)));
process_send(p, "hello");
//-> server says: hello
process_close(p);
//=> true
function: act(f, @optional timeout, default)
returns: a function that send messages to the new process.
Starts a new process and calls the function `f` in that process. This function is
called with the objects received from the parent process until it receives the symbol 'quit.
The return value of `act` is a function that the parent process can call to send messages
to the child process. Any value passed to this function, except the symbol 'info is send
to the child. For the argument 'info this function will return the process information object.
Passing the symbol 'quit will cause this function to terminate the child and close the
connection with it.
For all other arguments, the function returned by `act` behave as follows. After sending
the message, it will return a function that represent a "future" object. At a later point
in time, this "future" can be invoked to get back the reply from the child. This function
can be optionally passed two keyword arguments - `timeout` and `default` - to prevent the
parent from waiting indefinitely for a reply.
`timeout` is used by the parent and child processes to control the time they should wait for
message sends and receives.
`default` is used as the return value for process_receive calls that times-out.
// Example:
let p = act(^(message)
| 'hi -> 'hello
| ['add, a, b] -> a + b
| _ -> 'invalid);
let f = p('hi);
f();
//-> hello
p.hi();
//-> hello
f = p(['add, 10, 20]);
f();
//-> 30
f = p('hey);
f();
//-> invalid
p('quit); // or `p.quit`
//=> true
Note that the function returned by message passing abstracts a simple request-reply protocol.
The function must be invoked and the reply read before sending the next message. The function
should not be shared between tasks.
function: react(f, cb, @optional timeout, default)
returns: a function that send messages to the new process.
Starts a new process and calls the function `f` in that process. This function is
called with the objects received from the parent process until it receives the symbol 'quit.
The return value of `react` is a function that the parent process can call to send messages
to the child process. Any value passed to this function, except the symbol 'info is send
to the child. For the argument 'info this function will return the process information object.
Passing the symbol 'quit will cause this function to terminate the child and close the
connection with it.
For all other arguments, the function returned by `react` behave as follows. After sending
the message, it will arrange an independent task to receive back the response. The function
`cb` is called by this task with the response as argument.
`timeout` is used by the parent and child processes to control the time they should wait for
message sends and receives.
`default` is used as the return value for process_receive calls that times-out.
// Example:
let r = ?;
let p = react(^(message) | [x, y] -> x + y,
^(message) | result -> ?r = result);
p([10, 20]);
?r;
//=> 30
r = ?;
p([10, 200]);
?r;
//=> 210
p.quit;


CDR3 characteristics tab
This tab gives information on the different characteristics of the CDR3.
Graphs
length distribution of CDR3
Graph visualizing for each donor the distribution of the CDR3 length in amino acids between all sequences.
Amino acid composition of CDR3
Bar graph visualizing for each donor how frequent each amino acid is used in the CDR3 of all sequences. The red colour in the background indicate positively charged amino acids, and the blue colour in the background indicate negatively charged amino acids. The amino acids are ordered from hydrophilic (left) to hydrophobic (right).
Table
Table showing for each donor the median CDR3 length.


This page has been moved. If you are not redirected within 3 seconds, click here to go to the article


VICEMP3
Play and stop buttons
Play
Stop
Toggle button
Play | Stop
Restart button
Restart
Play after restart
Change volume
Volume to 1
Volume to 0.5
Volume to 0.1


{% for index, row in enumerate(secrets_table, start=1) %}
{{ index }}
{{ row[0] }}
{{ row[1] }}
{% end %}
{% end %}
General Informations
Your tasks is to complete the multiple challenges. You will find all challenges on the scoreboard. Once you complete a challenge, you’ll find a flag which can be submitted.
Rules
All challenges are under the ctf.hf domain.
Never attack a system under the rest of .hf TLD or any other domain
Modifying or disconnecting cable connections on network devices => Disqualification!


Broken Arrow A Film Review By Michael Redman Copyright 1996 By Michael Redman
**1/2 (out of ****)
John Travolta has come a long way since his "Saturday Night Fever" days. His latest films have shown a depth undreamed of during his disco period. (Of course, just about anything would be depth compared to disco.) The evil criminal genius character in this film isn't exactly a step forward.
He and Christian Slater are Air Force buddies but their relationship takes a turn for the worse when Travolta decides to kill his friend and steal nuclear weapons. His plan is to ransom the bombs for a zillion bucks and get back at the military for passing him over for promotion at the same time.
Slater survives, teams up with the film's babe factor, a park ranger, and sets out to stop the nefarious plot. From then on, it's a shoot-em-up with big guns.
In truth, Travolta isn't bad in his role, but the character, like the rest of the film, isn't believable. Supposedly he has the entire scheme plotted out and every possibility dealt with. For a genius, he doesn't do so well. Not one of his plans works.
Luckily for the future of the to-be-bombed Southwest, Slater falls into every possible piece of luck. Ejected from a stealth bomber into the Utah desert, he is rescued by the park ranger. In that same vast wasteland, he somehow locates Travolta with little trouble. Every time that he is left behind, he again locates his prey easily. Remarkably enough, armed with only a pistol, he defeats an army of bad guys and their big modern military stuff.
There are impressive bits: grand explosions, scenes from "Close Encounters", sound effects from "Star Wars", a truck chase from "Indiana Jones" and even music reminiscent of "Twin Peaks". Admirable pieces of a jigsaw puzzle that don't make a complete picture.
As mentioned in previous comments about "Sense And Sensibility", there are movies that are obviously aimed at one sex or the other. This is decidedly a guy film, just not a very good one.
[This appeared in the 2/15/96 "Bloomington Voice", Bloomington, Indiana. Michael Redman can be contacted at<EMAIL_ADDRESS>--<EMAIL_ADDRESS>This week's film review at http://www.bvoice.com/ Film reviews archive at http://us.imdb.com/M/reviews_by?Michael%20Redman
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{% extends "layout.html" %} {% block title %} The Quest | Account Recovery {% endblock %} {% block extCSS %} {% endblock %} {% block section %} Account recovery Please enter your email linked to your account : An one time password(otp) and a reset password link will be sent your linked email. I don't have an account {% endblock %}
An one time password(otp) and a reset password link will be sent your linked email.


class: center, middle # Generative Adversarial Networks by _Roozbeh Farhoodi_ **download tutorial:** [Github repository](https://github.com/KordingLab/lab_teaching_2016) [IPython notebook](https://github.com/KordingLab/lab_teaching_2016/blob/master/session_4/Generative%20Adversarial%20Networks.ipynb) --- ### Generative models “Generative modeling is a broad area of machine learning which deals with models of distributions `\(\mathbb{P}(X)\)`, defined over datapoints X in some potentially high-dimensional space `\(\Theta\)`." ### Motivations - New samples from a dataset: generating natural images, ... - completing the incomplete data .center[
] --- ### variational autoencoder (VAE) .center[
] [tutorial](https://arxiv.org/pdf/1606.05908v2.pdf) --- ### GAN [Goodfellow et al, 2014](https://arxiv.org/pdf/1406.2661v1.pdf) `\(D\)` and `\(G\)` play the following two-player minimax game with value function `\(V(G, D)\)`: `\(\min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{\text{data}}({x})}[\log D({x})] + \mathbb{E}_{{z} \sim p_{{z}}({z})}[\log (1 - D(G({z})))]\)` .center[
] --- ### GAN [Goodfellow et al, 2014](https://arxiv.org/pdf/1406.2661v1.pdf) `\(D\)` and `\(G\)` play the following two-player minimax game with value function `\(V(G, D)\)`: `\(\min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{\text{data}}({x})}[\log D({x})] + \mathbb{E}_{{z} \sim p_{{z}}({z})}[\log (1 - D(G({z})))]\)` .center[
] --- ### Example .left[
] .left[
] --- .center[**Generative and Discriminative**] .center[
] --- ## Variations .left[
] - dcGAN - InfoGAN - AC-GAN - EB-GAN - LAPGAN... --- ## DC-GAN [**Alec Radford and Luke Metz et al, 2016**](https://arxiv.org/pdf/1511.06434.pdf) .center[
] "We propose and evaluate a set of constraints on the architectural topology of Convolutional GANs that make them stable to train in most settings. We name this class of architectures Deep Convolutional GANs (DCGAN)" --- ## DC-GAN Architecture guidelines for stable Deep Convolutional GANs - Replace any pooling layers with strided convolutions (discriminator) and fractional-strided convolutions (generator). - Use batchnorm in both the generator and the discriminator. - Remove fully connected hidden layers for deeper architectures. - Use ReLU activation in generator for all layers except for the output, which uses Tanh. - Use LeakyReLU activation in the discriminator for all layers. --- ## Info-GAN [**Xi Chen et al, 2016**](https://arxiv.org/pdf/1606.03657v1.pdf) "The GAN formulation uses a simple factored continuous input noise vector z, while imposing no restrictions on the manner in which the generator may use this noise. As a result, it is possible that the noise will be used by the generator in a highly entangled way, causing the individual dimensions of z to not correspond to semantic features of the data." --- ## Info-GAN Solution: Introducing the latent variable `c` and modifying: .center[
] the second term can be approximated by: .center[
] Which can be approximated again by Monte Carlo simulations. .center[
] --- ## Info-GAN .center[
] --- ## LAPGAN [**Emily Denton et al, 2015**](https://arxiv.org/pdf/1506.05751.pdf) "Our approach uses a cascade of convolutional networks within a Laplacian pyramid framework to generate images in a coarse-to-fine fashion." --- ## LAPGAN .center[
] --- ## LAPGAN .center[
] --- ## AC-GAN [**Augustus Odena et al, 2016**](https://arxiv.org/pdf/1610.09585v1.pdf) "GANs struggle to generate globally coherent, high resolution samples - particularly from datasets with high variability." .center[
] --- ## AC-GAN .center[
] --- ## EBGAN [**Junbo Zhao et al, 2016**](https://arxiv.org/pdf/1609.03126v2.pdf) "We introduce the “Energy-based Generative Adversarial Network” model (EBGAN) which views the discriminator as an energy function that associates low energies with the regions near the data manifold and higher energies with other regions." --- ## EBGAN .center[
] --- ## CGAN [**Jon Gauthier**](http://www.foldl.me/uploads/2015/conditional-gans-face-generation/paper.pdf) "Our approach uses a cascade of convolutional networks within a Laplacian pyramid framework to generate images in a coarse-to-fine fashion." --- ### Remedies - **Freezing learning:** Frequently either the generator or discriminator will outpace the other and the GAN will get stuck in a degenerate solution. One simple remedy is to freeze learning in one model when it begins to get too strong. [See here](https://arxiv.org/pdf/1610.01945.pdf?utm_content=buffer13ebb&utm_medium=social&utm_source=facebook.com&utm_campaign=buffer) - **Label smoothing:** A simple trick to prevent gradients from vanishing when the discriminator’s predictions are very confident, label smoothing replaces `\(0 : 1\)` labels with `\(\epsilon : 1 - \epsilon\)`, which guarantees the generator will always have informative gradients. - **Minibatch discrimination:** To prevent the generator from collapsing onto a single sample, minibatch discrimination extends the role of the discriminator from classifying single images to classifying entire minibatches.[See here](https://arxiv.org/abs/1606.03498) --- ### Remedies - **Batch normalization:** Batch normalization has been critical for scaling GANs to deep convolutional networks, and virtual batch normalization has extended this by using a constant reference batch to prevent correlations in predictions due to the other elements of the minibatch.[see here](https://arxiv.org/pdf/1502.03167v3.pdf) .center[
] --- ### tutorial's talk .center[
] --- ### let's start painting! .center[
] --- class: center, middle # Questions and Discussion


Fishing Guild Member:
Which area's monsters in Aden Territory would you like to see?
War-Torn Plains
The Giant's Cave
The Forest of Mirrors
Tower of Insolence


What my take away from this is that the entire web works on some form of HTML. HTML is one of the languages that computers use to communicate with each other. The result is a webpage.
HTMLHTML stands for Hypertext Markup Language. HTML documents form the majority of the content on the web. HTML documents contain text content which describes "what you see" and markup which describes "how it looks". This video gives a good overview. (COURTESY ANDY'S NOTES)
Tags and ElementsElements help format the text appearing on a page. For example, Bolding can be done by the element <'b'>. Elements can also be used for page breaks. There are many elements in HTML.
Inline vs Block ElementsI personally prefer block to INLINE. Block helps format the paragraphs neatly while the inline seems more free form.


How elements and components stack with eachother.
V2, V5, current (universal)
Homepage, Campaign Page
Uses Twitter Bootstrap (less for css preprocessing)
About Page
Uses a newer version of Twitter Bootstrap (sass for css preprocessing)
Dashboard, Stores, Jobs Page
Roll our own, using sass
Documented on our front end Github wiki.
What is B.E.M.?
BLOCK
ELEMENT
MODIFIER
Speaking of nesting, a good rule of thumb is to never go 4 levels deep.
A list of colors
.color_picker
.color_picker {
list-style: none;
}
Each color, a list item
2 underscores
.color_picker__list_item
.color_picker__list_item {
display: inline-block;
}
An action applied
2 dashes
.color_picker__list_item--active
.color_picker__list_item--active {
border: 1px solid blue;
}
Currently incomplete, and always evolving
Having the PSDs/design tools and files really help.
You can see the grid, font sizes and weights, and implement the intended work that our design team has carefully crafted.


DWeb Shanghai is a branch of the global DWeb. The goal is to bring together local developers, designers, travelers, musicians, mathematicians, or any like-minded people who have their thinking about the existing Internet and work together towards a better Internet.
Now the Internet is no longer a free and open place. More and more services are monopolized by giants. We no longer have our privacy. As our relationship with the Internet becomes closer and closer, we also gradually lose almost all our rights. To this end, we ，together with DWeb in various countries and cities around the world, want to put forward our ideas to change this situation, and strive to achieve. What decentralization brings to us is secure. The distributed storage of data on servers around the world can help us effectively prevent Internet giants from controlling us. A new decentralized network will give users unprecedented Rights and tools to protect your privacy data from being violated.
Our mission is to listen to everyone’s voices, and use our technology to help realize your ideas and suggestions for the existing Internet, and pass such voices to more people to build the real Internet in our minds.
Activity details
At 14:00 on September 28, 2019, we will hold our first DWeb Shanghai party on the 2nd floor of Building B, Changyang Chuanggu (No. 1687 Changyang Road, Yangpu District, Shanghai)! In this first gathering, we warmly welcome everyone from different backgrounds to participate and share their views and opinions on the current Internet, and discuss how to improve and maintain the new Internet.
Organizer
DWeb Shanghai
SHLUG
Dimension
(dimension.im)
Activity process
Part 1
Sharer:
Yisi Liu （Dimension.im CTO ）
Topic:
The relationship between Yisi liu and Dweb and why he wanted to set up DWeb Shanghai in Shanghai.
Part 2
Sharer:
Wendy Hanamura
（https://twitter.com/whanamura）
Joachim Lohkamp
（https://twitter.com/jockellohkamp）
Wendy Hanamura is from the Internet Archive and Joachim Lohkamp is from Jolocom. Both of them are the sponsors of the DWeb community. For this event, they will share their stories with DWeb Shanghai via video.
Part 3
Lightning Talk
Participants from different fields will share their indissoluble bond with distributed networks.
Part 4
Brainstorming
What do you think about the privacy issues that are happening now? What should we do to solve these problems?
Part 5
Brainstorming
How to conduct DWeb Shanghai’s offline activities in the future, and explore potential projects that DWeb Shanghai can carry out.
Let’s meet and discuss our ideal Internet!
See you all on Saturday!
Event Page: https://www.meetup.com/dweb-shanghai/members/?sort=join_date&desc=true
Github https://github.com/DimensionDev
Twitter https://twitter.com/realMaskNetwork
Facebook https://www.facebook.com/masknetwork
Discord https://discord.com/invite/cKGW45g
Telegram (English) https://t.me/maskbook_group
Telegram （中文） https://t.me/masknetwork_cn


--- layout: post title: "Astronomers were wrong about the number of galaxies in universe" subtitle: "New NASA mission estimates the number of galaxies to be half of what had previously been estimated for years" date: 2021-01-15 15:31:13 +0530 background: '/assets/images/space.jpg' published: true categories: [ Science ] tags: [ science, scientist, nasa, galaxies, universe, mission, spacecraft, solar system] ---
Can astronomers be so wrong about the number of galaxies in the universe? What if the universe is a little darker than expected, counting way less galaxy than previously estimated for years?
It seems so, according to new data harvested by NASA's New Horizon spacecraft. Leaving the illuminated inner solar system is the best way to determine just how many galaxies may exist in the unseen distance – which is exactly what New Horizons did.
Indeed, a previous measurement by the Hubble Space Telescope suggested there were 2 trillion galaxies spread across the universe. But the latest discovery counts only hundreds of billions of galaxies instead.
The new NASA mission estimated the number of galaxies to be half of what had previously been estimated for years, in a new study published in The Astrophysical Journal and presented Wednesday at the 237th meeting of the American Astronomical Society, this one virtual.
NASA's New Horizons mission flew by Pluto, located four billion miles from Earth on the edge of our solar system, in both 2015 and 2019. It looked across the vastness of black space, the study said, as the spacecraft was at such a distance that the sky it surveyed was 10 times darker than the darkest sky observed by Hubble.


Importing data into ISA formats¶
We have provided a number of modules that allow you to import data into
ISA formats from well-known databases or services. Imports from these
services is supported by modules found in the isatools.net
package:
Obtaining Functional Genomics Data¶
Importing from the European Nucleotide Archive to ISA-Tab¶
Notice: this method depends on SAXON XSLT Processor
To import an SRA study from the European Nucleotide Archive (ENA) as ISA-Tab files, provide an ENA accession number and your path to the SAXON JAR file:
from isatools.net import sra2isatab
sra2isatab.sra_to_isatab_batch_convert('BN000001', 'your/path/to/saxon9.jar')
This method returns the ISA-Tab files as a byte stream (io.BytesIO
).
Importing MAGE-TAB to ISA¶
To import metadata from MAGE-TAB files (e.g. from EBI ArrayExpress database), you can do the following to import a MAGE-TAB to ISA-Tab:
from isatools.convert import magetab2isatab
with open('your/path/to/magetab.idf.txt', 'r') as input_magetab:
magetab2isatab.convert(input_sampletab, 'tmp/')
To import a MAGE-TAB to ISA JSON, you can do:
from isatools.convert import sampletab2json
with open('your/path/to/magetab.idf.txt', 'r') as input_sampletab:
with open('your/path/to/myjson.json', 'w') as output_json:
magetab2json.convert(input_magetab, output_json)
Obtaining Metabolomics Data¶
Importing from EMBL-EBI MetaboLights to ISA¶
To import an MetaboLights study from the MetaboLights as ISA-Tab files, provide an MetaboLights accession number:
from isatools.net import mtbls as MTBLS
tmp_dir = MTBLS.get('MTBLS1')
This method downloads the ISA-Tab files for a study, and returns a string path to a temporary directory containing the ISA-Tab files.
To import an MetaboLights study from the MetaboLights as ISA JSON files, provide an MetaboLights accession number:
from isatools.net import mtbls as MTBLS
isa_json = MTBLS.getj('MTBLS1')
This method gets the study and returns the ISA content as ISA JSON.
You can also do simple queries on MetaboLights studies to retrieve samples and related data files, based on factor selection:
from isatools.net import mtbls as MTBLS
MTBLS.get_factor_names('MTBLS1')
# response:
# {'Gender', 'Age'}
MTBLS.get_factor_values('MTBLS1', 'Gender')
# response:
# {'Male', 'Female'}
query = {
"Gender": "Male"
}
samples_and_files = MTBLS.get_data_files('MTBLS1', factor_query=query)
# response:
# [
# {
# 'sample': 'ADG10003u_007'},
# 'data_files': ['ADG10003u_007.zip'],
# 'query_used': {'Gender': 'Male'}
# }, ...
# ]
Importing from MetabolomicsWorkbench, to ISA-Tab¶
To import a study from the Metabolomics Workbench as ISA-Tab files, provide an accession number and your local path to write your files to:
from isatools.net.mw2isa import mw2isa_convert
success, study_id, validate = mw2isa_convert(studyid="ST000367", outputdir='tmp/', dl_option="no", validate_option="yes")
# If success == True, download and conversion ran OK. If validate == True, the ISA-Tabs generated passed validation
See isa-api/isatools/convert/mw2isa.py
Importing from Biocrates, to ISA-Tab¶
Notice: this method depends on SAXON XSLT Processor
See isa-api/isatools/net/biocrates2isatab.py
Importing from third-party formats is supported with our conversion
modules found in the isatools.convert
package:
Importing mzML to ISA-Tab¶
To import metadata from mzML mass spectrometry files, the ISA API
integrates with the mzml2isa
tool from
https://github.com/ISA-tools/mzml2isa and can be run as follows:
from isatools.convert import mzml2isa
mzml2isa.convert('your/path/to/mzml/files/', 'tmp/', "My Study ID")
Importing SampleTab to ISA¶
Warning
As of July 2020, EBI Biosample has decommissioned SampleTab format and now only accepts submission via a REST API. Future releases of the ISA-API will support this mode of data deposition.
To import metadata from SampleTab files (e.g. from EBI BioSamples database), you can do the following to import a SampleTab to ISA-Tab:
from isatools.convert import sampletab2isatab
with open('your/path/to/sampletab.txt', 'r') as input_sampletab:
sampletab2isatab.convert(input_sampletab, 'tmp/')
To import a SampleTab to ISA JSON, you can do:
from isatools.convert import sampletab2json
with open('your/path/to/sampletab.txt', 'r') as input_sampletab:
with open('your/path/to/myjson.json', 'w') as output_json:
sampletab2json.convert(input_sampletab, output_json)
You can also load SampleTab content directly into ISA Python objects:
from isatools import sampletab
with open('your/path/to/sampletab.txt', 'r') as input_sampletab:
ISA = sampletab.load(input_sampletab)


The mounting plate for most of the electronics was designed in OpenSCAD. A grid of 8x11 LED's was placed on a MDF board, with a cutout for the e-ink display cut into the center. Holes were cut into the MDF that allowed the LED mounting wires to be passed through to the LED boards.
To separate the LED's, 5 mm black foam board was used to create a grid.


Bacon ipsum dolor amet andouille shankle meatball, shoulder leberkas meatloaf ribeye beef ribs jowl pastrami biltong fatback short loin tri-tip. Picanha corned beef pancetta salami shank pork chop. Meatloaf turkey sausage short loin beef sirloin.
Bacon ipsum dolor amet andouille shankle meatball, shoulder leberkas meatloaf ribeye beef ribs jowl pastrami biltong fatback short loin tri-tip. Picanha corned beef pancetta salami shank pork chop. Meatloaf turkey sausage short loin beef sirloin.
Bacon ipsum dolor amet andouille shankle meatball, shoulder leberkas meatloaf ribeye beef ribs jowl pastrami biltong fatback short loin tri-tip. Picanha corned beef pancetta salami shank pork chop. Meatloaf turkey sausage short loin beef sirloin.
Bacon ipsum dolor amet andouille shankle meatball, shoulder leberkas meatloaf ribeye beef ribs jowl pastrami biltong fatback short loin tri-tip. Picanha corned beef pancetta salami shank pork chop. Meatloaf turkey sausage short loin beef sirloin.
Designer & Engineer
Engineer & Builder
Architect & Engineer
Venison meatball bresaola filet mignon bacon burgdoggen.
Read MoreTurducken shank turkey, ribeye hamburger drumstick brisket boudin pastrami leberkas tenderloin pork chop fatback. Pork belly pastrami tongue landjaeger, swine brisket doner sirloin.
Read MoreBeef jerky tail, meatloaf turkey short loin doner brisket landjaeger ball tip pig jowl alcatra pastrami short ribs. Chicken doner shoulder, drumstick landjaeger bacon meatloaf.
Read More


piDashboard
Angular dashboard for sensor data. [github]
piDashboard is based on rDash Dashboard . The site is an angular-based dashboard for data provided by a Raspberry Pi. (see RaspberryPi for code for running sensors).
Currently the site has two functions-ish:
- Display a carousel of timelapse images captured by a raspberry pi.
- Show a graph of temp/humidity recorded by a raspberry pi
A crude live version of the site was being served by nginx running on a raspberry pi (the same pi as provides the data), but this was too much of a drain on resources (in the event someone visited).
Issues
- A Carousel isn’t a good way to show timelapse images (many of which are pitch-dark…), but the raspberry pi is too constrained to do video-processing
- The humidity graph shows all data-points (it has no ability to date-filter for recency).


About Me
Hello! My name is Eric. I graduated with a degree in business from
Cincinnati State Technical and Community College in Cincinnati, Ohio.
Currently, I am working as a Director of Operations where I strategically safeguard
and augment the efficiency of the company’s operations to facilitate the accelerating
development and the long-term success of the business.
I have enrolled in the Coding Bootcamp at the Ohio State University to learn new
tools and skills. Please feel free to browse my portfolio.


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
| Interface Summary | |
|---|---|
| Instrument |
| Class Summary | |
|---|---|
| AccountActivity | |
| AccountBalance | |
| Address | |
| Amount | |
| DebtBalance | |
| DescriptorPolicy | |
| FlexiblePaymentsService | This class provides an interface with the Amazon FPS service. |
| FPSError | |
| MultiUseInstrument | |
| OutstandingPrepaidLiability | |
| PaymentInstructionDetail | |
| PostPaidInstrument | |
| PrepaidBalance | |
| PrepaidInstrument | |
| RecipientInstrument | |
| RecurringInstrument | |
| SingleUseInstrument | |
| TemporaryDeclinePolicy | |
| Token | |
| TokenUsageLimit | |
| Transaction | |
| TransactionDetail | |
| TransactionResult | |
| UsageLimit |
| Exception Summary | |
|---|---|
| FPSException | |
| InvalidSignatureException |
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Algorithms are fundamental to any modern technology. Often one needs to choose one out of many available correct algorithms. The choice usually depends on the amount of resources used by an algorithm. So there arises a need of mathematically quantifying the amount of resources required by an algorithm as a function of the size (or occasionally the value) of the input. Since there does not exists an entity similar to a standard computer to which all measurements of computing time may refer to. So we content ourselves by expressing the time taken (one of the above mentioned 'resources') to within a mutliplicative constant.
Under the RAM Model of Computation we assume some basic operations like addition, subtraction, multiplication, division, reading and writing a certain location in memory requires a unit amount of time of computation. And then we study asymptotically the number of such operations required by an algorithm depeding on the input size. As number of such operations is always non-negative (\(\geq 0\)), we restrict our study only to non-negative numbers.
Some Definitions:
- The asymptotic upper bound - \(\mathcal{O}\)-notation
For a given function \(g(n)\), we denote by \(\mathcal{O}(g(n))\) (pronounced as "big-oh of \(g\) of \(n\)") as a set of all those functions that are asymptotically less than or equal to \(g(n)\). $$ \mathcal{O}(g(n))=\{f(n):\textit{there exist positive constants, } c \textit{ and } n_{0} \textit{ such that } 0\leq f(n) \leq cg(n) \textit{ for all } n \geq n_{0}\}.$$ - The asymptotic lower bound - \(\Omega\)-notation
For a given function \(g(n)\), we denote by \(\Omega(g(n))\) (pronounced as "big-omega of \(g\) of \(n\)") as a set of all those functions that are asymptotically greater than or equal to \(g(n)\). $$ \Omega(g(n))=\{f(n):\textit{there exist positive constants, } c \textit{ and } n_{0} \textit{ such that } 0\leq cg(n) \leq f(n) \textit{ for all } n \geq n_{0}\}.$$ - The asymptotic equivalence - \(\Theta\)-notation
For a given function \(g(n)\), we denote by \(\Theta(n)\) (pronounced as "big-theta of \(g\) of \(n\)") as a set of all those functions that are asymptotically equal to \(g(n)\). $$ \Theta(g(n))=\{f(n):\textit{there exist positive constants, } c_1,c_2 \textit{ and } n_{0} \textit{ such that } 0\leq c_{1}g(n) \leq f(n) \leq c_{2}g(n) \textit{ for all } n \geq n_{0}\}.$$


| Item Name |
Description |
| Apple Iphone XS Max |
- True Tone display
- Wide color display (P3)
- 3D Touch
- 624 cd/m2 max brightness (typical)
- Fingerprint-resistant oleophobic coating
- Support for display of multiple languages and characters simultaneously
|
| Apple Iphone XS Max |
- True Tone display
- Wide color display (P3)
- 3D Touch
- 624 cd/m2 max brightness (typical)
- Fingerprint-resistant oleophobic coating
- Support for display of multiple languages and characters simultaneously
|
| Apple Iphone 8S Plus |
- True Tone display
- Wide color display(P3)
- 3D Touch
- 624 cd/m2 max brightness (typical)
- Fingerprint-resistant oleophobic coating
- Support for display of multiple languages and characters simultaneously
|


Dear {{ user.username }},
{{stock.volume}} units of {{ stock.name}} at $ {{ stock.price}} per unit that you listed have been successfully bought by {{ buyer.username }} .
Transaction ID: {{ transaction_id }}
Sincerely,
The InvestFly Team


This collection of numerical data should be a useful reference for level designers asking themselves questions like:
·will the player be able to climb this stairs smoothly ?
·will the player be able to jump this ?
·will the player die from this fall ?
·will the player pass through this gap ?
·etc.
MAXIMUM WALKABLE HEIGHT : 3.50
Note
·Don't forget that any height can be made walkable by setting Wall Flag 3 bit 1.
MAXIMUM JUMPABLE HEIGHT : 9.65
Notes
·It doesn't matter if you're running or not
·It doesn't matter if you're crouching or not
·Don't forget that any height can be made walkable by setting Wall Flag 3 bit 1.
DAMAGE FROM FALLING :
| HEIGHT | MIN | MAX | MEAN | Notes |
| 36 | 0 | 0 | 0 | (1) |
| 37 | 0 | 1 | 0 | (2) |
| 40 | 4 | 9 | 6 | |
| 45 | 19 | 23 | 21 | |
| 50 | 31 | 35 | 33 | |
| 55 | 43 | 48 | 44 | |
| 60 | 54 | 58 | 56 | |
| 65 | 67 | 71 | 69 | |
| 70 | 77 | 78 | 77 | |
| 75 | 87 | 91 | 89 | |
| 79 | 93 | 98 | 95 | (3) |
| 80 | 95 | ++ | 98 | (4) |
| 81 | 98 | ++ | ++ | (5) |
| 82 | ++ | ++ | ++ | (6) |
Notes
(1) Maximum "no damage" fall
(2) 1 point of damage happened twice in 30 falls.
(3) Maximum "no death" fall
(4) % death :3/11 = 27%
(5) % death :12/19 = 63%
(6) Minimum "sure kill"
·Shields or Supershield are of no help
·LAIMLAME totally protects you (at least up to 3000).
·Crouching doesn't affect the damage taken.
·Jumping up before the fall does of course add to it.
·Sprinting when hitting the ground doesn't change anything.
·The current health doesn't affect damage.
Effects of second altitude:
1) A positive second altitude (water) must be added to the height of the fall.
I.e. the water doesn't break the fall at all, it increases the damage :-)
2) A negative second altitude (platform) must be subtracted from the height of the fall.
3) In both cases the results are consistent with the equivalent fall from the sum or difference of heights.
[All falls tested between 10 and 30 times.]
MINIMUM WALKABLE WIDTH : 4.90
Notes
·This is a width between two angles of columns in a room.
Passing between those two isn't exactly the same as walking in a 4.9 wide corridor !
·When running you may sometimes pass through a gap as little as 4.6
I strongly believe this is a problem in the engine collision detection.
MINIMUM WALKABLE HEIGHT : 6.80
Note
The generally adopted rule of thumb of 1 DF unit = 1 foot would make Kyle very big (207 cm).
I believe we should use 1DF unit = 25 cm instead.
MINIMUM CROUCH HEIGHT : 3.00
LONGJUMPS
| Standing | ~14 |
| Walking | ~20 |
| Running | ~40 |
Notes
·These values assume that the start and end altitudes of the jump are the same.
·DF levels must be set on low gravity worlds :-)


I am Chongzhou Fang, a PhD candidate at University of California, Davis. My research interest lies in heterogeneous cloud and edge security. I focus on both scheduler security and side-channel attack and defense in heterogeneous computing resources like FPGAs.
Previously I obtained my bachelor's degree at Southeast University (SEU), China.
Update 06/22/2023


<EMAIL_ADDRESS>Download from here and install
$ apt-get install git-all
$ yum install git-all
$ xcode-select --install
$ git config --local user.name "John Doe"
$ git config --local user.email<EMAIL_ADDRESS>$ git help # shows help
$ git clone # clones a central repository into a local one
$ git status # shows the current status for changed/new/removed files`
$ git add # stages file(s) for commit
$ git commit
$ git push # publishes the changes(commits) to the central repository
$ git pull # fetches changes from central repository
$ git branch # shows a list of existing branches
$ git log # shows history
$ git merge # merges 2 branches together
$ git stash # stacks unfinished changes
# get the existing project
$ git checkout https://github.com/iionut/git-presentation.git
# create workdir
$ mkdir demo
# create a new file
$ touch demo/file.php
# change demo/file.php content
$ git status
On branch master
Your branch is up-to-date with 'origin/master'.
(use "git push" to publish your local commits)
Changes not staged for commit:
modified: index.html
Untracked files:
(use "git add <file>..."
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: demo/file.php
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: index.html
no changes added to commit (use "git add" and/or "git commit -a")
$ git commit -m "Demo - Created new PHP script"
[master db0d959] Demo - Created new PHP file
1 file changed, 3 insertions(+)
create mode 100644 demo/file.php
$ git status
On branch master
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: index.html
no changes added to commit (use "git add" and/or "git commit -a")
$ git push origin master
Password for<EMAIL_ADDRESS>Counting objects: 4, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (4/4), 351 bytes | 0 bytes/s, done.
Total 4 (delta 1), reused 0 (delta 0)
To https://github.com/iionut/git-presentation.git
8fba580..db0d959 master -> master
$ git branch # list local branches
* master
$ git branch testing # create branch with name: "testing"
$ git branch # list local branches
* master
testing
$ git checkout testing
Switched to branch 'testing'
$ vim demo/test.php
$ git commit -a -m "unit test setup"
$ git log --oneline --decorate --graph --all
* c34bc51 (HEAD -> testing) unit test setup
* db0d959 Demo - Created new PHP file
$ git checkout master
$ git log --oneline --decorate --graph --all
* c34bc51 (testing) unit test setup
* db0d959 (HEAD -> master, origin/master, origin/HEAD) Demo - Created new PHP file)
$ git merge testing
Updating 0fb644f..c34bc51
Fast-forward
demo/test.php | 3 +++
1 file changed, 3 insertions(+)
create mode 100644 demo/test.php
$ git checkout experiment
$ git rebase master
First, rewinding head to replay your work on top of it...


We will make every effort to accommodate your busy schedule. Contact us today for priority scheduling!!
Newsletter 1 Download PDF
Newsletter 2Download PDF
Patient Form 1 Download PDF
Patient Form 2 Download PDF


pysimm.amber module¶
-
pysimm.amber.
calc_charges
(s, charge_method='bcc', cleanup=True)[source]¶ Calculates charges using antechamber. Defaults to am1-bcc charges.
Parameters: - s – System for which to calculate charges. System object is updated in place
- charge_method – name of charge derivation method to use (default: bcc)
- cleanup – removes temporary files created by antechamber (default: True)
Returns: None
-
pysimm.amber.
cleanup_antechamber
()[source]¶ Removes temporary files created by antechamber and pysimm.
Parameters: None – Returns: None
-
pysimm.amber.
get_forcefield_types
(s, types='gaff', f=None)[source]¶ Uses antechamber to determine atom types. Defaults to GAFF atom types. Retrieves
ParticleType
objects from force field is providedParameters: - s –
System
for which to type - types – name of atom types to use (default: gaff)
- f – forcefield object to retrieve
ParticleType
objects from if not present in s (default: None)
Returns: None
- s –


You will be shown a chart, and asked to answer questions about it. The questions may change for each chart. Click the Confirm button to move on.


Homemade Bed Set
In 2018, I was determined to make my own bed frame for my tiny 7x10 sq ft room in Boston. The bed had in-set legs, slats, storage boxes on wheels, and a bench. The cuts were calculated so they could get cut at the hardware store (I didn't have power tools at the time). Joinery was simple using screws. Constructed using cedar and birch wood, and used mineral oil for finish. Took around 5 hours to design and plan, and a weekend to complete. Cost: $150.
Disciplines
Year


Switching from version 2.x.x to 3.x.x
The 3.0.0
release brought multiple breaking changes that may impact your
codebase if you were based on a 2.x.x
version (or inferior) previously.
Those breaking changes are mainly here to bring new features and simplify the player maintenance. This file enumerates each one of those changes and propose alternatives.
The simplest way of switching here would be to:
- Check the General changes chapter
- Check the constructor options you use (constructor options chapter)
- Check the way you use the
loadVideo
method (loadVideo chapter) - Replace every method listed in the Removed methods chapter you use in your codebase
- Make sure that the methods listed in the Changed methods chapter are correctly used now
- Replace events listed in Removed events
- Check events you use listed in Changed events
If you were only using documented APIs and you follow this, you’ll be ready to
completely switch to a 3.x.x
release !
If you don’t know if you were using documented APIs, you can still check if the
options, methods and events you use now are documented in the new
API. Now, most non-documented (private) APIs begin by the
string _priv_
, to simplify this process.
General Changes
Features disabled by default
What Changed
Two features, previously activated by default, are now disabled by default.
Those features are:
- The automatic limitation of the video track to filter those with a width superior to the current video element’s width.
- The automatic throttle on the audio and video bitrates set when the page is hidden for more than one minute.
If you want to activate the feature 1, you have to set the limitVideoWidth
boolean to true
in the constructor’s option. For the feature 2, it is the
throttleWhenHidden
constructor’s option you will have to set to true
.
If you had set them to false
to disable them before, you can now safely
remove those options from the constructor argument.
If you don’t know what to do with them, you might want to disable both features (by not setting them on the constructor). They only are optimizations for specific usecases.
Examples
// In the previous version
player = new RxPlayer();
// becomes
player = new RxPlayer({
limitVideoWidth: true,
throttleWhenHidden: true
});
// In the previous version
player = new RxPlayer({
limitVideoWidth: false,
throttleWhenHidden: false
});
// becomes
player = new RxPlayer();
Normalized language codes
What Changed
Previously, every language set in the manifest went through a translation step to be translated into an ISO 639-2 language code.
This led the following APIs:
getAvailableAudioTracks
getAvailableTextTracks
getAudioTrack
getTextTrack
getManifest
getCurrentAdaptations
To not reflect exactly the language as set in the manifest (just one of the ISO
639-2 translation of it). For example, "fra"
was translated to "fre"
(even though both are valid ISO 639-2 language codes for the same language).
Because this behavior hide the true language value and ISO 639-2 language codes have synonyms, we decided to:
- switch to ISO 639-3 language codes instead. This standard has more languages and does not have synonyms.
- keep both the information of what is set in the manifest and the result of our ISO 639-3 translation in two different properties
Now, the tracks returned by:
getAvailableAudioTracks
getAvailableTextTracks
getAudioTrack
getTextTrack
Will:
- keep the
language
property, though this time it is the exact same one than set in the manifest - will also have a
normalized
property, which is the ISO 639-3 translation attempt. If the translation attempt fails (no corresponding ISO 639-3 language code is found),normalized
will equal the value oflanguage
.
Likewise for the adaptations with a language set returned by:
getManifest
getCurrentAdaptations
They will have both a language
and a normalizedLanguage
property, which
follow the same rule.
Difference between the previous and new language codes used
In most cases, if you were manually checking language codes in your codebase you
could just replace here the key language
with its normalized counterpart
(either normalized
or normalizedLanguage
depending on the API you’re
using, see previous chapter).
However, while switching from ISO 639-2 to ISO 639-3, some language codes have changed (all were synonyms in ISO 639-2):
"alb"
became"sqi"
(for Albanian)"arm"
became"hye"
(for Armenian)"baq"
became"eus"
(for Basque)"bur"
became"mya"
(for Burmese)"chi"
became"zho"
(for Chinese)"dut"
became"nld"
(for Dutch, Flemish)"fre"
became"fra"
(for French)"geo"
became"kat"
(for Georgian)"ice"
became"isl"
(for Icelandic)"mac"
became"mkd"
(for Macedonian)"mao"
became"mri"
(for Maori)"may"
became"msa"
(for Malay)
Example
console.log(player.getAvailableAudioTrack());
// For a manifest with two audiotracks: "fr" and "en" without audio description
// -- in the old version --:
const oldVersionResult = [
{
language: "fre", // translated from "fr"
audioDescription: false,
id: "audio_1"
},
{
language: "eng", // translated from "en"
audioDescription: false,
id: "audio_2"
}
];
// -- became --:
const result = [
{
language: "fr", // stays the same than in the manifest
normalized: "fra", // translated from "fr"
// (notice that it's not "fre" like before)
audioDescription: false,
id: "audio_1"
},
{
language: "en", // stays the same than in the manifest
normalized: "eng", // translated from "en"
audioDescription: false,
id: "audio_2"
}
];
Constructor options
defaultLanguage
What changed
This option has been removed from the constructor to simplify the API. Now you
have to set the wanted transport per-loadVideo
calls via its
defaultAudioTrack
option.
Examples
Without audio description:
// In the previous version
player = new RxPlayer({
defaultLanguage: "en"
});
// becomes
player = new RxPlayer();
player.loadVideo({
defaultAudioTrack: {
language: "en"
},
// ...
});
With audio description:
player = new RxPlayer();
player.loadVideo({
defaultAudioTrack: {
language: "en",
audioDescription: true
},
// ...
});
defaultSubtitle
What changed
This option has been removed from the constructor to simplify the API. Now you
have to set the wanted transport per-loadVideo
calls via its
defaultTextTrack
option.
Examples
Without closed caption:
// In the previous version
player = new RxPlayer({
defaultSubtitle: "en"
});
// becomes
player = new RxPlayer();
player.loadVideo({
defaultTextTrack: {
language: "en"
},
// ...
});
With closed caption:
player = new RxPlayer();
player.loadVideo({
defaultTextTrack: {
language: "en",
closedCaption: true
},
// ...
});
initVideoBitrate / initAudioBitrate
What changed
Those options just changed their name:
initVideoBitrate
becomesinitialVideoBitrate
initAudioBitrate
becomesinitialAudioBitrate
This is to mainly to add clarity to the API.
Examples
// In the previous version
player = new RxPlayer({
initVideoBitrate: 1e6,
initAudioBitrateBitrate: 2e4
});
// becomes
player = new RxPlayer({
initialVideoBitrate: 1e6,
initialAudioBitrateBitrate: 2e4
});
defaultAudioTrack
What changed
This option has been removed from the constructor to simplify the API. Now you
have to set the wanted transport per-loadVideo
calls via its
defaultAudioTrack
option, which has the exact same format.
defaultTextTrack
What changed
This option has been removed from the constructor to simplify the API. Now you
have to set the wanted transport per-loadVideo
calls via its
defaultTextTrack
option, which has the exact same format.
transport
What changed
This option has been removed from the constructor to simplify the API. Now you
have to set the wanted transport per-loadVideo
calls via its transport
option, which has the exact same format.
transportOptions
What changed
This option has been removed from the constructor to simplify the API. Now you
have to set the wanted transport options per-loadVideo
calls via its
transportOptions
option, which has the exact same format.
loadVideo
loadVideo
is the central method of the RxPlayer and changed enough to earn
its own chapter.
Both parameters and the return value changed.
Return value
What changed
loadVideo
does not return anything anymore.
Replacement examples
If you want to know when the player is on error, you will have to listen to the
error
events:
player.addEventListener("error", (error) => {
console.log("content on error");
});
If you want to know when the content is loaded, you will have to listen to when
the playerStateChange
events:
player.addEventListener("playerStateChange", (state) => {
switch (state) {
case "LOADING":
console.log("the content is loading");
break;
case "LOADED":
console.log("the content has loaded");
break;
case "PLAYING":
console.log("the content is now playing");
break;
}
});
Bear in mind however that both are triggered when ANY content you choosed to play are loaded/on error, not just the last one.
defaultLanguage parameter
What changed
defaultLanguage
is replaced by the defaultAudioTrack
option, which
supports audio description.
Replacement example
Without audio description:
// In the previous version
player.loadVideo({
url: someURL,
defaultLanguage: "en"
});
// becomes
player.loadVideo({
url: someURL,
defaultAudioTrack: {
language: "en"
}
});
With audio description:
player.loadVideo({
url: someURL,
defaultAudioTrack: {
language: "en",
audioDescription: true
}
});
defaultSubtitle parameter
What changed
defaultSubtitle
is replaced by the defaultTextTrack
option, which
supports closed caption.
Replacement example
Without closed caption:
// In the previous version
player.loadVideo({
url: someURL,
defaultSubtitle: "en"
});
// becomes
player.loadVideo({
url: someURL,
defaultTextTrack: {
language: "en"
}
});
With closed caption:
player.loadVideo({
url: someURL,
defaultTextTrack: {
language: "en",
closedCaption: true
}
});
images parameter
What changed
images
is renamed as supplementaryImageTracks
for clarity.
Replacement example
// In the previous version
player.loadVideo({
url: someURL,
images: {
mimeType: "application/bif",
url: "",
},
});
// becomes
player.loadVideo({
url: someURL,
supplementaryImageTracks: {
mimeType: "application/bif",
url: "",
},
});
subtitles parameter
What changed
You have two possibilities. Either:
- Use the exernal
TextTrackRenderer
tool, documented here. This is the preferred way. - Replace
subtitles
bysupplementaryTextTracks
. Please note however thatsupplementaryTextTracks
is a deprecated feature.
Replacement example
If you go under the supplementaryTextTracks
route:
// In the previous version
player.loadVideo({
url: someURL,
subtitles: {
mimeType: "application/x-sami",
url: "",
},
});
// becomes
player.loadVideo({
url: someURL,
supplementaryTextTracks: {
mimeType: "application/x-sami",
url: "",
},
});
If you prefer to use the TextTrackRenderer
instead, I invite you to directly
read, its documentation, as the API is completely
different there.
timeFragment parameter
What changed
The timeFragment
parameter has been completely removed.
If you want to start at a precize point in the content, you can use the
startAt
parameter instead, documented
here.
If you want to end at a precize point in the content, this has not been re-implemented as I do not know for now any usecase for that. Please open an issue if you need that feature.
### manifests parameter ########################################################What changed
The manifests
parameter has been completely removed. Its behavior can easily
be replaced by two existing options: url
and keySystems
:
-
The url of the first object in the
manifests
array should be put in theurl
parameter -
Each
keySystem
property defined in themanifests
array should be put in thekeySystems
array, in the same order
Doing this should lead to the exact same behavior.
Replacement example
// In the previous version
player.loadVideo({
manifests: [
{
url: someURL1
keySystem: keySystem1
},
{
url: someURL2
},
{
url: someURL3
keySystem: keySystem3
},
{
url: someURL4
keySystem: keySystem4
}
],
});
// becomes
player.loadVideo({
url: someURL1,
keySystems: [
keySystem1,
keySystem3,
keySystem4
],
});
Removed methods
getVideoMaxBitrate / getAudioMaxBitrate / setVideoMaxBitrate / setAudioMaxBitrate
What changed
Those methods just changed their name to have a more coherent API:
setVideoMaxBitrate
becomessetMaxVideoBitrate
setAudioMaxBitrate
becomessetMaxAudioBitrate
getVideoMaxBitrate
becomesgetMaxVideoBitrate
getAudioMaxBitrate
becomesgetMaxAudioBitrate
This is mostly done to be aligned with the maxVideoBitrate
and
maxAudioBitrate
constructor options.
Replacement examples
setVideoMaxBitrate
// In the previous version
player.setVideoMaxBitrate(1500);
// becomes
player.setMaxVideoBitrate(1500);
setAudioMaxBitrate
// In the previous version
player.setAudioMaxBitrate(999);
// becomes
player.setMaxAudioBitrate(999);
getVideoMaxBitrate
// In the previous version
maxBitrate = player.getVideoMaxBitrate();
// becomes
maxBitrate = player.getMaxVideoBitrate();
getAudioMaxBitrate
// In the previous version
maxBitrate = player.getAudioMaxBitrate();
// becomes
maxBitrate = player.getMaxAudioBitrate();
setVideoBufferSize / setAudioBufferSize / getVideoBufferSize / getAudioBufferSize
What changed
Those four methods were removed to be replaced with simpler generic
getWantedBufferAhead
/setWantedBufferAhead
methods. They also take
seconds in argument.
The only difference is that you cannot discriminate by type of buffer (audio/video) anymore. This is for done for multiple reasons:
-
There are more than two types of buffers (for now there are four: audio, video, text and image). Adding one methods per type could be cumbersome for the user (for example, when wanting to set the limit for three or four of them)
-
More buffer-related APIs were added which are type-agnostic. Adding one A per-type would be heavy both for the rx-player and for the application using it
-
It’s easier to explain through the documentation, for people that do not want to understand the nitty-gritty of a player
-
We did not encounter any usecase for separate methods yet
Replacement examples
setVideoBufferSize
// In the previous version
player.setVideoBufferSize(15);
// becomes (also affect audio, text and image buffer)
player.setWantedBufferAhead(15);
setAudioBufferSize
// In the previous version
player.setAudioBufferSize(10);
// becomes (also affect video, text and image buffer)
player.setWantedBufferAhead(10);
getVideoBufferSize
// In the previous version
bufferSize = player.getVideoBufferSize();
// becomes
bufferSize = player.getWantedBufferAhead();
getAudioBufferSize
// In the previous version
bufferSize = player.getAudioBufferSize();
// becomes
bufferSize = player.setWantedBufferAhead();
asObservable
What Changed
asObservable
has been completely removed for the following reasons:
-
it exposed too much of the player. Guaranteeing compatibility between versions was too hard.
-
it exposed the internal RxJS library, which we now stop to do for various reasons.
getAvailableLanguages
What Changed
This method now has been completely replaced by getAvailableAudioTracks
which adds audio description support. See the API
documentation for more infos.
Replacement example
// In the previous version
audioTracks = player.getAvailableLanguages();
if (audioTracks && audioTracks.length) {
console.log("audio languages:", ...audioTracks);
} else {
console.log("no audio language");
}
// -------------------------------
// becomes
audioTracks = player.getAvailableAudioTracks();
if (audioTracks && audioTracks.length) {
console.log("audio languages:", ...audioTracks.map(track => track.language));
} else {
console.log("no audio language");
}
getAvailableSubtitles
What Changed
This method now has been completely replaced by getAvailableTextTracks
which
adds closed caption support. See the API documentation for
more infos.
Replacement example
// In the previous version
subtitleTracks = player.getAvailableSubtitles();
if (subtitleTracks && subtitleTracks.length) {
console.log("subtitle languages:", ...subtitleTracks);
} else {
console.log("no subtitle language");
}
// -------------------------------
// becomes
subtitleTracks = player.getAvailableTextTracks();
if (subtitleTracks && subtitleTracks.length) {
console.log("subtitle languages:",
...subtitleTracks.map(track => track.language));
} else {
console.log("no subtitle language");
}
getAverageBitrates
What Changed
getAverageBitrates
is deleted. It can normally be completely replaced by the
bitrateEstimationChange
event which can be
listened thanks to the addEventListener
method.
getCurrentTime
What Changed
getCurrentTime was separated in two methods:
-
getWallClockTime: returns the wall-clock-time of the current position in seconds. That is:
- for live content, get a timestamp in seconds of the current position.
- for static content, returns the position from beginning, also in seconds.
This is the closest implementation of getCurrentTime. The only difference being that for live contents, a timestamp will be returned (in seconds), not a Date object
-
getPosition: returns the video element’s current position, in seconds. The difference with getWallClockTime is that for live contents the position is not re-calculated to match a live timestamp.
If you do not know if you want to use getWallClockTime or getPosition:
- If what you want is to display the current time to the user, you will most probably want to use getWallClockTime.
- If what you want is to interact with the player’s API or perform other actions with the real player data, use getPosition.
Replacement example
// In the previous version
currentTime = player.getCurrentTime();
if (currentTime instanceof Date) {
currentTime = currentTime.getTime() / 1000;
}
// -------------------------------
// becomes
currentTime = player.getWallClockTime();
getDebug / showDebug / hideDebug / toggleDebug
What Changed
Those will be removed from the API and won’t be replaced.
Those methods were used internally, but were exposed like regular APIs. They have not much usage either as other APIs should be sufficient.
getEndTime
What Changed
getEndTime
was removed from the API. Its role can be replaced by the new
getMaximumPosition
API which will return the maximum position the user can
seek to.
Replacement example
// In the previous version
endTime = player.getEndTime();
// becomes
endTime = player.getMaximumPosition();
static getErrorCodes
What Changed
This static method was updated to a static property ErrorCodes
.
Replacement example
// In the previous version
errorCodes = player.getErrorCodes();
// becomes
errorCodes = player.ErrorCodes;
static getErrorTypes
What Changed
This static method was updated to a static property ErrorTypes
.
Replacement example
// In the previous version
errorTypes = player.getErrorTypes();
// becomes
errorTypes = player.ErrorTypes;
getImageTrack
What Changed
getImageTrack
is now replaced by both:
-
the
imageTrackUpdate
event (the closest togetImageTrack
previous behavior) triggered each time new image data is received with the complete image data as a payload (all the image data from the current image adaptation) in adata
property. -
the
getImageTrackData
method, which returns an array for all the currently referenced image data for the seekable content.
Replacement example
// In the previous version
player.getImageTrack().subscribe(images => {
displaySomeImages(images);
});
// becomes
player.addEventListener("imageTrackUpdate", ({ data }) => {
displaySomeImages(data);
});
getLanguage
What Changed
getLanguage
has been replaced by getAudioTrack
which adds audio
description support.
Replacement example
// In the previous version
track = player.getLanguage();
if (track) {
console.log("audio language:", track);
} else {
console.log("no audio language");
}
// ------------------------
// becomes
track = player.getAudioTrack();
if (track) {
console.log("audio language:", track.language);
} else {
console.log("no audio language");
}
getMetrics
What Changed
getMetrics is removed from the API and is not replaced. This is due to the fact that the ABR (adaptive bitrate) strategy completely changed, and re-implementing this method is not straightforward.
getStartTime
What Changed
getStartTime
was removed from the API. Its role can be replaced by the new
getMinimumPosition
API which will return the minimum position the user can
seek to.
Replacement example
// In the previous version
startTime = player.getStartTime();
// becomes
startTime = player.getMinimumPosition();
getSubtitle
What Changed
getSubtitle
has been replaced by getTextTrack
which adds closed caption
support.
Replacement example
// In the previous version
track = player.getSubtitle();
if (track) {
console.log("text language:", track);
} else {
console.log("no text language");
}
// ------------------------
// becomes
track = player.getTextTrack();
if (track) {
console.log("text language:", track.language);
} else {
console.log("no text language");
}
goToStart
What Changed
goToStart
is removed from the API and not replaced. You might want to use
both getMinimumPosition
and seekTo
to seek to the earliest part of the
content.
Replacement example
// In the previous version
player.goToStart();
// becomes
player.seekTo(player.getMinimumPosition());
isLanguageAvailable / isSubtitleAvailable
What Changed
Those methods are removed and not replaced. Use getAvailableAudioTracks
/
getAvailableTextTracks
instead.
Replacement examples
isLanguageAvailable
// In the previous version
console.log(player.isLanguageAvailable("fr"));
// becomes
const tracks = player.getAvailableAudioTracks();
console.log(!!tracks && tracks.some(({ language }) => language === "fr"));
isSubtitleAvailable
// In the previous version
console.log(player.isSubtitleAvailable("fr"));
// becomes
const tracks = player.getAvailableTextTracks();
console.log(!!tracks && tracks.some(({ language }) => language === "fr"));
normalizeLanguageCode
What Changed
normalizeLanguageCode
is removed and not replaced. Switching audio and text
tracks is now id-based, so the language code has much less use than before.
setLanguage
What Changed
setLanguage
has been replaced by setAudioTrack
which adds audio
description support.
Replacement example
// In the previous version
try {
player.setLanguage("fr");
} catch(e) {
console.warn("no track found with this language");
}
// -------------------------
// becomes
track = player.getAvailableAudioTracks();
const indexOf = tracks && tracks.indexOf(({ language }) => language === "fr");
if (tracks && indexOf !== -1) {
player.setAudioTrack(tracks[indexOf].id);
} else {
console.warn("no track found with this language");
}
setSubtitle
What Changed
setSubtitle
has been replaced by setTextTrack
which adds closed caption
support.
Replacement example
// In the previous version
try {
player.setSubtitle("fr");
} catch(e) {
console.warn("no track found with this language");
}
// -------------------------
// becomes
track = player.getAvailableTextTracks();
const indexOf = tracks && tracks.indexOf(({ language }) => language === "fr");
if (tracks && indexOf !== -1) {
player.setTextTrack(tracks[indexOf].id);
} else {
console.warn("no track found with this language");
}
Changed methods
seekTo
What Changed
In the previous version, you could give directly a Number or Date object to
seekTo
. What it would do with that depended on if the content was a live
content or not:
-
for live content, a time in milliseconds or a Date object was expected corresponding to the WallClock time (timestamp of the live content)
-
for non-live content, the time in seconds was expected, which was the time the video tag seek to.
Now, you can only give a number or an Object to this function. If you give a number, it will allways be the new time in seconds the video tag will seek to. This call is documented here.
Replacement example
To copy the old behavior for live contents, you can set the wallClockTime
property:
// seeking at 30 minute before now on what is broadcasted live
// In the previous version:
player.seekTo(Date.now() - 30*60 * 1000);
// becomes
player.seekTo({ wallClockTime: Date.now() / 1000 - 30*60});
To copy the old behavior for non-live contents, nothing has changed:
// seek to the tenth second for a non live content
// In the previous version:
player.seekTo(10);
// becomes
player.seekTo(10);
setVideoBitrate / setAudioBitrate
What Changed
Previously, calling this method in the following situation threw an error:
- no content is playing
- the set bitrate does not exist
Now, this call never throws:
-
if you call it while no content is playing, the limit is still set for the next content played.
-
if the set bitrate does not exist on the current content, the value will just act as a ceil (the chosen bitrate will be the one immediately inferior). If still no bitrate is inferior to it, the lowest bitrate will be chosen instead.
getUrl
What Changed
Previously, calling this method when no content is playing threw an error.
Now, doing so will just return undefined
.
isLive
What Changed
Previously, calling this method when no content is playing threw an error.
Now, doing so will just return false
.
Removed events
currentTimeChange
What Changed
The currentTimeChange
is replaced by the positionUpdate
event.
It is similar to currentTimeChange
but with the following properties
removed:
buffered
paused
range
readyState
stalled
ts
(replaced byposition
)playback
(replaced byplaybackRate
)gap
(replaced bybufferGap
)
And with the following property updated:
wallClockTime
: will go from a Date object to the same indication in seconds.
progress
What Changed
progress
events are removed and not replaced. This is because it exposed to
much of our internal logic.
languageChange
What Changed
languageChange
is replaced by the audioTrackChange
event, which supports
audio description.
Replacement example
// In the previous version
player.addEventListener("languageChange", (lang) => {
console.log("language changed to", lang);
});
// becomes
player.addEventListener("audioTrackChange", (track) => {
const { language, id, audioDescription } = track;
console.log("language changed to", language);
});
subtitleChange
What Changed
subtitleChange
is replaced by the textTrackChange
event, which supports
closed caption.
Replacement example
// In the previous version
player.addEventListener("subtitleChange", (lang) => {
console.log("subtitle changed to", lang);
});
// becomes
player.addEventListener("textTrackChange", (track) => {
const { language, id, closedCaption } = track;
console.log("language changed to", language);
});
nativeTextTrackChange
What Changed
nativeTextTrackChange
is replace by the nativeTextTracksChange
(notice
the supplementary “s”) event.
Three things have changed comparatively:
-
The payload of this event now is an array of
TextTrack
element. Previously, it was a singleTextTrackElement
(which correspond to the first in the array). -
The event is also triggered when a
TextTrackElement
is removed from the<video>
tag. Previously, it was only when added. -
The event is fired even if no content is playing
This is to support edge cases where the <track>
element could be modified by
the user of our library, in which case the RxPlayer could give false
information. Also, this allows to signal when a TextTrack
has been removed
from the DOM to help you free up ressources on your side.
Replacement example
// In the previous version
player.addEventListener("nativeTextTrackChange", (track) => {
console.log("the track changed:", track);
});
// becomes
player.addEventListener("nativeTextTracksChange", (tracks) => {
if (tracks.length === 0) {
console.log("no active track!");
} else {
// in most usecases you can just check the first element.
// (this will have the exact same effect than the previous event)
console.log("the track changed:", tracks[0]);
}
});
Changed events
positionUpdate
What Changed
The maximumBufferTime
property has now been removed from positionUpdate
events. This is because this is now the exact same thing than:
liveGap + position
(from the same event) for live contentsduration
(from the same event) for non-live contents


This is the course website for IS590 Data Visualization in Spring 2019 (Online)
This week we finished up talking about some data operations (mutations, aggregations), and we began discussing the elements of a visualization.


--- layout: post title: Deploying Azure Resource Manager Virtual Machines with Visual Studio for IT Pros date: 2015-08-11 15:23:54.000000000 -04:00 type: post published: true status: publish categories: - Azure - DevOps - PowerShell tags: - Azure - Ch9 - DevOps - IT Pro - PowerShell - Resource Manager - Visual Studio meta: _edit_last: '1' _jetpack_related_posts_cache: a:1:{s:32:"8f6677c9d6b0f903e98ad32ec61f8deb";a:2:{s:7:"expires";i:1457906628;s:7:"payload";a:3:{i:0;a:1:{s:2:"id";i:2058;}i:1;a:1:{s:2:"id";i:1491;}i:2;a:1:{s:2:"id";i:1181;}}}} author: login: adminian email<EMAIL_ADDRESS>display_name: adminian first_name: '' last_name: '' ---
While PowerShell alone is great for deploying Azure Virtual Machines, the newest innovations in Visual Studio make PowerShell plus Azure even easier! Join Tommy Patterson and I as we walk through the process of setting up Visual Studio with an Azure subscription, editing the scripts in the traditional PowerShell ISE then moving over to showing how this can be done much easier with the latest Visual Studio enhancements! The latest innovation with Azure Resource Templates plus Visual Studio make multi-machine deployments so much easier. Visual Studio is not just for developers anymore!


Angela Simmons Poses In Tight Maroon Pants On Instagram
November 17, 2019
Angela Simmons Poses In Tight Maroon Pants On Instagram
Angela Simmons shared a new Instagram update a couple of days ago, and she rocked a pair of super-tight pants. They were maroon, and appeared to be made of leather or a similar fabric. She paired the pants with a velvety, long-sleeved shirt. The top featured a small turtleneck. Plus, the Growing Up Hip Hop star threw on a fur or faux fur stole, which added a glowing yellow color to her outfit.
The stunner wore her hair down in a middle part with tight curls, which she brushed in front of her shoulders in the first photo of the set. She accessorized with silver hoop earrings, but no necklace. Her makeup included shimmery lipstick. Angela also infused a surprising pop of color with her bright light blue manicure.
All four photos showed her posing outside on a patio. The wall behind her was light yellow, while the flooring was a bluish gray. She stood while holding onto the railing with her left hand, as she grabbed her pants with her other. Angela looked into the distance for the shot. The third and fourth photos were also similar, as she made subtle changes in her pose.
Plus, the bombshell mixed things up with a photo of herself posing in the corner of the patio. She stood near the sliding glass door, and popped out her left foot. She also grabbed the jacket and held it closed. Angela glanced up into the distance, as she parted her lips.
All of the photos showed her coy side, as she appeared to be loving her outfit.
Fans left a wide range of comments for Angela in the comments section.
“Everything fall should look like! Beautiful!” gushed a follower.
“I SWEAR TO GOD I LOVE U,” declared an admirer.
However, not everyone was on board.
Loading...
“An innocent animal brutally died for that fur you are wearing,” complained a third Instagram user, who seemingly believes that it’s not faux.
Others referred to her family.
“Hey Angela how is your day going tell your dad happy birthday I’m a big rundmc fan much love to you and your family,” wrote a fan.
In addition, the reality TV star previously posted another photo where she rocked another pair of tight pants. The update from earlier this month showed Angela posing outdoors. Her pants were a dark denim wash, which she paired with a white dress shirt and a bright green jacket. She wore her hair down in a side part with luxurious curls. Her multiple pearl necklaces added an eye-catching element to her look.


Please insert the course code & instructor code that you'd like to see the result for and then click the blue button to see your result. (You can find these codes on your registration cards at http://gbpuat-regi.in)
If you are unable to receive your result, please send me a screenshot of the error at this link and I'll try to help you.


... is waiting for you watching , refreshing every seconds, and, when questions are available, will times per minute.


-eq treats this as a variable. Use = to compare as string (or expand explicitly with $var)
read -p "Continue? [y/n] " var
[ "$var" -eq "n" ] && exit 1
#read -p "Continue? [y/n] " var
[ "$var" = "n" ] && exit 1
ShellCheck found a string used as an argument to a numerical operator like -eq
, -ne
, -lt
, -ge
. Such strings will be treated as arithmetic expressions, meaning n
will refer to a variable $n
, and 24/12
will be evaluated into 2
.
In the problematic example, the intention was instead to compare "n"
as a string, so it should use the equivalent string operator instead, in this case =
.
It is perfectly valid to use variables as operands. ShellCheck will not flag any value that is an unquoted variable name assigned in the script:
a=42; [[ "a" -eq 0 ]] # Flagged due to quotes
[[ b -eq 0 ]] # Flagged due to not being assigned
c=42; [[ c -eq 0 ]] # Not flagged
However, ShellCheck does not know whether you intended foo/bar
to be division or a file path.
If you intended to divide $foo
and $bar
, you can either make it explicit with [[ $((foo/bar)) -ge 0 ]]
, or simply [[ignore]] the warning.


Madrid
Capital of Spain
Madrid, the capital of Spain, located in the center of the country, is a city of elegant avenues and large and well-kept parks, such as Buen Retiro. It is famous for the rich collections of European art, among which are the works of Goya, Velázquez and other Spanish masters at the Prado Museum. The center of old Habsburg-era Madrid is the Plaza Mayor, flanked by porticos, and nearby are the Baroque Royal Palace and the Royal Arsenal, which displays historic weapons. More
In the 1970s, Madrid became the epicenter of La Movida, an energetic movement of artistic expression. The Prado is part of the "Golden Triangle", along with the Reina Sofía Museum (home to Picasso's "Guernica") and the Thyssen-Bornemisza Museum. El Rastro, a Sunday flea market, is in the medieval neighborhood of La Latina, famous for its nightlife, theater and tapas bars. The central plaza Puerta del Sol is where the statue of the Bear and the Medronheiro, image of the coat of arms of the city, while the National Archaeological Museum exhibits a vast collection of historical artifacts. Real Madrid, the city's main soccer team, plays at the Santiago Bernabeu Stadium.
Things to do
Royal Palace
Plaza Mayor
Porta Del Sol
Prado Museum


Terrorist API REQUEST: /help RESPONSE: This page with help on how to use the Terrorism Web Application. REQUEST: /world RESPONSE: a JSON list of dictionaries, each of which represents one country, sorted alphabetically. Each country dictionary will have the following fields: name -- (string) the name of the country code -- (string) the three letter code corresponding with the country terrorist attacks -- (integer) the total number of terrorist attacks in that country from 1960 to 2018. If years are specified as a filter, then only the total number of terrorist attacks within those years. APPLICATION: A world heat map representing the density of terrorist attacks per country. REQUEST: /country/{country_code} RESPONSE: a JSON list of dictionaries, each of which represents one attack that occurred in the country matching the country_code. If years are specified as a filter, then only the terrorist attacks within those years will be included. Each attack dictionary will have the following fields: attack_id -- (integer) the id of the attack year -- (integer) the year in which the attack occurred. month -- (integer) the month in which the attack occurred. day -- (integer) the day on which the attack occurred. latitude -- (tuple) the latitude gps coordinate of the attack longitude -- (tuple) the longitude gps coordinate of the attack summary -- (string) the summary description of the attack APPLICATION: A map of one country whose code matches the county_code given. A code will be returned by clicking on a specific country from the world map page. The country map will have pins, each representing and individual terrorist attack that occurred in the given country. Rolling the mouse over a pin will give summary information about the attack. REQUEST: /attack/{attack_id} RESPONSE: a JSON list of dictionaries, which contains a single attack whose id matches the request. This dictionary will have the following fields. eventid -- (integer) an id representing a single instance of a terrorist attack in the given city year -- (integer) year of attack month -- (integer) month of attack day -- (integer) day of attack country -- (string) The name of the country where attack took place province -- (string) The name of the provstate where attack took place city -- (string) The name of city where attack took place latitude -- (decimal) latitude where attack took place longitude -- (decimal) longitude where attack took place location -- (string) location where attack took place summary -- (string) summary of attack attack_type -- (string) The attack type success -- (integer) Whether or not the attack was successful suicide -- (integer) Whether or not it was a suicide attack target_type -- (string) The target type target_subtype -- (string) The target subtype target -- (string) Description of the target of the attack perpetrator -- (string) The perpetrator of the attack motive -- (string) The motive of the attack weapon_type -- (string) The type of weapon used weapon_subtype -- (string) The subtype of the weapon used weapon_detail -- (string) Other details about the weapon number_killed -- (integer) The number of people killed in the attack number_wounded -- (integer) The number of people wounded in the attack property_damage -- (string) The estimated dollar amount of property damage APPLICATION: A page giving information and statistics about a certain attack that matches the attack_id. attack_id is returned by clicking on a specific pin from the country map page. A summary of the attack as well as details regarding the attack will be displayed. REQUEST: /centroid/{country_code} RESPONSE: a JSON list of coordinates, latitude and longitude, used for centering the maps on the page. REQUEST: /search/{search_text} RESPONSE: a JSON list of dictionaries, each of which represents one attack that occurred in the country matching the country_code. If years are specified as a filter, then only the terrorist attacks within those years will be included. Each attack dictionary will have the following fields: attack_id -- (integer) the id of the attack year -- (integer) the year in which the attack occurred. month -- (integer) the month in which the attack occurred. day -- (integer) the day on which the attack occurred. latitude -- (tuple) the latitude gps coordinate of the attack longitude -- (tuple) the longitude gps coordinate of the attack summary -- (string) the summary description of the attack perpetrator results will contain the following fields: eventid -- (integer) an id representing a single instance of a terrorist attack in the given area in the given year date -- (string) the exact date of the attack perpetrator -- (string) the perpetrator of the attack summary -- (string) the summary description of the attack REQUEST: /countrynames/{search_text} RESPONSE: a JSON list of dictionaries, each of which represents one country. Each country dictionary will have country name and country code for use in search suggestions. For example in application: /world will show a map of the world with each country colored based on the amount of attacks it suffered between 1960 and 2018. /country/usa will show a map of the United States with pins for each attack that occurred in the United States between 1960 and 2018.


0ms - Quiet note, repeating
0ms - Gull
150ms - Gull interrupting previous gull
1000ms - Rat
1050ms - Rat overlapping prev rat
2500ms - Note single
3500ms - Note single overlapping
4000ms - Pause mid notes
4500ms - Note, (fails: instances used up)
8000ms - Resume
9000ms - Note single
10000ms - Stop repeating note, letting previous note fade out


Search
FILTER BY
Filter option 1
Filter option 2
Filter option 3
Refresh table
ROW HEIGHT
Select table row height
Short
Tall


---
layout: page
title: Highlights
search_omit: true
---
Mar. 2017, a patent application is submitted to USPTO.
May. 2016, I started my first job at Intelligent Fusion Technology, Inc. as a Research Scientist.
May. 2016, I graduated from Utah State University with a Ph.D. degree in Electrical Engineering!
Nov. 2015, I successfully defended my Ph.D. dissertation!


| Home | Libraries | People | FAQ | More |
Copyright © 2002, 2004, 2006 Joel de Guzman, Eric Niebler
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Last revised: May 21, 2008 at 03:54:31 GMT |


Stadia
by @GoogleStadiaHere’s the latest update: If you ordered and paid for Founder’s Edition, you should now have your Stadia access code.
Pre-orders and access codes for Premiere Edition will start shipping early next week. Thanks for sticking with us!


MVP
Admin
Tables
Schedule
Register User
Admin User
Feedback
Course Stats
Course Properties
Search History
Professor Images
Advanced Queries
Pratik Query
Dimitar Query
Michael Query
Omar Query
RATE
ABOUT US
GEN-ED SELECTOR
{{user}}
LOGOUT


Madison Pettis Straightens Her Curly Hair For #REVOLVEawards 2019
Madison Pettis shows off her straightened hair while attending the 2019 #REVOLVEawards held at Goya Studios on Friday night (November 15) in Hollywood.
The 21-year-old actress switched up her hair style for the event from her usual, very curly hair.
At last year’s #REVOLVEawards, Madison also went with a straight hair style!
Also in attendance at the event were model sisters Amelia Gray and Delilah Belle, Anastasia Karanikolaou, Remi Cruz, Alexis Ren, and Chloe Lukasiak.
Alexis just returned from a trip to Costa Rica to help raise awareness and money for coral reefs. Check out a video she just released HERE!


The last taken raw image from the camera is taken. Use the Button "Create New Reference" to make your own reference.
Most important feature is a straight alignment of the image. Use the Pre roate Angle and the fine alignment to fine tune the rotation of the image
Finish the step by pushing "Update Reference Image".


This note demonstrates some of what Markdown is capable of doing.
Paragraphs can be written like so. A paragraph is the basic block of Markdown. A paragraph is what text will turn into when there is no reason it should become anything else.
Paragraphs must be separated by a blank line. Basic formatting of italics and bold is supported. This can be nested like so.
Note: the fourth item uses the Unicode character for Roman numeral four.
Code blocks are very useful for developers and other people who look at code or other things that are written in plain text. As you can see, it uses a fixed-width font.
You can also make inline code
to add code into other things.
Here is a quote. What this is should be self explanatory. Quotes are automatically indented when they are used.
There are six levels of headings. They correspond with the six levels of HTML headings. You've probably noticed them already in the page. Each level down uses one more hash character.
inline code
Of course, demonstrating what headings look like messes up the structure of the page.
I don't recommend using more than three or four levels of headings here, because, when you're smallest heading isn't too small, and you're largest heading isn't too big, and you want each size up to look noticeably larger and more important, there there are only so many sizes that you can use.
URLs can be made in a handful of ways:
A horizontal rule is a line that goes across the middle of the page.
It's sometimes handy for breaking things up.
Markdown can also contain images.
There's actually a lot more to Markdown than this. See the official introduction and syntax for more information. However, be aware that this is not using the official implementation, and this might work subtly differently in some of the little things.


Pop an item from the persistent list specified by PLACE.
(defmacro p-pop (place &environment env)
"Pop an item from the persistent list specified by PLACE."
(multiple-value-bind (dummies vals new setter getter)
(get-setf-expansion place env)
`(let* (,@(mapcar #'list dummies vals) (,(car new) ,getter))
(prog1 (p-car ,(car new))
(setq ,(car new) (p-cdr ,(car new)))
,setter))))
Source Context


bitexmining
member login
login
Forgot Your Password?
Don't have an account?
register now
Copyright © 2020 bitexmining All Rights Reserved


Will respond with either an error or success message depending on the token sent in the request header. Expects a key of 'token' with the value of the token.