csp: huh? and components
TRANSCRIPT
CSP: Huh? And [email protected]/TheHydroImpulse
Communicating Sequential Processes
• I won’t be getting into the complex theory.
• I’ll be going into the practical examples of CSP.
ConcurrencyWhat is it exactly?
Concurrency != Parallelism
• Concurrency is a model for concurrent execution.
• Parallelism is the literal act of being concurrent.
• With concurrency, tasks are able to run at the same time,but they don’t have to — that’s parallelism.
CSP: Huh?
• A formal language for describing patterns of interaction in concurrent systems.
• based on message passing via channels.
Channels• A powerful primitive for communication
• Channels are exactly what you think it is; they let you pass stuff through it.
• Two basic actions: Put & Take
Channel
Input
Output
Kinds of Channels
Buffered
Unbuffered (Can be dangerous)
Basic Actions
• Put: Send a new value onto the channel
• Take: Receive on existing value from the channel.
Channel Semantics• Semantics vary on the
language/implementation.
• The basic semantics are:
• on share-ability of concrete channels. (i.e., across tasks/threads?)
• when channels block
Blocking• Can block when trying to put a value onto the
channel when it’s full.
• Can block when trying to take a value from an empty channel.
What Blocks?• Very much dependent on the
implementation/language.
• Golang blocks on goroutines (a.k.a green threads)
• Rust blocks on tasks (a.k.a green threads or native threads)
• Clojure (core.async): both actions have the potential to block the underlying thread.
Clojure: core.async• A library not a language feature.
• Goes to show how powerful a consistent language form (Lisp) can be, thanks to macros.
• Supports unbounded buffered and bounded buffered channels. The former is discouraged.
• Two implementations of the underlying “threads”.
• Supports timeouts (super powerful)
• All operations are expressions not statements.
• Priority selects with alts!
Clojure: core.async• Supports two kinds of thread of control:
• IoC (inversion of control)
• Normal Threads
• IoC threads are created with go blocks
• go is a macro that examines it’s body for any channel operations and turns them into a state machine.
• C#’s async does the same thing.
Clojure: Example!
JavaScript Example!
• Uses ES6 Generators
• Similar to ClojureScript/Clojure’s go blocks.
Callbacks (Direct Data-Flow)
• Worst style of concurrency
• You have no control over the data flow.
• You’re (the callback) at the mercy of the caller.
Direct vs Indirect
Callback/LogicIn Out
LogicIn Channel
Direct
Indirect
Channel Out
Indirect = Channels• Channels offer a better alternative at
managing data-flow.
• They are indirect. This means the logic is in control of the data-flow.
• The logic can decide when it’s had too much data coming through. It’s the best decider at judging how much it can handle.
Examples!• Return the 5 fastest search queries.
• Return the x number of queries that finish within 3 seconds (timeouts)
• Channels act like queues. They’re a buffer for your data.
ComponentsBuilding modular applications.
Components• Not an abstract component.
• https://github.com/component/component
• A client-side package manager and build tool.
• CommonJS style code.
• Ability to share client and server code super easily.
Unix Style• Build small, concentrated applications that do
one thing, and does that thing extremely well.
• Modular
• Modular
• Modular
Globals..grrr• Globals are horrible. Never use them.
• Globals are horrible. Never use them.
• Globals are horrible. Never use them.
• jQuery, Angular, Ember, etc… ALL use them.
/** * Module Dependencies */
var dom = require('dom');var model = require('tower-model');var migration = require('tower-migration');
/** * User Model */
model('user') .attr('email') .validate('presence') .validate('isEmail') .attr('firstname') .attr('lastname') .attr('country') .attr('city');
/** * Migration */
migration.up('create_user_table') .model('user');
Creating a Component App
Modular Apps• It’s the future
• Building monolithic apps suck
• Tooling is only going to get better.
• It’s much easier to wrap your head around a single module that has no side-effects (i.e., no external state & globals).
Server & Client-side• Node.js offers the ability to share code with
the client-side (components).
• Both have the same module pattern (CommonJS
• Module can now be designed for both platforms.
No Globals?• We can take advantage of the module
caching.
• A version of inversion-of-control
• Decentralized.
Module Caching• If each module is concentrated, you can store data
(instances, values, etc…) in the module exports or module itself.
• Example!
Wrapping Up• CSP is awesome.
• Clojure is awesome.
• Message passing & channels are awesome.
• Modular apps are awesome.
• Globals are horrible.
• Callbacks are horrible.
Resources
Components & ES6• Module system in ES6 replaces the build
system in component.
• Components might just become a package manager.
Thanks!@TheHydroImpul
se
github.com/TheHydroImpulsehydrocodedesign.co
m