SunboX

function worker() {
  setInterval(function() {
    postMessage({foo: "bar"});
  }, 1000);
}

var code = worker.toString();
code = code.substring(code.indexOf("{")+1, code.lastIndexOf("}"));

var blob = new Blob([code], {type: "application/javascript"});

lifuzu

# There are 3 levels of git config; project, global and system.

# project: Project configs are only available for the current project and stored in .git/config in the project's directory.
# global: Global configs are available for all projects for the current user and stored in ~/.gitconfig.
# system: System configs are available for all the users/projects and stored in /etc/gitconfig.

# Create a project specific config, you have to execute this under the project's directory.
$ git config user.name "John Doe"

# Create a global config

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---

bhauman

Recent improvements to the ClojureScript compiler have greatly simplified setting up development versus production outputs.

This example uses Figwheel as something that you want to exclude for production, but the pattern is general.

With this simple setup you only need one html file/view and it will work for developement and production.

caasi

# Literate LiveScript

This is an example for literate livescript. Although I can just wrap comments in
`/**/`, I think a markdown is more beautiful.

    request = require 'superagent'

    triple-ip = ->
      { body: { origin: a } } <- request.get 'http://httpbin.org/ip'
      { body: { origin: b } } <- request.get 'http://httpbin.org/ip'

likethesky

$ brew update && brew doctor          # Repeat, until you've done *all* the Dr. has ordered!
$ brew install postgresql             # You'll need postgres to do this... you may also need to 'initdb' as well. Google it.

$ brew install elixir
$ mix local.hex                       # Answer y to any Qs
$ createuser -d postgres              # create the default 'postgres' user that Chris McCord seems to like -- I don't create mine w/a pw...

# Use the latest Phoenix from here: http://www.phoenixframework.org/docs/installation -- currently this is 1.0.3
# ** Answer y to any Qs **
$ mix archive.install https://github.com/phoenixframework/phoenix/releases/download/v1.0.3/phoenix_new-1.0.3.ez

justinwoo

How to make a Cycle.js + Elm hybrid Etch-a-Sketch app

A couple of days ago, I wrote a Cycle.js app using Elm to render stuff to the page. This was pretty fun and got some attention, so I might as well write about it some.

Writing this thing

Overview

A Cycle.js application consists of three parts: your main function declaration, your drivers setup, and your application initialization with Cycle.run (which sets up the "Cycle" part of your application). We'll do the following in our app:

asksven

If 2fa is enabled on github switch to ssh instead of https on linux

1. generate an ssh keypair on your linux box
ssh-keygen -t {rsa|dsa} 

2. add the public key to github: profile - settings - ssh keys

3. switch from https to ssh

Check your repo remote:

andymatuschak

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,

yelouafi

Motivation

In Redux, reducer composition with combineReducers offers a powerful way to handle complex update logic of an application. A reducer can encapsulate all the ways a part of the state is mutated because it can react to multiple types of actions.

But in some cases there is also a need for another type of factoring: often the update logic is simple (for example setting a single value), and the there are many places in the state shape where the update logic is the same.