In this tutorial, you’ll learn how to create Storm topologies and deploy them to a Storm cluster. Java will be the main language used, but a few examples will use Python to illustrate Storm’s multi-language capabilities.
Preliminaries
This tutorial uses examples from the storm-starter project. It’s recommended that you clone the project and follow along with the examples. Read Setting up a development environment and Creating a new Storm project to get your machine set up.
Components of a Storm cluster
A Storm cluster is superficially similar to a Hadoop cluster.  “Jobs” and “topologies” themselves are very different – one key difference is that a MapReduce job eventually finishes, whereas a topology processes messages forever (or until you kill it).
There are two kinds of nodes on a Storm cluster: the master node and the worker nodes. The master node runs a daemon called “Nimbus” that is similar to Hadoop’s “JobTracker”. Nimbus is responsible for distributing code around the cluster, assigning tasks to machines, and monitoring for failures.
Each worker node runs a daemon called the “Supervisor”. The supervisor listens for work assigned to its machine and starts and stops worker processes as necessary based on what Nimbus has assigned to it. Each worker process executes a subset of a topology; a running topology consists of many worker processes spread across many machines.
All coordination between Nimbus and the Supervisors is done through a Zookeeper cluster. Additionally, the Nimbus daemon and Supervisor daemons are fail-fast and stateless; all state is kept in Zookeeper or on local disk. This means you can kill -9 Nimbus or the Supervisors and they’ll start back up like nothing happened. This design leads to Storm clusters being incredibly stable.
Topologies
To do realtime computation on Storm, you create what are called “topologies”. A topology is a graph of computation. Each node in a topology contains processing logic, and links between nodes indicate how data should be passed around between nodes.
Running a topology is straightforward. First, you package all your code and dependencies into a single jar. Then, you run a command like the following:
storm jar all-my-code.jar backtype.storm.MyTopology arg1 arg2
This runs the class backtype.storm.MyTopology
with the arguments arg1
and arg2
. The main function of the class defines the topology and submits it to Nimbus. The storm jar
part takes care of connecting to Nimbus and uploading the jar.
Since topology definitions are just Thrift structs, and Nimbus is a Thrift service, you can create and submit topologies using any programming language. The above example is the easiest way to do it from a JVM-based language. See Running topologies on a production cluster] for more information on starting and stopping topologies.
Streams
The core abstraction in Storm is the “stream”. A stream is an unbounded sequence of tuples. Storm provides the primitives for transforming a stream into a new stream in a distributed and reliable way. For example, you may transform a stream of tweets into a stream of trending topics.
The basic primitives Storm provides for doing stream transformations are “spouts” and “bolts”. Spouts and bolts have interfaces that you implement to run your application-specific logic.
A spout is a source of streams. For example, a spout may read tuples off of a Kestrel queue and emit them as a stream. Or a spout may connect to the Twitter API and emit a stream of tweets.
A bolt consumes any number of input streams, does some processing, and possibly emits new streams. Complex stream transformations, like computing a stream of trending topics from a stream of tweets, require multiple steps and thus multiple bolts. Bolts can do anything from run functions, filter tuples, do streaming aggregations, do streaming joins, talk to databases, and more.
Networks of spouts and bolts are packaged into a “topology” which is the top-level abstraction that you submit to Storm clusters for execution. A topology is a graph of stream transformations where each node is a spout or bolt. Edges in the graph indicate which bolts are subscribing to which streams. When a spout or bolt emits a tuple to a stream, it sends the tuple to every bolt that subscribed to that stream.
Links between nodes in your topology indicate how tuples should be passed around. For example, if there is a link between Spout A and Bolt B, a link from Spout A to Bolt C, and a link from Bolt B to Bolt C, then everytime Spout A emits a tuple, it will send the tuple to both Bolt B and Bolt C. All of Bolt B’s output tuples will go to Bolt C as well.
Each node in a Storm topology executes in parallel. In your topology, you can specify how much parallelism you want for each node, and then Storm will spawn that number of threads across the cluster to do the execution.
A topology runs forever, or until you kill it. Storm will automatically reassign any failed tasks. Additionally, Storm guarantees that there will be no data loss, even if machines go down and messages are dropped.
Data model
Storm uses tuples as its data model. A tuple is a named list of values, and a field in a tuple can be an object of any type. Out of the box, Storm supports all the primitive types, strings, and byte arrays as tuple field values. To use an object of another type, you just need to implement a serializer for the type.
Every node in a topology must declare the output fields for the tuples it emits. For example, this bolt declares that it emits 2-tuples with the fields “double” and “triple”:
```java public class DoubleAndTripleBolt extends BaseRichBolt { private OutputCollectorBase _collector;
@Override
public void prepare(Map conf, TopologyContext context, OutputCollectorBase collector) {
_collector = collector;
}
@Override
public void execute(Tuple input) {
int val = input.getInteger(0);
_collector.emit(input, new Values(val*2, val*3));
_collector.ack(input);
}
@Override
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("double", "triple"));
} } ```
The declareOutputFields
function declares the output fields ["double", "triple"]
for the component. The rest of the bolt will be explained in the upcoming sections.
A simple topology
Let’s take a look at a simple topology to explore the concepts more and see how the code shapes up. Let’s look at the ExclamationTopology
definition from storm-starter:
java
TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("words", new TestWordSpout(), 10);
builder.setBolt("exclaim1", new ExclamationBolt(), 3)
.shuffleGrouping("words");
builder.setBolt("exclaim2", new ExclamationBolt(), 2)
.shuffleGrouping("exclaim1");
This topology contains a spout and two bolts. The spout emits words, and each bolt appends the string “!!!” to its input. The nodes are arranged in a line: the spout emits to the first bolt which then emits to the second bolt. If the spout emits the tuples [“bob”] and [“john”], then the second bolt will emit the words [“bob!!!!!!”] and [“john!!!!!!”].
This code defines the nodes using the setSpout
and setBolt
methods. These methods take as input a user-specified id, an object containing the processing logic, and the amount of parallelism you want for the node. In this example, the spout is given id “words” and the bolts are given ids “exclaim1” and “exclaim2”.
The object containing the processing logic implements the IRichSpout interface for spouts and the IRichBolt interface for bolts.
The last parameter, how much parallelism you want for the node, is optional. It indicates how many threads should execute that component across the cluster. If you omit it, Storm will only allocate one thread for that node.
setBolt
returns an InputDeclarer object that is used to define the inputs to the Bolt. Here, component “exclaim1” declares that it wants to read all the tuples emitted by component “words” using a shuffle grouping, and component “exclaim2” declares that it wants to read all the tuples emitted by component “exclaim1” using a shuffle grouping. “shuffle grouping” means that tuples should be randomly distributed from the input tasks to the bolt’s tasks. There are many ways to group data between components. These will be explained in a few sections.
If you wanted component “exclaim2” to read all the tuples emitted by both component “words” and component “exclaim1”, you would write component “exclaim2”’s definition like this:
java
builder.setBolt("exclaim2", new ExclamationBolt(), 5)
.shuffleGrouping("words")
.shuffleGrouping("exclaim1");
As you can see, input declarations can be chained to specify multiple sources for the Bolt.
Let’s dig into the implementations of the spouts and bolts in this topology. Spouts are responsible for emitting new messages into the topology. TestWordSpout
in this topology emits a random word from the list [“nathan”, “mike”, “jackson”, “golda”, “bertels”] as a 1-tuple every 100ms. The implementation of nextTuple()
in TestWordSpout looks like this:
java
public void nextTuple() {
Utils.sleep(100);
final String[] words = new String[] {"nathan", "mike", "jackson", "golda", "bertels"};
final Random rand = new Random();
final String word = words[rand.nextInt(words.length)];
_collector.emit(new Values(word));
}
As you can see, the implementation is very straightforward.
ExclamationBolt
appends the string “!!!” to its input. Let’s take a look at the full implementation for ExclamationBolt
:
```java public static class ExclamationBolt implements IRichBolt { OutputCollector _collector;
public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
_collector = collector;
}
public void execute(Tuple tuple) {
_collector.emit(tuple, new Values(tuple.getString(0) + "!!!"));
_collector.ack(tuple);
}
public void cleanup() {
}
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("word"));
}
public Map getComponentConfiguration() {
return null;
} } ```
The prepare
method provides the bolt with an OutputCollector
that is used for emitting tuples from this bolt. Tuples can be emitted at anytime from the bolt – in the prepare
, execute
, or cleanup
methods, or even asynchronously in another thread. This prepare
implementation simply saves the OutputCollector
as an instance variable to be used later on in the execute
method.
The execute
method receives a tuple from one of the bolt’s inputs. The ExclamationBolt
grabs the first field from the tuple and emits a new tuple with the string “!!!” appended to it. If you implement a bolt that subscribes to multiple input sources, you can find out which component the Tuple came from by using the Tuple#getSourceComponent
method.
There’s a few other things going in in the execute
method, namely that the input tuple is passed as the first argument to emit
and the input tuple is acked on the final line. These are part of Storm’s reliability API for guaranteeing no data loss and will be explained later in this tutorial.
The cleanup
method is called when a Bolt is being shutdown and should cleanup any resources that were opened. There’s no guarantee that this method will be called on the cluster: for example, if the machine the task is running on blows up, there’s no way to invoke the method. The cleanup
method is intended for when you run topologies in local mode (where a Storm cluster is simulated in process), and you want to be able to run and kill many topologies without suffering any resource leaks.
The declareOutputFields
method declares that the ExclamationBolt
emits 1-tuples with one field called “word”.
The getComponentConfiguration
method allows you to configure various aspects of how this component runs. This is a more advanced topic that is explained further on Configuration.
Methods like cleanup
and getComponentConfiguration
are often not needed in a bolt implementation. You can define bolts more succinctly by using a base class that provides default implementations where appropriate. ExclamationBolt
can be written more succinctly by extending BaseRichBolt
, like so:
```java public static class ExclamationBolt extends BaseRichBolt { OutputCollector _collector;
public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
_collector = collector;
}
public void execute(Tuple tuple) {
_collector.emit(tuple, new Values(tuple.getString(0) + "!!!"));
_collector.ack(tuple);
}
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("word"));
} } ```
Running ExclamationTopology in local mode
Let’s see how to run the ExclamationTopology
in local mode and see that it’s working.
Storm has two modes of operation: local mode and distributed mode. In local mode, Storm executes completely in process by simulating worker nodes with threads. Local mode is useful for testing and development of topologies. When you run the topologies in storm-starter, they’ll run in local mode and you’ll be able to see what messages each component is emitting. You can read more about running topologies in local mode on Local mode.
In distributed mode, Storm operates as a cluster of machines. When you submit a topology to the master, you also submit all the code necessary to run the topology. The master will take care of distributing your code and allocating workers to run your topology. If workers go down, the master will reassign them somewhere else. You can read more about running topologies on a cluster on Running topologies on a production cluster].
Here’s the code that runs ExclamationTopology
in local mode:
```java Config conf = new Config(); conf.setDebug(true); conf.setNumWorkers(2);
LocalCluster cluster = new LocalCluster(); cluster.submitTopology(“test”, conf, builder.createTopology()); Utils.sleep(10000); cluster.killTopology(“test”); cluster.shutdown(); ```
First, the code defines an in-process cluster by creating a LocalCluster
object. Submitting topologies to this virtual cluster is identical to submitting topologies to distributed clusters. It submits a topology to the LocalCluster
by calling submitTopology
, which takes as arguments a name for the running topology, a configuration for the topology, and then the topology itself.
The name is used to identify the topology so that you can kill it later on. A topology will run indefinitely until you kill it.
The configuration is used to tune various aspects of the running topology. The two configurations specified here are very common:
- TOPOLOGY_WORKERS (set with
setNumWorkers
) specifies how many processes you want allocated around the cluster to execute the topology. Each component in the topology will execute as many threads. The number of threads allocated to a given component is configured through thesetBolt
andsetSpout
methods. Those threads exist within worker processes. Each worker process contains within it some number of threads for some number of components. For instance, you may have 300 threads specified across all your components and 50 worker processes specified in your config. Each worker process will execute 6 threads, each of which of could belong to a different component. You tune the performance of Storm topologies by tweaking the parallelism for each component and the number of worker processes those threads should run within. - TOPOLOGY_DEBUG (set with
setDebug
), when set to true, tells Storm to log every message every emitted by a component. This is useful in local mode when testing topologies, but you probably want to keep this turned off when running topologies on the cluster.
There’s many other configurations you can set for the topology. The various configurations are detailed on the Javadoc for Config.
To learn about how to set up your development environment so that you can run topologies in local mode (such as in Eclipse), see Creating a new Storm project.
Stream groupings
A stream grouping tells a topology how to send tuples between two components. Remember, spouts and bolts execute in parallel as many tasks across the cluster. If you look at how a topology is executing at the task level, it looks something like this:
When a task for Bolt A emits a tuple to Bolt B, which task should it send the tuple to?
A “stream grouping” answers this question by telling Storm how to send tuples between sets of tasks. Before we dig into the different kinds of stream groupings, let’s take a look at another topology from storm-starter. This WordCountTopology reads sentences off of a spout and streams out of WordCountBolt
the total number of times it has seen that word before:
```java TopologyBuilder builder = new TopologyBuilder();
builder.setSpout(“sentences”, new RandomSentenceSpout(), 5);
builder.setBolt(“split”, new SplitSentence(), 8)
.shuffleGrouping(“sentences”);
builder.setBolt(“count”, new WordCount(), 12)
.fieldsGrouping(“split”, new Fields(“word”));
```
SplitSentence
emits a tuple for each word in each sentence it receives, and WordCount
keeps a map in memory from word to count. Each time WordCount
receives a word, it updates its state and emits the new word count.
There’s a few different kinds of stream groupings.
The simplest kind of grouping is called a “shuffle grouping” which sends the tuple to a random task. A shuffle grouping is used in the WordCountTopology
to send tuples from RandomSentenceSpout
to the SplitSentence
bolt. It has the effect of evenly distributing the work of processing the tuples across all of SplitSentence
bolt’s tasks.
A more interesting kind of grouping is the “fields grouping”. A fields grouping is used between the SplitSentence
bolt and the WordCount
bolt. It is critical for the functioning of the WordCount
bolt that the same word always go to the same task. Otherwise, more than one task will see the same word, and they’ll each emit incorrect values for the count since each has incomplete information. A fields grouping lets you group a stream by a subset of its fields. This causes equal values for that subset of fields to go to the same task. Since WordCount
subscribes to SplitSentence
’s output stream using a fields grouping on the “word” field, the same word always goes to the same task and the bolt produces the correct output.
Fields groupings are the basis of implementing streaming joins and streaming aggregations as well as a plethora of other use cases. Underneath the hood, fields groupings are implemented using mod hashing.
There’s a few other kinds of stream groupings. You can read more about them on Concepts.
Defining Bolts in other languages
Bolts can be defined in any language. Bolts written in another language are executed as subprocesses, and Storm communicates with those subprocesses with JSON messages over stdin/stdout. The communication protocol just requires an ~100 line adapter library, and Storm ships with adapter libraries for Ruby, Python, and Fancy.
Here’s the definition of the SplitSentence
bolt from WordCountTopology
:
```java public static class SplitSentence extends ShellBolt implements IRichBolt { public SplitSentence() { super(“python”, “splitsentence.py”); }
public void declareOutputFields(OutputFieldsDeclarer declarer) {
declarer.declare(new Fields("word"));
} } ```
SplitSentence
overrides ShellBolt
and declares it as running using python
with the arguments splitsentence.py
. Here’s the implementation of splitsentence.py
:
```python import storm
class SplitSentenceBolt(storm.BasicBolt): def process(self, tup): words = tup.values[0].split(“ “) for word in words: storm.emit([word])
SplitSentenceBolt().run() ```
For more information on writing spouts and bolts in other languages, and to learn about how to create topologies in other languages (and avoid the JVM completely), see Using non-JVM languages with Storm.
Guaranteeing message processing
Earlier on in this tutorial, we skipped over a few aspects of how tuples are emitted. Those aspects were part of Storm’s reliability API: how Storm guarantees that every message coming off a spout will be fully processed. See Guaranteeing message processing for information on how this works and what you have to do as a user to take advantage of Storm’s reliability capabilities.
Transactional topologies
Storm guarantees that every message will be played through the topology at least once. A common question asked is “how do you do things like counting on top of Storm? Won’t you overcount?” Storm has a feature called transactional topologies that let you achieve exactly-once messaging semantics for most computations. Read more about transactional topologies here.
Distributed RPC
This tutorial showed how to do basic stream processing on top of Storm. There’s lots more things you can do with Storm’s primitives. One of the most interesting applications of Storm is Distributed RPC, where you parallelize the computation of intense functions on the fly. Read more about Distributed RPC here.
Conclusion
This tutorial gave a broad overview of developing, testing, and deploying Storm topologies. The rest of the documentation dives deeper into all the aspects of using Storm.


