Michael Bradley michaelsbradleyjr

How to set up stress-free SSL on an OS X development machine

One of the best ways to reduce complexity (read: stress) in web development is to minimize the differences between your development and production environments. After being frustrated by attempts to unify the approach to SSL on my local machine and in production, I searched for a workflow that would make the protocol invisible to me between all environments.

Most workflows make the following compromises:

Use HTTPS in production but HTTP locally. This is annoying because it makes the environments inconsistent, and the protocol choices leak up into the stack. For example, your web application needs to understand the underlying protocol when using the secure flag for cookies. If you don't get this right, your HTTP development server won't be able to read the cookies it writes, or worse, your HTTPS production server could pass sensitive cookies over an insecure connection.
Use production SSL certificates locally. This is annoying

WebSockets - An Introduction

WebSockets is a modern HTML5 standard which makes communication between client and server a lot more simpler than ever. We are all familiar with the technology of sockets. Sockets have been fundamental to network communication for a long time but usually the communication over the browser has been restricted. The general restrictions

The server used to have a permanent listener while the client (aka browser) was not designated any fixed listener for a more long term connection. Hence, every communication was restricted to the client demanding and the server responding.
This meant that unless the client requested for a particular resource, the server was unable to push such a resource to the client.
This was detrimental since the client is then forced to check with the server at regular intervals. This meant a lot of libraries focused on optimizing asynchronous calls and identifying the response of asynchronous calls. Notably t

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.

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors and Sequences

Parsing CSS file with monadic parser in Clojure

Inspired by "Parsing CSS with Parsec".

Just quick notes and code that you can play with in REPL.

By @kachayev

	// Just before switching jobs:
	// Add one of these.
	// Preferably into the same commit where you do a large merge.
	//
	// This started as a tweet with a joke of "C++ pro-tip: #define private public",
	// and then it quickly escalated into more and more evil suggestions.
	// I've tried to capture interesting suggestions here.
	//
	// Contributors: @r2d2rigo, @joeldevahl, @msinilo, @_Humus_,
	// @YuriyODonnell, @rygorous, @cmuratori, @mike_acton, @grumpygiant,

	M[16],X=16,W,k;

	main(){
	T(system("stty cbreak"));
	puts(W&1?"WIN":"LOSE");
	}

	K[]={2,3,1};

	s(f,d,i,j,l,P){

	(ns om-data.core
	(:require [om.core :as om :include-macros true]
	[om.dom :as dom :include-macros true]
	[datascript :as d]))

	(enable-console-print!)

	(def schema {})
	(def conn (d/create-conn schema))

	(ns shades.lenses)

	; We only need three fns that know the structure of a lens.
	(defn lens [focus fmap] {:focus focus :fmap fmap})
	(defn view [x {:keys [focus]}] (focus x))
	(defn update [x {:keys [fmap]} f] (fmap f x))

	; The identity lens.
	(defn fapply [f x] (f x))
	(def id (lens identity fapply))

	(require '[clojure.core.async :as a])

	(def xform (comp (map inc)
	(filter even?)
	(dedupe)
	(flatmap range)
	(partition-all 3)
	(partition-by #(< (apply + %) 7))
	(flatmap flatten)
	(random-sample 1.0)