Whether the returned array of results will be flattened to a single dimension array.
The JSON object to evaluate (whether of null, boolean, number, string, object, or array type).
In the current absence of JSON Schema support,
one can determine types beyond the built-in types by adding the
perator @other()
at the end of one's query.
If such a path is encountered, the otherTypeCallback
will be invoked
with the value of the item, its path, its parent, and its parent's
property name, and it should return a boolean indicating whether the
supplied value belongs to the "other" type or not (or it may handle
transformations and return false).
In the event that a query could be made to return the root node, this allows the parent of that root node to be returned within results.
In the event that a query could be made to return the root node, this allows the parentProperty of that root node to be returned within results.
The JSONPath expression as a (normalized or unnormalized) string or array.
Although JavaScript evaluation expressions are allowed by default, for security reasons (if one is operating on untrusted user input, for example), one may wish to set this option to true to throw exceptions when these expressions are attempted.
Can be case-insensitive form of "value", "path", "pointer", "parent", or "parentProperty" to determine respectively whether to return results as the values of the found items, as their absolute paths, as JSON Pointers to the absolute paths, as their parent objects, or as their parent's property name.
If set to "all", all of these types will be returned on an object with the type as key name.
Key-value map of variables to be available to code evaluations such as filtering expressions. (Note that the current path and value will also be available to those expressions; see the Syntax section for details.)
Whether or not to wrap the results in an array.
If wrap is set to false, and no results are found, undefined will be returned (as opposed to an empty array when wrap is set to true).
If wrap is set to false and a single non-array result is found, that result will be the only item returned (not within an array).
An array will still be returned if multiple results are found, however. To avoid ambiguities (in the case where it is necessary to distinguish between a result which is a failure and one which is an empty array), it is recommended to switch the default to false.
Generated using TypeDoc
If supplied, a callback will be called immediately upon retrieval of an end point value.
The three arguments supplied will be the value of the payload (according to
resultType
), the type of the payload (whether it is a normal "value" or a "property" name), and a full payload object (with allresultType
s).undefined


| Opcode/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
| 0F D8 /r1 PSUBUSB mm, mm/m64 | RM | V/V | MMX | Subtract unsigned packed bytes in mm/m64 from unsigned packed bytes in mm and saturate result. |
| 66 0F D8 /r PSUBUSB xmm1, xmm2/m128 | RM | V/V | SSE2 | Subtract packed unsigned byte integers in xmm2/m128 from packed unsigned byte integers in xmm1 and saturate result. |
| 0F D9 /r1 PSUBUSW mm, mm/m64 | RM | V/V | MMX | Subtract unsigned packed words in mm/m64 from unsigned packed words in mm and saturate result. |
| 66 0F D9 /r PSUBUSW xmm1, xmm2/m128 | RM | V/V | SSE2 | Subtract packed unsigned word integers in xmm2/m128 from packed unsigned word integers in xmm1 and saturate result. |
| VEX.NDS.128.66.0F.WIG D8 /r VPSUBUSB xmm1, xmm2, xmm3/m128 | RVM | V/V | AVX | Subtract packed unsigned byte integers in xmm3/m128 from packed unsigned byte integers in xmm2 and saturate result. |
| VEX.NDS.128.66.0F.WIG D9 /r VPSUBUSW xmm1, xmm2, xmm3/m128 | RVM | V/V | AVX | Subtract packed unsigned word integers in xmm3/m128 from packed unsigned word integers in xmm2 and saturate result. |
| VEX.NDS.256.66.0F.WIG D8 /r VPSUBUSB ymm1, ymm2, ymm3/m256 | RVM | V/V | AVX2 | Subtract packed unsigned byte integers in ymm3/m256 from packed unsigned byte integers in ymm2 and saturate result. |
| VEX.NDS.256.66.0F.WIG D9 /r VPSUBUSW ymm1, ymm2, ymm3/m256 | RVM | V/V | AVX2 | Subtract packed unsigned word integers in ymm3/m256 from packed unsigned word integers in ymm2 and saturate result. |
Notes: 1. See note in Section 2.4, “Instruction Exception Specification” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 2A and Section 22.25.3, “Exception Conditions of Legacy SIMD Instructions Operating on MMX Registers” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A.
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RM | ModRM:reg (r, w) | ModRM:r/m (r) | NA | NA |
| RVM | ModRM:reg (w) | VEX.vvvv (r) | ModRM:r/m (r) | NA |
Performs a SIMD subtract of the packed unsigned integers of the source operand (second operand) from the packed unsigned integers of the destination operand (first operand), and stores the packed unsigned integer results in the destination operand. See Figure 9-4 in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1, for an illustration of a SIMD operation. Overflow is handled with unsigned saturation, as described in the following paragraphs.
These instructions can operate on either 64-bit or 128-bit operands.
The (V)PSUBUSB instruction subtracts packed unsigned byte integers. When an individual byte result is less than zero, the saturated value of 00H is written to the destination operand.
The (V)PSUBUSW instruction subtracts packed unsigned word integers. When an individual word result is less than zero, the saturated value of 0000H is written to the destination operand.
In 64-bit mode, using a REX prefix in the form of REX.R permits this instruction to access additional registers (XMM8-XMM15).
Legacy SSE version: When operating on 64-bit operands, the destination operand must be an MMX technology register and the source operand can be either an MMX technology register or a 64-bit memory location. 128-bit Legacy SSE version: The second source operand is an XMM register or a 128-bit memory location. The first source operand and destination operands are XMM registers. Bits (VLMAX-1:128) of the corresponding YMM destination register remain unchanged. VEX.128 encoded version: The second source operand is an XMM register or a 128-bit memory location. The first source operand and destination operands are XMM registers. Bits (VLMAX-1:128) of the destination YMM register are zeroed. VEX.256 encoded version: The second source operand is an YMM register or a 256-bit memory location. The first source operand and destination operands are YMM registers.
Note: VEX.L must be 0, otherwise instructions will #UD.
PSUBUSB (with 64-bit operands) DEST[7:0] ← SaturateToUnsignedByte (DEST[7:0] − SRC (7:0] ); (* Repeat add operation for 2nd through 7th bytes *) DEST[63:56] ← SaturateToUnsignedByte (DEST[63:56] − SRC[63:56]; PSUBUSB (with 128-bit operands) DEST[7:0] ← SaturateToUnsignedByte (DEST[7:0] − SRC[7:0]); (* Repeat add operation for 2nd through 14th bytes *) DEST[127:120] ← SaturateToUnSignedByte (DEST[127:120] − SRC[127:120]); VPSUBUSB (VEX.128 encoded version) DEST[7:0] ← SaturateToUnsignedByte (SRC1[7:0] - SRC2[7:0]); (* Repeat subtract operation for 2nd through 14th bytes *) DEST[127:120] ← SaturateToUnsignedByte (SRC1[127:120] - SRC2[127:120]); DEST[VLMAX-1:128] ← 0 VPSUBUSB (VEX.256 encoded version) DEST[7:0] ← SaturateToUnsignedByte (SRC1[7:0] - SRC2[7:0]); (* Repeat subtract operation for 2nd through 31st bytes *) DEST[255:148] ← SaturateToUnsignedByte (SRC1[255:248] - SRC2[255:248]); PSUBUSW (with 64-bit operands) DEST[15:0] ← SaturateToUnsignedWord (DEST[15:0] − SRC[15:0] ); (* Repeat add operation for 2nd and 3rd words *) DEST[63:48] ← SaturateToUnsignedWord (DEST[63:48] − SRC[63:48] ); PSUBUSW (with 128-bit operands) DEST[15:0] (* Repeat add operation for 2nd through 7th words *) DEST[127:112] ← SaturateToUnSignedWord (DEST[127:112] − SRC[127:112]); VPSUBUSW (VEX.128 encoded version) DEST[15:0] ← SaturateToUnsignedWord (SRC1[15:0] - SRC2[15:0]); (* Repeat subtract operation for 2nd through 7th words *) DEST[127:112] ← SaturateToUnsignedWord (SRC1[127:112] - SRC2[127:112]); DEST[VLMAX-1:128] ← 0 VPSUBUSW (VEX.256 encoded version) DEST[15:0] ← SaturateToUnsignedWord (SRC1[15:0] - SRC2[15:0]); (* Repeat subtract operation for 2nd through 15th words *) DEST[255:240] ← SaturateToUnsignedWord (SRC1[255:240] - SRC2[255:240]);
| PSUBUSB: | __m64 _mm_subs_pu8(__m64 m1, __m64 m2) |
| (V)PSUBUSB: | __m128i _mm_subs_epu8(__m128i m1, __m128i m2) |
| VPSUBUSB: | __m256i _mm256_subs_epu8(__m256i m1, __m256i m2) |
| PSUBUSW: (V)PSUBUSW: __m128i _mm_subs_epu16(__m128i m1, __m128i m2) | __m64 _mm_subs_pu16(__m64 m1, __m64 m2) |
| VPSUBUSW: | __m256i _mm256_subs_epu16(__m256i m1, __m256i m2) |
None.
None.
See Exceptions Type 4; additionally
| #UD | If VEX.L = 1. |


[1] J. R. Hershey, Z. Chen, J. L. Roux, and S. Watanabe, “Deep clustering: Discriminative embeddings for segmentation and separation,” 2015.
[2] P. Huang, M. Kim, M. Hasegawa-Johnson, and P. Smaragdis, “Deep learning for monaural speech separation,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 2014, pp. 1562–1566.
[3] D. Wang and J. Chen, “Supervised speech separation based on deep learning: An overview,” IEEE/ACM Transactions on Acoustics, Speech, and Signal Processing, vol. 26, no. 10, pp. 1702–1726, Oct. 2018.
[4] E. C. Cherry, “Some experiments on the recognition of speech, with one and with two ears,” The Journal of the Acoustical Society of America, vol. 25, no. 5, pp. 975–979, 1953.
[5] T. Virtanen, “Monaural sound source separation by nonnegative matrix factorization with temporal continuity and sparseness criteria,” IEEE Transactions on Audio, Speech and Language Processing, vol. 15, no. 3, pp. 1066–1074, Mar. 2007.
[6] E. Vincent, R. Gribonval, and C. Fevotte, “Performance measurement in blind audio source separation,” IEEE Transactions on Audio, Speech and Language Processing, vol. 14, no. 4, pp. 1462–1469, Jul. 2006.
[7] Z.-Q. Wang, J. L. Roux, and J. R. Hershey, “Alternative objective functions for deep clustering,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 2018.
[8] Y. Isik, J. L. Roux, Z. Chen, S. Watanabe, and J. R. Hershey, “Single-channel multi-speaker separation using deep clustering,” in Interspeech, 2016.
[9] F.-R. Stöter, A. Liutkus, and N. Ito, “The 2018 Signal Separation Evaluation Campaign,” Apr. 2018.
[10] M. T. Adiga and R. Bhandarkar, “Improving single frequency filtering based voice activity detection (VAD) using spectral subtraction based noise cancellation,” in 2016 international conference on signal processing, communication, power and embedded system (SCOPES), 2016.
[11] J. R. Hershey, Z. Chen, J. L. Roux, and S. Watanabe, “Deep clustering: Discriminative embeddings for segmentation and separation,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 2016.
[12] R. G. Lyons, Understanding digital signal processing, 1st ed. Addison Wesley Pub. Co, 1997.
[13] J. W. Cooley and J. W. Tukey, “An algorithm for the machine calculation of complex fourier series,” Mathematics of Computation, vol. 19, no. 90, pp. 297–297, May 1965.
[14] V. Emiya, E. Vincent, N. Harlander, and V. Hohmann, “Subjective and objective quality assessment of audio source separation,” IEEE Transactions on Audio, Speech, and Language Processing, vol. 19, no. 7, pp. 2046–2057, Sep. 2011.
[15] A. V. Oppenheim, R. W. Schafer, and J. R. Buck, Discrete-time signal processing, 2nd ed. Prentice-Hall, Inc., 1999.
[16] J. O. Smith, “Overlap-add stft processing,” in Spectral audio signal processing, 2011.
[17] G. Heinzel, A. Ruediger, and R. Schilling, “Spectrum and spectral density estimation by the Discrete Fourier transform (DFT), including a comprehensive list of window functions and some new at-top windows.” Feb-2002.
[18] A. V. Oppenheim and R. W. Schafer, Discrete-time signal processing, 3rd ed. Pearson Education, 2014.
[19] T. E. Oliphant, A guide to numpy, vol. 1. Trelgol Publishing, 2006.
[20] F. J. Harris, “On the use of windows for harmonic analysis with the discrete fourier transform,” Proceedings of the IEEE, vol. 66, no. 1, pp. 51–83, 1978.
[21] S. Rosen, P. Souza, C. Ekelund, and A. A. Majeed, “Listening to speech in a background of other talkers: Effects of talker number and noise vocoding,” The Journal of the Acoustical Society of America, vol. 133, no. 4, pp. 2431–2443, Apr. 2013.
[22] G. A. Miller, “The masking of speech.” Psychological Bulletin, vol. 44, no. 2, pp. 105–129, 1947.
[23] D. L. Wang and G. J. Brown, Computational auditory scene analysis: Principles, algorithms, and applications. Wiley, 2006.
[24] J. M. Festen and R. Plomp, “Effects of fluctuating noise and interfering speech on the speech-reception threshold for impaired and normal hearing,” The Journal of the Acoustical Society of America, vol. 88, no. 4, pp. 1725–1736, Oct. 1990.
[25] D. D. Lee and H. S. Seung, “Learning the parts of objects by non-negative matrix factorization,” Nature, vol. 401, no. 6755, pp. 788–791, Oct. 1999.
[26] S. Dubnov, “Extracting sound objects by independent subspace analysis.” Jun-2002.
[27] M. A. Casey and A. Westner, “Separation of mixed audio sources by independent subspace analysis,” in ICMC, 2000.
[28] D. Wang, “On Ideal Binary Mask As the Computational Goal of Auditory Scene Analysis,” in Speech separation by humans and machines, P. Divenyi, Ed. Springer, 2005, pp. 181–197.
[29] B. Schuller, F. Weninger, M. Wollmer, Y. Sun, and G. Rigoll, “Non-negative matrix factorization as noise-robust feature extractor for speech recognition,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 2010.
[30] Y.-m. Qian, C. Weng, X.-k. Chang, S. Wang, and D. Yu, “Past review, current progress, and challenges ahead on the cocktail party problem,” Frontiers of Information Technology & Electronic Engineering, vol. 19, no. 1, pp. 40–63, Jan. 2018.
[31] Y. Hu and P. C. Loizou, “Subjective comparison and evaluation of speech enhancement algorithms,” Speech Communication, vol. 49, nos. 7-8, pp. 588–601, Jul. 2007.
[32] Y. Ephraim and D. Malah, “Speech enhancement using a minimum mean-square error log-spectral amplitude estimator,” IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. 33, no. 2, pp. 443–445, Apr. 1985.
[33] D. Marr, Vision: A computational investigation into the human representation and processing of visual information. Henry Holt; Co., Inc., 1982.
[34] M. N. Schmidt and R. K. Olsson, “Single-channel speech separation using sparse non-negative matrix factorization,” in Interspeech, 2006.
[35] Y. Tu, J. Du, Y. Xu, L. Dai, and C.-H. Lee, “Deep neural network based speech separation for robust speech recognition,” in 12th ieee international conference on signal processing (ICSP), 2014.
[36] D. Arthur and S. Vassilvitskii, “K-means++: The advantages of careful seeding,” in Proceedings of the eighteenth annual acm-siam symposium on discrete algorithms, 2007, pp. 1027–1035.
[37] S. Lloyd, “Least squares quantization in PCM,” IEEE Transactions on Information Theory, vol. 28, no. 2, pp. 129–137, Mar. 1982.
[38] P. Berkhin, “Survey of clustering data mining techniques,” 2002.
[39] K. Paliwal, K. Wójcicki, and B. Shannon, “The importance of phase in speech enhancement,” Speech Communication, vol. 53, no. 4, pp. 465–494, Apr. 2011.
[40] D. S. Williamson, Y. Wang, and D. Wang, “Complex ratio masking for monaural speech separation,” IEEE/ACM Transactions on Audio, Speech, and Language Processing, vol. 24, no. 3, pp. 483–492, Mar. 2016.
[41] I. Goodfellow, Y. Bengio, and A. Courville, Deep learning. MIT Press, 2016.
[42] A. L. Maas, A. Y. Hannun, and A. Y. Ng, “Rectifier nonlinearities improve neural network acoustic models,” in Proceedings of the international conference on machine learning, 2013.
[43] M. A. Nielsen, Neural networks and deep learning. Determination Press, 2015.
[44] A. Graves, Supervised sequence labelling with recurrent neural networks. Springer, 2012.
[45] M. Schuster and K. K. Paliwal, “Bidirectional recurrent neural networks,” IEEE Transactions on Signal Processing, vol. 45, no. 11, pp. 2673–2681, 1997.
[46] R. J. Williams and D. Zipser, “Gradient-Based Learning Algorithms for Recurrent Networks and Their Computational Complexity.” 1995.
[47] D. A. Heide and G. S. Kang, “Speech enhancement for bandlimited speech,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 1998, vol. 1, pp. 393–396.
[48] D. Aloise, A. Deshpande, P. Hansen, and P. Popat, “NP-hardness of Euclidean sum-of-squares clustering,” Machine Learning, vol. 75, no. 2, pp. 245–248, Jan. 2009.
[49] M. Kolbaek, D. Yu, Z.-H. Tan, and J. Jensen, “Multitalker speech separation with utterance-level permutation invariant training of deep recurrent neural networks,” IEEE/ACM Transactions on Audio, Speech, and Language Processing, vol. 25, no. 10, pp. 1901–1913, Oct. 2017.
[50] C. Bauckhage, “k-Means Clustering Is Matrix Factorization,” Dec. 2015.
[51] E. Keogh and A. Mueen, “Curse of dimensionality,” in Encyclopedia of machine learning and data mining, Springer US, 2017, pp. 314–315.
[52] P. Pudil and J. Novovičová, “Novel methods for feature subset selection with respect to problem knowledge,” in Feature extraction, construction and selection, Springer, 1998, pp. 101–116.
[53] J. Shlens, “A tutorial on principal component analysis,” 2014.
[54] J. S. Garofolo, L. F. Lamel, W. M. Fisher, J. G. Fiscus, and D. S. Pallett, “DARPA TIMIT - Acoustic-Phonetic Continuous Speech Corpus. NIST Speech Disc 1-1.1,” vol. 93. Feb-1993.
[55] J. S. Garofolo, D. Graff, D. Paul, and D. S. Pallett, “ARPA CSR-WSJ0 - Continuous Speech Recognition Wall Street Journal. NIST Speech Discs 11-1.1 - 11-12.1, 11-13.1, 11-14.1, and 11-15.1.” 1994.
[56] F. Hernandez, V. Nguyen, S. Ghannay, N. Tomashenko, and Y. Estève, “TED-lium 3: Twice as much data and corpus repartition for experiments on speaker adaptation,” in Speech and computer, 2018, pp. 198–208.
[57] Z. Rafii, A. Liutkus, F.-R. Stoter, S. I. Mimilakis, D. FitzGerald, and B. Pardo, “An overview of lead and accompaniment separation in music,” IEEE/ACM Transactions on Audio, Speech, and Language Processing, vol. 26, no. 8, pp. 1307–1335, Aug. 2018.
[58] E. Kreyszig, Advanced engineering mathematics, 9th ed. Wiley, 2006.
[59] B. Sharpe, “Invertibility of overlap-add processing.” 2018.
[60] D. Griffin and J. Lim, “Signal estimation from modified short-time fourier transform,” IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. 32, no. 2, pp. 236–243, Apr. 1984.
[61] B. McFee et al., “Librosa/librosa: 0.6.3.” Zenodo, 2019.
[62] K. Greff, R. K. Srivastava, J. Koutnik, B. R. Steunebrink, and J. Schmidhuber, “LSTM: A search space odyssey,” IEEE Transactions on Neural Networks and Learning Systems, vol. 28, no. 10, pp. 2222–2232, Oct. 2017.
[63] D. P. Kingma and J. Ba, “Adam: A Method for Stochastic Optimization,” arXiv e-prints, p. arXiv:1412.6980, Dec. 2014.
[64] Python Software Foundation, “The python language reference, version 3.7.3.”.
[65] F. Pedregosa et al., “Scikit-learn: Machine learning in Python,” Journal of Machine Learning Research, vol. 12, pp. 2825–2830, 2011.
[66] J. D. Hunter, “Matplotlib: A 2D graphics environment,” Computing in Science & Engineering, vol. 9, no. 3, pp. 90–95, 2007.
[67] C. Raffel et al., “mir_eval: A Transparent Implementation of Common MIR Metrics,” Proceedings of the 15th International Conference on Music Information Retrieval, 2014.
[68] C. Févotte, R. Gribonval, and E. Vincent, “BSS_EVAL Toolbox User Guide – Revision 2.0,” Technical Report, 2005.
[69] M. Abadi et al., “TensorFlow: A system for large-scale machine learning,” in 12th usenix symposium on operating systems design and implementation (osdi 16), 2016, pp. 265–283.
[70] E. Vincent et al., “The Signal Separation Evaluation Campaign (20072010): Achievements and Remaining Challenges,” Signal Processing, vol. 92, no. 8, pp. 1928–1936, Aug. 2012.
[71] E. Vincent, H. Sawada, P. Bofill, S. Makino, and J. P. Rosca, “First Stereo Audio Source Separation Evaluation Campaign: Data, Algorithms and Results,” in Independent component analysis and signal separation, 2007, pp. 552–559.
[72] C. H. Taal, R. C. Hendriks, R. Heusdens, and J. Jensen, “A short-time objective intelligibility measure for time-frequency weighted noisy speech,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 2010.
[73] A. W. Rix, J. G. Beerends, M. P. Hollier, and A. P. Hekstra, “Perceptual evaluation of speech quality (PESQ)-a new method for speech quality assessment of telephone networks and codecs,” in IEEE international conferenceon acoustics, speech and signal processing (icassp), 2001.
[74] J. Chung, Çaglar Gülçehre, K. Cho, and Y. Bengio, “Empirical evaluation of gated recurrent neural networks on sequence modeling,” Dec. 2014.


RGB SLIDER
Blink LED
Reset LED
E.g ws://<IP_ADDRESS>:81/
X-axis:
Listen to X-axis value
Change R value
Y-axis:
Listen to Y-axis value
Change G value
Z-axis:
Listen to Z-axis value
Change B value
R
0
G
0
B
0
Author: Rahul Credits: 1.Markus Sattler [https://github.com/Links2004] 2.Martin [http://www.instructables.com/member/martin2250/]


Discussion of the goals and challenges in redesigning this site.
Some key points for understanding basic Regex.
Exploring some differences between the "older" and "newer" types of databases.
An introduction to Procs, Blocks and lambdas in Ruby.
Some practice with Ruby classes and instance variables through a poker example.
Let's take a look at Ruby's #group_by method, a member of the Enumerable family.
Once and for all, I break down the subtle differences between these three web design attributes.
An important lesson I learned about asking technical questions.
I recount a conflict I had with a college instructor.
A time of self-reflection and why good health is of utmost importance.
Fight back against the fear of confirming negative stereotypes by becoming aware of it.
Pair programming is big at Dev Bootcamp. Here are some things I like, and some things I don't like about it.
Ever think about how you solve problems or view the world? We aren't all the same.
DBC Co-Founder Shereef Bishay provides an inside look into the "kitchen".
This project has been my creative outlet and novel technical challenge for the last couple of months. The app allows iOS users to make a profile and communicate with each other over Bluetooth Low Energy. Please check out the demo video in the link to see the current progress. I'm writing the native app in Objective-C with a Rails API to handle user authentication. I hope to one day offer it in the app store as a nearby social connection solution.
Standup allows for collaborative preparation and participation in meetings. Before and during a meeting, all members can contribute to the agenda by posting and voting on topics. After a meeting is closed, all meeting members receive a summary email and access to an archived version of the meeting. We built Standup in eight days using Ruby on Rails for the backend, and jQuery, AJAX, HTML and CSS for the front-end. Our app is tightly coupled with Google (Calendar and Contacts APIs) for user convenience. We accomplished rapid live page updating with Faye Websockets running on a separate Heroku app. We have a Sidekiq worker process and a Redis server to speed up contact caching and emailing (SendGrid)
You Owe Me Homie lets you track debit and credit between members of a customized group. Recipients must confirm each transaction before the app factors it into calculations. Users can view histories of confirmed, pending, and denied transactions between any two members. We built You Owe Me, Homie in five days using test driven development, Rails for the backend and jQuery, AJAX, HTML and CSS for the front.
A Sinatra app that accepts a data file depicting menu items, prices, and a target price. Upon upload, the app displays the menu, along with a list of all possible combinations adding up exactly to the target price specified. This was an exercise in NP-Complete algorithms and data validation.
An object-oriented JavaScript game against the computer, which was programatically proven to win in every scenario (see Github for details). But, you can try to beat it anyway.
Cache Only was a single-day project that we built to better understand file uploading to Amazon S3 in a Sinatra app. Our goal was to create an app for a user to upload a file, and then receive a download link that destroyed the file once downloaded. Check it out!
A simple web game using JavaScript. Happy hunting!


--- title: calcError sidebar: function_reference_sidebar permalink: PoleFigure.calcError.html folder: function_reference toc: false ---
RP and mean square error
calcError(pf,rec) calculates reconstruction error between meassured intensities and the recalcuated ODF or between two meassured pole figures. It can be specified whether the RP error or the mean square error is calculated. The scaling coefficients are calculated by the function PoleFigure/calcNormalization
| pf,pf2 | PoleFigure |
| rec | SO3Fun |
| e | error |
| RP | RP value (default) |pfmeas - pfcalc|./ pfcalc |
| l1 | l1 error |pfmeas - pfcalc| |
| l2 | l2 error |pfmeas - pfcalc|.^2 |
SO3Fun.calcError PoleFigure.calcNormalization PoleFigure.scale


I’ve been watching some great RubyConf talks recently, and Matz (creator of Ruby) is always fun to watch. He went over some new features in Ruby 2.3.0, so I thought I’d re-report them here for everyone. This is the talk I got them from.
Enumerable#grep_v
grep
is a Unix command for pattern matching. For example, if I wanted to check my history for a recent ssh IP address, I could try something like:
So grep -v
is the inverse - you’ll get all the results that don’t match. I am imagining it is used like so:
Hash#fetch_values
Stricter version of Hash#values_at. Check out the feature request here.
Numeric#positive? Numeric#negative?
Longer than > 0
!
Hash comparisons: <=, <, >=, >
This seems odd, but it A >= B
is another way of asking if hash A contain all of B and possibly more.
Hash#to_proc
Here’s an example straight from the talk:
Did-you-mean
Just a ruby interpreter helper for typos on methods. Doesn’t seem very useful to me.
 This frees up space or something. Feels inconvenient, so I hope the gains are worth it!
Safe navigation with &.
Look, it’s a guy sitting on the floor staring at a dot! The ‘lonely operator’! This one is really useful:
Beautiful.
Array, Hash#dig
This is also another very useful feature in Ruby 2.3. It’s unsafe to check arrays or hashes at depth for values if you aren’t sure they’ll be there, because you’ll get an error once a nil comes up. Now, there’s a safe dig
method available, and it’s not unsimilar to the aforementioned &.
:
Another really common need, at least for me, is the opposite of this dig
which I’m calling bury
. I actually tweeted to @Matz about this feature request and posted to the Ruby lang redmine forum thing. bury
allows you to insert an object at an arbitrary depth into an array or hash:
My feature request actually got a few comments!


Control all your switches from this hub by waving left and right to select a switch, and closing your fist to switch it off, and releasing to switch it on!
Select between different modes to apply to your house!


Reports non-string literals that are used as bundle property key.
This is hard to maintain. It is better to pass around already resolved natural language strings.
Example:
val key =
if (???) "property.key.1"
else "property.key.2"
Bundle.message(key)
Use instead:
val string =
if (???) Bundle.message("property.key.1")
else Bundle.message("property.key.2")
string


Interplay between computation and economics. Topics in electronic commerce, computational social choice, computational mechanism design, peer production, prediction markets and reputation systems. Readings in AI, theoretical CS, multi-agent systems, economic theory, and operations research.
Scaling computation over parallel and distributed computing systems is a rapidly advancing area of research receiving high levels of interest from both academia and industry. The objective can be for high-‐performance computing and energy-‐efficient computing (“green” data center servers as well as small embedded devices). In this course, students will learn principled methods of mapping prototypical computations used in machine learning, the Internet of Things, and scienti
The contents and course requirements are similar to those of Computer Science 144r, with the exception that students enrolled in Computer Science 244r are expected to do substantial system implementation and perform graduate-level work.
The contents and course requirements are similar to those of Computer Science 146, with the exception that students enrolled in Computer Science 246 are expected to undertake a substantial course project.
Seminar course exploring recent research in computer architecture. Topics vary from year to year and will include subjects such as multi-core architectures, energy-efficient computing, reliable computing, and the interactions of these issues with system software. Students read and present research papers, undertake a research project.
The contents and course requirements are similar to those of Computer Science 148, with the exception that students enrolled in Computer Science 248 are expected to do a substantial design project and paper discussions on advanced topics.
 The central theme is the view of programs and languages as formal mathematical objects about which precise claims may be made and proved. Particular topics include operational techniques for formal definition of language features, type systems, and program logics. The models and proofs are formalized using mechanical theorem provers.
Seminar course exploring recent research in programming languages. Topics vary from year to year. Students read and present research papers, undertake a research project.
Modern software systems construction and analysis. Distributed systems; operating systems; networks; data centers; big data; emerging systems deployments. Close, careful reading of research papers and code, coupled with programming projects. Readability and programmability. Topic focus will change each offering. May be repeated for credit with instructor permission.
An introduction to operating systems research. Paper-based seminar course that introduces students to the state of the art in systems research through historical and quantitative lenses. Students will read and discuss research papers and complete a final research project.
An examination of the special problems associated with distributed computing such as partial failure, lack of global knowledge, asynchrony and coordination of time, and protocols that function in the face of these problems. Emphasis on both the theory that grounds thinking about these systems and in the ways to design and build such systems.
This course explores practical attacks on modern computer systems, explaining how those attacks can be mitigated using careful system design and the judicious application of cryptography. The course discusses topics like buffer overflows, web security, information flow control, and anonymous communication mechanisms such as Tor. The course includes several small projects which give students hands-on experience with various offensive and defensive techniques; the final, larger project is open-end
Big data is everywhere. A fundamental goal across numerous modern businesses and sciences is to be able to exploit as many machines as possible, to consume as much information as possible and as fast as possible. The big challenge is "how to turn data into useful knowledge". This is far from a simple task and a moving target as both the underlying hardware and our ability to collect data evolve. In this class, we will discuss how to design data systems and algorithms that can "scale up" and "sca
Advanced seminar in computer graphics focusing on geometric representations and processing. Topics include: subdivision surfaces, surface parametrization, vector fields over surfaces, shape editing, shape matching and surface reconstruction.
Advanced course in computer graphics focusing on image rendering and processing. Topics include: light transport, efficient rendering, image based rendering, texture processing, interactive image processing.
The course covers major areas of inquiry and core research methods in Human-Computer Interaction including experimental design, statistical data analysis, and qualitative methods. Activities will include discussion of primary literature, a small number of lectures, assignments (design, execution and analysis of both lab-based and on-line experiments), and a research project. Special focus this year is on social computing and crowd-powered systems. Specifically, we will look at the design and ana
Seminar course exploring research directions in artificial intelligence (AI), typically combining two or more of such areas as multi-agent systems, natural-language processing, machine learning, reasoning under uncertainty, representation systems. Topic for Spring 2017: Multi-agent systems: collaboration, coordination and loosely-coupled teamwork.
Advanced statistical machine learning and probabilistic data analysis. Topics include: Markov chain Monte Carlo, variational inference, Bayesian nonparametrics, text topic modeling, unsupervised learning, dimensionality reduction and visualization. Requires a major final project.
The focus of the Spring 2015 course will be reinforcement learning, a framework for solving problems involving a sequence of decisions with uncertain outcomes. This course will cover the fundamental theory through readings of classic papers and build practical intuition through coding assignments. Topics will include Markov decision process and partially observable Markov decision processes, planning under uncertainty, model-free and model-based reinforcement learning, function approximation in
Vision as an ill-posed inverse problem: image formation, two-dimensional signal processing; feature analysis; image segmentation; color, texture, and shading; multiple-view geometry; object and scene recognition; and applications.
Computational methods have revolutionized the way we control the motions of complex, nonlinear, and underactuated robots. In this course, we study a variety of optimization algorithms for designing and stabilizing trajectories for walking, manipulating, and flying systems. Topics will include optimal control (HJB and Pontryagin’s minimum principle), nonlinear optimization, trajectory planning (shooting and direct methods) and stabilization, model-predictive control, legged systems (classic
Algorithmic, game-theoretic and logical foundations of multi-agent systems, including distributed optimization and problem solving, non-cooperative game theory, learning and teaching, communication, social choice, mechanism design, auctions, negotiation, coalitional game theory, logics of knowledge and belief, collaborative plans and social systems.
Focuses on statistical and machine learning approaches to natural language processing. Methods include log-linear models, hidden Markov models and conditional random fields, expectation maximization, and neural networks. Natural language topics include language modelling, tagging and information extraction, syntactic parsing, and machine translation. As part of the course, students will also undertake a final research project.
Seminar course exploring recent research in computer vision. Topics vary from year to year, typically including object recognition; activity recognition; and visual surveillance. Students read and present research papers and undertake a research project.
Surveys biologically-inspired approaches to designing distributed systems. Focus is on algorithms, analysis, and programming paradigms. Topics: swarm intelligence, amorphous computing, immune-inspired systems, synthetic biology. Discussion of research papers and a research project required.
This course introduces first year Computer Science PhD students to the CS colloquium series. Required for G1 PhDs in CS.
This course introduces first year Computer Science PhD students to the CS colloquium series. Required for G1 PhDs in CS.
Supervision of experimental or theoretical research on acceptable computer science problems and supervision of reading on topics not covered by regular courses of instruction.
Supervision of experimental or theoretical research on acceptable computer science problems and supervision of reading on topics not covered by regular courses of instruction.


B.A., Visual Communication, Graphic Design
Coordinated opening events, lead sales, installation and removal.
Designed and produced events based signage from initial concept to final release across all markets and languages. Developed and maintained merchandising style guide and editable collateral for external use by vendors. Primary creator and contact for maintenance of The Home Depot’s visual merchandising standards.
Worked exclusively for The Home Depot’s visual merchandising department. Created innovative retail signage from the ground up across multiple brands for Home Depot stores. Interacted regularly with clients, vendors, creative partners and other team members as needed for completion of assigned projects. Developed initial production ready templates. Managed projects with up to 20 concurrent deadlines, with each consistently on-time and under budget. Communicated across all departments to create a strong and cohesive brand experience.
Works across multiple marketing outlets to design engaging collateral. Creates dynamic advertisements which boast over 60,000 unique weekly visitors. Boosted engagement and reduced drop-off by creating a more user friendly, responsive advertising layout. Creates social media skins and posts for use in events and sports marketing. Orders photography and works in tandem with agency partners, to ensure the most current and appealing display of merchandise.
From quick engagements like logo design to full brand strategy, I'm ready to tackle the creative problems that are at the heart of building engaging, powerful brands.
If you've been in a big box store, chances are you've seen my work. Whether it's a unique special installation project or a point of sale design across an entire chain, my work has passed the test.
Having just completed General Assembly's User Experience Design course, I'm design focused, data driven and ready to learn more.
Graphic Designer
Based in Atlanta, GA, I enjoy making things, exploring trails and spoiling my dog Judy, and my cat Lizzie.
I work hard and care deeply about my projects. I'd love to learn more about what you're working on and see how I can help.


About Me
Current Residence: New York, NY
Interests
Education
Santa Monica High School
Class of 2002
...
Bard College
Class of 2006
...
Dev Bootcamp
Purple Martins Cohort
Class of 2015
Fun Fact
I hiked and traveled all over Japan one summer. In Hiroshima, I found a building with over 50 Okonomiyaki stalls all on one floor!


{% extends "base.html" %} {% load static %} {% block title %}Write for Hello Web Books - {{ block.super }}{% endblock %} {% block analytics %} analytics.page("Write"); {% endblock %} {% block content %}
I started writing Hello Web Books because I wanted smaller, friendlier books for tech folks. No giant behemoth tomes — something small, fun, and easy to pick up.
I've learned so much after self-publishing three books. Book design, book production, eBook conversion, how to get on Amazon, how to set up a fulfillment warehouse, sales, marketing, you name it. And I've been thinking it's a shame that I can't help others with this knowledge.
Thinking of writing a book? Let's see about working together!
What does book publishing entail? Here's my process, which I would likely adapt for someone who's working with me (with flexibility):
Ideally we'd run a Kickstarter campaign for the book to determine viability and to get pre-orders/initial marketing for the book (don't worry, I will coordinate everything for the campaign for you!) From there, you'll get your advance and we'll coordinate a much, much, much higher percentage than traditional publishers for royalties.
I have to coordinate and cover production costs, but my goal is for the majority of profits from your book to go straight to you.
Send me an email at<EMAIL_ADDRESS>We can start chatting topics and answer any questions you have. I also have a book proposal document for you to fill out when you're ready to propose a topic.
I hope to work with you!


|
Border Survillence Bot Group V
An attempt to omplement border survillence using Firebird-V robot using Python.
|
#include "winavr_firebird.h"
Go to the source code of this file.
Functions | |
| void | init_devices () |
| int | main (void) |
Variables | |
| unsigned char | data |
Written by: Group 5:
HARISH 8005052 SAMEER 8005056 RAJESH 8005041 PRADEEP 8005044
AVR Studio Version 4.17, Build 666
Application example: Robot control over serial port
Concepts covered: serial communication
Serial Port used: UART1
There are two components to the motion control: 1. Direction control using pins PORTA0 to PORTA3 2. Velocity control by PWM on pins PL3 and PL4 using OC5A and OC5B.
In this experiment for the simplicity PL3 and PL4 are kept at logic 1.
Pins for PWM are kept at logic 1.
Connection Details:
Motion control: L-1---->PA0; L-2---->PA1; R-1---->PA2; R-2---->PA3; PL3 (OC5A) ----> Logic 1; PL4 (OC5B) ----> Logic 1;
Serial Communication: PORTD 2 --> RXD1 UART1 receive for RS232 serial communication PORTD 3 --> TXD1 UART1 transmit for RS232 serial communication
PORTH 0 --> RXD2 UART 2 receive for USB - RS232 communication PORTH 1 --> TXD2 UART 2 transmit for USB - RS232 communication
PORTE 0 --> RXD0 UART0 receive for ZigBee wireless communication PORTE 1 --> TXD0 UART0 transmit for ZigBee wireless communication
PORTJ 0 --> RXD3 UART3 receive available on microcontroller expainsion board PORTJ 1 --> TXD3 UART3 transmit available on microcontroller expainsion board
Serial communication baud rate: 9600bps
This experiment enables the user to control the robot motion through Serial Comunication from the PC Wirelessly.
Byte Commands for respective direction are as Follows:
0x51 -----> FORWARD 0x52 -----> BACKWARD 0x53 -----> LEFT 0x54 -----> Right 0x50 -----> Stop
Note:
1. Make sure that in the configuration options following settings are done for proper operation of the code
Microcontroller: atmega2560 Frequency: 11059200 Optimization: -O0 (For more information read section: Selecting proper optimization options below figure 4.22 in the hardware manual)
2. Difference between the codes for RS232 serial, USB and wireless communication is only in the serial port number. Rest of the things are the same.
3. For USB communication check the Jumper 1 position on the ATMEGA2560 microcontroller adaptor board
*******************************************************************************
Copyright (c) 2010, NEX Robotics Pvt. Ltd. -*- c -*- All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.
Source code can be used for academic purpose. For commercial use permission form the author needs to be taken.

Software released under Creative Commence cc by-nc-sa licence. For legal information refer to: http://creativecommons.org/licenses/by-nc-sa/3.0/legalcode
Definition in file main.c.
| void init_devices | ( | ) |
Function To Initialize All The Devices
Initializes all the ports
Initailize UART0 for serial communiaction
timer0 interrupt sources
timer1 interrupt sources
timer2 interrupt sources
timer3 interrupt sources
timer4 interrupt sources
timer5 interrupt sources
Enables the global interrupt


rt-props
rt-props is used to inject properties into an element programmatically.
It will merge the properties with the properties received in the template.
This option allows you to build properties based on external logic and pass them to the template.
It is also useful when passing properties set on the component to an element within the template.
The expected value of this attribute is an expression returning an object.
The keys will be the property name, and the values will be the property values.
Online documents
Sample:
<input style="height:10px;width:3px;" rt-props="{style:{width:'5px'},type:'text'}"/>
Compiled:
define([
'react',
'lodash'
], function (React, _) {
'use strict';
return function () {
return React.DOM.input(_.merge({}, {
'style': {
height: '10px',
width: '3px'
}
}, {
style: { width: '5px' },
type: 'text'
}));
};


01 Jan 2013
I’ve had my Mac scripts dotted around my Macs over the years, so after spending twenty minutes looking for my script to add a login item to a user, I decided to put them all in one place on GitHub. Hopefully someone will find them useful, I’ll be adding the rest as soon as I work out where I put them.
MacScripts on GitHub
15 Dec 2012
I’ll preface this with one thing - I’m not a Casper Suite expert. I don’t use it reguarly, and at what it costs, I probably won’t! It’s this price that gave me high expectations for this last install. Unfortunately they were unfounded.
I’m hoping to write a series of articles comparing the various aspects of Casper against the free tools I use every day. First up is DeployStudio.
Workflow creation
Both Casper Imaging and DeployStudio have a nice GUI for creating the workflow. It’s just a drag and drop to place the tasks you need. The DeployStudio interface feels a bit more polished, but that’s probably just my bias showing though. The only real differentiator here are the package groups that DeployStudio offers. If you had a standard group of packages that you deploy over several different workflows, DeployStudio makes it easy to maintain - yes, this should probably be done elsewhere, but it can be handy to install a certain set of applications at imaging time. I couldn’t see a direct replacement for this in Casper Imaging.
Winner: Draw (just! if pushed, I’d say DeployStudio just edged it)
NetBoot
This is where DeployStudio really starts to poop on Casper Imaging from a great height. With Casper, the chap doing the jump start told me that I had to manually build up a NetBoot image with Casper Imaging set up. Hilarious. Surely he was joking, right? No. DeployStudio, a free product, has a wizard for making a customised NetBoot set that offers an iTunes like interface that is so simple, I’ve regularly taken an office manager through imaging a Mac. I dread to think how that same person would cope with the random UI elements that have been thrown at the screen when making the casper imaging app.
Winner: DeployStudio, hands down. Casper didn’t even turn up
Imaging process
So, you’ve managed to get past the lovely Casper Imaging interface, and now you’re installing a package that’s best installed when running from the target system - like an Adobe CS package. One that is likely to be the biggest package you’re installing. With DeployStudio, you at least get some indication that something is happening - you have the log scrolling by in the background.  No idea if it’s going to take five minutes or two hours.
Winner: DeployStudio
I’ll finish this post with an admission: I don’t use DeployStudio either. I’ve been trying to get rid of OS X in my server rooms, so as I mentioned in my last post, we’re using JAMF’s NetSUS appliance (dear JAMF, why can you make an awesome free product like NetSUS, but your flagship product be so poor?) and NetRestore with a InstaDMG made image with just an OS and a package to hook it into Puppet. I chose to compare Casper Imaging with DeployStudio as they’re closer competitors than the one trick pony of NetRestore.
12 Dec 2012
A few months ago, we decided to move away from DeployStudio for imaging our Macs to reduce the OS X footprint in the server room (a plain old NetRestore can be run from NetSUS). This left us with a problem - how are we going to name our Macs now (a task previously performed by DeployStudio)?
Enter MacNamer. It’s usage and installation is detailled in the Readme file, please fork, try to break, file pull requests. This has been in production for several months at work, but I’m sure someone will manage to make it break!
12 Nov 2012
Maintaining visibility over your fleet of machines is always difficult. It’s even more difficult when you’ve got Macs. It gets nearly impossible when you decide you’d like something hosted in the cloud.
We’ve been looking for a good solution for ages now - we even resorted to using OCS Inventory for a while. We then discovered Meraki’s Systems Manager.
This isn’t going to be one of those fancy review type things - you can go and look at it’s features yourself. This is more an overview of the factors that came into our decision:
##Pros
* It’s cloud based! No servers for us to deploy, no VPNs between sites for clients to communicate over
* It does basic iOS MDM. It’s not the best in the world, but it does a lot of what we wanted (basically configuring email and Wi-Fi settings)
* It has SSH over the Internet. If all else fails, we have a way into a machine, no matter where it is.
* It’s free! It’s hard to argue with a price like that!
Cons
- It’s free!  My home network is in Sheffield apparently. We supposedly have clients in Bath (we don’t).
- It’s not particuarly customisable. With Puppet, Facter, Puppet Dashboard and the inventory service configured, you can pull out practically any information you require (for example, we have a Fact that tells us if there are any admin users on a Mac other than our own).
Summary
For what it does, Meraki Systems Manager is hard to beat. If you need more than basic system information, or something that runs on Linux, you’re going to need to look elsewhere. It’s a great compliment to Puppet Inventory, but it’s not a total replacement.
21 Sep 2012
This post could also be called “Things we could learn from our developer brethren, but I digress, to the list! (Lists are awesome, aren’t they?)
I’m not going to try and tell you how to get started with Git (go here instead for that), I’m merely going to get on my soapbox.
- Branches - need to test something? No need to spend all day making a test setup, just make a branch and clone it to the test server. If it turns out that I wasn’t mad and my changes were a good idea, they can be merged back into the main branch just as easily.
- Accountability - who made that strange config change? A quick look at the commit history is all you need.
- Diff - what actually changed? It’s easy to see the exact changes
- Change history - why was that random change even made? Hopefully it’s in the commit message! (Your commit messages are useful, aren’t they?!)
- You can be a nice sysadmin - if you use GitHub it’s simple to take your repo public and share your awesomeness.
So there you go - I hope this goes some way to answering the question “why shuold I be using Git?”


Weather Dashboard
Welcome to your weather dashboard.
Where Ya Going?
Input City Name Here
Previous Searches
Here is your Forecast For:
UV Index:


Septi Fazriyanti
Menu
Home
About
Education
Skills
Education & Certificate
this is my education and the certificate that I have achieved.
Education & Certificate
Tech Muda Nurul Fikri
Web Development
July 2019 - August 2019
SMKN 6 Kota Bekasi
Rekayasa Perangkat Lunak
July 2018 - May 2018
Certificate Web Development
Nurul Fikri Computer (IT Solution)
July 2019 - August 2019
Lembaga Sertifikasi Profesi
Badan Nasional Sertifikasi Profesi
July 2019 - August 2019
Certificate Of Accomplishing
English Club
May 2017


This is my Portfolio.
Click on the links.
This example uses the ng-view directive as an attribute to a DIV element.


| I l@ve RuBoard |
4.1 "Splits and Joins and Alien Invasions"This chapter and the next continue our look at the system utilities domain in Python. They present a collection of larger Python scripts that do real systems work -- comparing and copying directory trees, splitting files, searching files and directories, testing other programs, configuring program shell environments, launching web browsers, and so on. To make this collection easier to absorb, it's been split into a two-chapter set. This chapter presents assorted Python system utility programs that illustrate typical tasks and techniques in this domain. The next chapter presents larger Python programs that focus on more advanced file and directory tree processing. Although the main point of these two case-study chapters is to give you a feel for realistic scripts in action, the size of these examples also gives us an opportunity to see Python's support for development paradigms like OOP and reuse at work. It's really only in the context of nontrivial programs like the ones we'll meet here that such tools begin to bear tangible fruit. These chapters also emphasize the "why" of systems tools, not just the "how" -- along the way, I'll point out real-world needs met by the examples we'll study, to help you put the details in context. One note up front: these chapters move quickly, and a few of their examples are largely just listed for independent study. Because all the scripts here are all heavily documented and use Python system tools described in the prior two chapters, I won't go through all code in detail. You should read the source code listings and experiment with these programs on your own computer, to get a better feel for how to combine system interfaces to accomplish realistic tasks. They are all available in source code form on the book's CD-ROM (view CD-ROM content online at http://examples.oreilly.com/python2), and most work on all major platforms. I should also mention that these are programs I really use -- not examples written just for this book. In fact, they were coded over years and perform widely differing tasks, so there is no obvious common thread to connect the dots here. On the other hand, they help explain why system tools are useful in the first place, demonstrate larger development concepts that simpler examples cannot, and bear collective witness to the simplicity and portability of automating system tasks with Python. Once you've mastered the basics, you'll probably wish you had done so sooner. |
| I l@ve RuBoard |


| GTK+ 3 Reference Manual |
|---|
gtk-launchgtk-launch — Launch an application |
gtk-launch
[APPLICATION] [URI...]
gtk-launch launches an application using the given name. The application is started with proper startup notification on a default display, unless specified otherwise.
gtk-launch takes at least one argument, the name of the application to launch. The name should match application desktop file name, as residing in /usr/share/application, with or without the '.desktop' suffix.
If called with more than one argument, the rest of them besides the application name are considered URI locations and are passed as arguments to the launched application.


The office is open from 7am-7pm, Monday-Friday. Some employees may have access to the office outside of this window, but it's only for extreme circumstances (like software failure that needs immediate attention). Most employees, unless otherwise discussed, have a certain degree of discretion over the hours they work. To ensure there is ample overlapping time for teammates to work together, the hours you choose should include the hours of 10am-4pm (with the exception of a reasonable lunch break).
For example, let's say you're expected to work 40 hours per week, the equivalent of 8 hours per day. If you're a morning person, you may want to work from 7am-4pm with a one-hour lunch break. If you really dislike mornings, 10am-7pm might be more desirable. Most employees fall somewhere in-between.


My First Project
This first project is personalised to myself, which includes my entry coding skills, I can take any PSD picture and code it up into the latest HTML and CSS.
Lets code up a cool website for your company from scratch!
Our Mission is to build websites you always dreamed of, to take your dream into reality, build a website with the most advanced modern coding language.
This first project is personalised to myself, which includes my entry coding skills, I can take any PSD picture and code it up into the latest HTML and CSS.
This 2'nd project took me a lot of time to figure out how to put all sections into place. The frame around, colours and fonts are coded with HTML and CSS. I didn't aim for any special colours or design, the main goal was to put different fonts and sizes in the middle of a sentence.
This mock website presents a truck which sells natural ingredients straight from the farm, I did it in a coding class, I copied it from a PSD picture and code it up into a website, I changed the style, and pictures, plus I add some more pages to make it unique!
Providing you with all the tools your team should be able to recharge, having a week without wifi, to make stronger the relationship between your team members up to 65 people, so your company or team can succeed outside our retreat.
See the current time RIGHT NOW,
The LOLCat Clock delivers a message based on the time of day, a different message for the morning, afternoon, evening, or party time.
Magic 8-Balls are a fortune-telling device to tell a person's future. Ask the ball any yes or no questions about some future event, It responds with a mysterious, somewhat applicable answer.
There are two candidates running for president. Each state has a set number of votes, you can display who the winner is by mousing over that state, and the tables will reflect these results.
I worked with a number of programs in different industries, including online selling, listing products, stocking systems, etc. where HTML came to help on the go.
Now I switch fully into web development, I take PSD designs and code them into clean, semantic HTML5, and the most up-to-date modern CSS.
Working with spreadsheets, docs, and Adobe Photoshop, help me a lot, e.g. calculations, to keep to my business goals and much more.
I use my technical skills for online selling, to sell more professionally online, like Amazon and Ebay, etc. which helps my building more skills on the work.
I keep learning from other successes, including reading, watching instructional video guides or courses, etc.


PFIZER IN $82.4 BILLION HOSTILE BID TO BREAK UP MERGER OF DRUG
COMPANIES
Hours after executives of American Home Products Corp. and
Warner-Lambert Co. announced a $70 billion merger agreement
Thursday, Pfizer Inc. tried to break the deal up with an $82.4
billion hostile bid for Warner-Lambert.
Stock analysts who follow the pharmaceutical industry said
Thursday night that a still-higher offer could emerge for
Warner-Lambert, either from American Home or Pfizer, or even from
another drug company. Warner-Lambert's board met Thursday night and
reaffirmed its commitment to American Home, saying that the terms
of Pfizer's offer, which call for the elimination of a $2 billion
payment agreed to by Warner-Lambert and American Home if one
company backed out of their deal, made the bid difficult to
evaluate.
Warner-Lambert is considered a prize within the industry because
of its blockbuster products, including the cholesterol-fighting
drug Lipitor marketed jointly with Pfizer, and its many other
treatments under development.
Competition has become intense among the world's largest drug
makers to ensure a pipeline of lucrative breakthrough drugs _
compounds that are billion-dollar sellers and control a commanding
share of the market. Companies also need to replace drugs losing
patent protection, which become vulnerable to cheaper generic
products, and want to amass bigger research budgets in the hope of
generating highly successful drugs.
Pfizer's bid for Warner-Lambert shatters all such records in the
industry. The $82.4 billion offer is, in fact, the biggest hostile
bid ever made for any company, and the deal, if completed, would be
one of the largest of any sort.
If Pfizer were to acquire Warner-Lambert, it would be by far the
biggest drug company. Astra Zeneca, now the world's largest, had
$10.68 billion in worldwide prescription drug sales last year and
4.2 percent of the market.
Pfizer and Warner-Lambert would have $15.9 billion in sales and
a 6.3 percent share. Drug-stock analysts said that because Pfizer
would have a relatively small share of a splintered market, and
because the companies had little overlap, antitrust issues were not
expected to be a factor in completing a deal.
If, on the other hand, Warner-Lambert were to complete its
friendly merger with American Home Products, the combined
AmericanWarner would still be the biggest drug company, but with
sales of $13.8 billion and 5.5 percent of the total market.
It is unclear how Warner-Lambert's 43,000 employees, 3,000 of
whom work in New Jersey, would fare in a Pfizer acquisition. Some
analysts said Pfizer would probably close Warner-Lambert's
headquarters in Morris Plains, N.J., and cut other jobs from the
company's confectionary or manufacturing divisions. Pfizer, which
is based in New York City, has 46,400 employees spread worldwide.
The company said Thursday that it expected $1.2 billion in cost
savings once the acquisition was completed.
Analysts said some jobs at Warner-Lambert's headquarters would
almost certainly be eliminated if it merged with American Home. At
their news conference, the companies' executives announced that
AmericanWarner would be based in American Home Products' corporate
center in Madison, N.J.. But they declined to specify how many jobs
might be lost. They estimated cost savings of $1.2 billion
annually.
nn
Pfizer's bid leaves American Home Products in a potentially
vulnerable position. When announcing the deal with Warner-Lambert,
American Home's chief executive said his third attempt at a merger
would be a charm. Previous agreements between American Home and
SmithKline Beecham and Monsanto fell apart over conflicts on who
would have executive control. Though that matter had apparently
been worked out with Warner-Lambert, the issue may not be so easily
resolved now.
As evidence of the uncertain fortunes for American Home, its
stock price fell Thursday, even though the company had become an
acquisition target, something that would normally push up a
company's stock price. Investors seemed to wonder whether it could
fetch a premium over its current price.
Stock analysts said Thursday that it could be months before any
merger deal is finalized for any of the companies involved. Several
European companies _ including Glaxo Wellcome and Novartis _ have
long been seen as possible acquirers in the industry, especially if
they can increase their prescription drug sales in the United
States.
``When it comes to figuring out which company may make an
acquisition, you can play chessboard here to your heart's
content,'' said Viren Mehta, a partner at Mehta Partners, a
biopharmacological research firm in New York. ``It's hard to
identify specific large companies that would not feel compelled to
go in this round.''
Even though Pfizer's executives expressed confidence Thursday
that their bid would be successful, questions remained. American
Home Products and Warner-Lambert agreed that ending their merger
would cost $2 billion to the party backing out, and they included a
clause in the contract making an exchange of shares difficult for
another company.
Upon making its offer, Pfizer immediately filed a lawsuit in
Delaware, where most big companies are incorporated, contesting the
$2 billion break-up fee. William Steere, Pfizer's chairman, said
Thursday in an interview that Pfizer's offer was contingent on both
roadblocks being removed. He called the break-up fee ``egregious
and unheard of'' for a deal of that size.


Powerful photo-analysis API
Dog photos
-
$50
Monthly -
40GB of data
-
2000 request each day
People photos
-
$100
Monthly -
500GB of data
-
20000 request each day
-
24/7 email and live support
Food photos
-
$150
Monthly -
150GB of data
-
100000 request each day
Not sure what do you want?
Looking for something more crunchy?
Shared Hosting
Share your host with someone you have no idea who they are (such as your competitor)! Enjoy!
Shared Hosting
Share your host with someone you have no idea who they are (such as your competitor)! Enjoy!
Shared Hosting
Share your host with someone you have no idea who they are (such as your competitor)! Enjoy!
Shared Hosting
Share your host with someone you have no idea who they are (such as your competitor)! Enjoy!
Shared Hosting
Share your host with someone you have no idea who they are (such as your competitor)! Enjoy!
Shared Hosting
Share your host with someone you have no idea who they are (such as your competitor)! Enjoy!
We are Always here to help.
- 24-hour online customer-service.
- Our highly-trained support staff are ready to assist you with all manner of issues.
- They are knowledgable and understanding.
- You should be able to reach out with them through online chat.
- You can also email them for help.
Happy Customers
Small Apple is the best service provider out there, love it!


Back after a pretty lengthy intermission! Today I want to talk about Kubernetes. I’ve recently had some clients that have been interested in running Docker containers in a production environment and, after some research and requirement gathering, we came to the conclusion that the functionality that they wanted was not easily provided with the Docker suite of tools. These are things like guaranteeing a number of replicas running at all times, easily creating endpoints and load balancers for the replicas created, and enabling more complex deployment methodologies like blue/green or rolling updates.
As it turns out, all of this stuff is included to some extent or another with Kubernetes and we were able to recommend that they explore this option to see how it works out for them. Of course, recommending is the easy part, while implementation is decidedly more complex. The desire for the proof of concept was to enable multi-cloud deployments of Kubernetes, while also remaining within their pre-chosen set of tools like Amazon AWS, OpenStack, CentOS, Ansible, etc.. To accomplish this, we were able to create a Kubernetes deployment using Hashicorp’s Terraform, Ansible, OpenStack, and Amazon. This post will talk a bit about how to roll your own cluster by adapting what I’ve seen.
Why Would I Want to do This?
This is totally a valid question. And the answer here is that you don’t… if you can help it. There are easier and more fully featured ways to deploy Kubernetes if you have open game on the tools to choose. As a recommendation, I would say that using Google Container Engine is by far the most supported and pain-free way to get started with Kubernetes. Following that, I would recommend using Amazon AWS and CoreOS as your operating system. Again, lots of people using these tools means that bugs and gotchas are well documented and easier to deal with. It should also be noted that there are OpenStack built-ins to create Kubernetes clusters, such as Magnum. Again, if you’re a one-cloud shop, this is likely easier than rolling your own.
Alas, here we are and we’ll search for a way to get it done!
What Pieces are in Play?
For the purposes of this walkthrough, there will be four pieces that you’ll need to understand:
- OpenStack - An infrastructure as a service cloud platform. I’ll be using this in lieu of Amazon.
- Terraform - Terraform allows for automated creation of servers, external IPs, etc. across a multitude of cloud environments. This was a key choice to allow for a seamless transition to creating resources in both Amazon and OpenStack.
- Ansible - Ansible is a configuration management platform that automates things like package installation and config file setup. We will use a set of Ansible playbooks called KubeSpray Kargo to setup Kubernetes.
- Kubernetes - And finally we get to K8s! All of the tools above will come together to give us a fully functioning cluster.
Clone KubeSpray’s Kargo
First we’ll want to pull down the Ansible playbooks we want to use.
-
If you’ve never installed Ansible, it’s quite easy on a Mac with
brew install ansible
. Other instructions can be found here. -
Ensure git is also installed with
brew install git
. -
Create a directory for all of your deployment files and change into that directory. I called mine ‘terra-spray’.
-
Issue
git clone git@github.com:kubespray/kargo.git
. A new directory called kargo will be created with the playbooks:
- Note that there are a plethora of different options available with Kargo. I highly recommend spending some time reading up on the project and the different playbooks out there in order to deploy the specific cluster type you may need.
Create Terraform Templates
We want to create two terraform templates, the first will create our OpenStack infrastructure, while the second will create an Ansible inventory file for kargo to use. Additionally, we will create a variable file where we can populate our desired OpenStack variables as needed. The Terraform syntax can look a bit daunting at first, but it starts to make sense as we look at it more and see it in action.
-
Create all files with
touch 00-create-k8s-nodes.tf 01-create-inv.tf terraform.tfvars
The.tf
and.tfvars
extension are terraform specific extensions. -
In the variables file,
terraform.tfvars
, populate with the following information and update the variables to reflect your OpenStack installation:
- Now we want to create our Kubernetes master and nodes using the variables described above. Open
00-create-k8s-nodes.tf
and add the following:
- Now, with what we have here, our infrastructure is provisioned on OpenStack. However, we want to get the information about our infrastructure into the Kargo playbooks to use as its Ansible inventory. Add the following to
01-create-inventory.tf
:
This template certainly looks a little confusing, but what is happening is that Terraform is taking the information for the created Kubernetes masters and nodes and outputting the hostnames and IP addresses into the Ansible inventory format at a local path of ./kargo/inventory/inventory. A sample output looks like:
Setup OpenStack
You may have noticed in the Terraform section that we attached a k8s-cluster
security group in our variables file. You will need to set this security group up to allow for the necessary ports used by Kubernetes. Follow this list and enter them into Horizon.
Hold On To Ya Butts!
Now that Terraform is setup, we should be able to launch our cluster and have it provision using the Kargo playbooks we checked out. But first, one small BASH script to ensure things run in the proper order.
- Create a file called
cluster-up.sh
and open it for editing. Paste the following:
You’ll notice I included a two minute sleep to take care of some of the time when the nodes created by Terraform weren’t quite ready for an SSH session when Ansible started reaching out to them. Finally, update the -u
flag in the ansible-playbook command to the user that has SSH access to the OpenStack instances you have created. I used ubuntu
because that’s the default SSH user for Ubuntu cloud images.
-
Source your OpenStack credentials file with
source /path/to/credfile.sh
-
Launch the cluster with
./cluster-up.sh
. The Ansible deployment will take quite a bit of time as the necessary packages are downloaded and setup. -
Assuming all goes as planned, SSH into your Kubernetes master and issue
kubectl get-nodes
:


Home
(current)
Sign in
Learning
Music theory
Guitar
Piano
Violin
Flute
Chord Library
Guitar
Piano
Violin
Services
Contact
Chord Library
guitar
C chord
C# chord
D chord
D# chord
E chord
F chord
F# chord
G chord
G# chord
A chord
A# chord
B chord
Previous
Next
major
minor
5
7
maj7
m7
sus4
add9
sus2
7sus4
7#9
9


---
title: "TREES AND SHRUBS FOR RESIDENTIAL LANDSCAPES"
date: "2000-01-01 20:05:06 -06:00"
categories:
- adult
subtitle: ""
layout: "events"
event-image: "trees-and-shrubs.jpg"
event-dates: "WEDNESDAYS, MAY 6 - 27"
event-location: "Online via Zoom"
button-type: "register"
tickets-link: "https://continue.utah.edu/lifelong/class/llhg_520_trees_and_shrubs_for_residential_landscapes"
registration-info: " Phone Registration Available:801-587-5433
Lifelong Learning: LLHG 520"
instructor-info: "Kim Eden"
member-cost: "$107"
public-cost: "$119"
event-notes: "Online"
tickets-button: ""
published: false
---
Wednesdays, May 6 - 27 @ 6-8:30PM
REGISTRATION REQUIRED
Evergreen and deciduous trees and shrubs are the backbone of the landscape and making the right selections for your garden is key to being successful and creating the look you are hoping to achieve. We will focus on 60 trees and shrubs suited for the Utah landscape discussing plant characteristics, size, growth pattern, and maintenance requirements so you can make appropriate choices for your garden. Class includes garden walks that will inspire and educate you about the trees and shrubs best suited to Utah's environment. We'll also cover where to purchase plants and the best times to plant. Most of class time is spent walking to view the trees and shrubs in the garden so dress appropriately for weather and for walking.
Co-sponsored with Lifelong Learning. Members pay $107 + sp fee, register for section 002.


{% include footer.html %} {% if page.jslibs %} {% for asset in page.jslibs %} {% endfor %} {% endif %} {% if page.url == "/does/consulting/" %} {% include contact-popup.html %} {% endif %}
We use cookies to provide you with a great experience and to help our website run effectively. Privacy policy.


|
Save
Me
(Hanson) |
|
Loving
you like I never have before
I'm nedding you to open up the door If begging you might somehow turn the tides Then tell me to I've got to get this off my mind I never thought thought I'd be speaking these words I never thought I'd need to say Another day alone is more than I can take Won't you save me, 'cause saving is what I need I just want to be by your side Won't you save me, I don't want to be Just drifting through the sea of life Listen please, don't walk out the door I'm on my knees. you're all I'm living for I never thought thought I'd be speaking these words I never thought I'd need to say Another day alone is more than I can take Won't you save me, 'cause saving is what I need I just want to be by your side Won't you save me, I don't want to be Just drifting through the sea of life Suddenly the sky is falling Could it be it's too late for me If I never say I'm sorry, then I'm wrong, I'm wrong Then I hear my spirit calling Wondering if she's longing for me And then I know that I can't live without her Won't you save me, 'cause saving is what I need I just want to be by your side Won't you save me, I don't want to be Just drifting through the sea of life Won't you save me Won't you save me Won't you save me |