Joe Henke joe-henke

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,

System Design Cheatsheet

Picking the right architecture = Picking the right battles + Managing trade-offs

Basic Steps

Clarify and agree on the scope of the system

User cases (description of sequences of events that, taken together, lead to a system doing something useful)
- Who is going to use it?
- How are they going to use it?

LLDB Debugging Cheat Sheet

Commands

LLDB Commands

LLDB comes with a great set of commands for powerful debugging.

help

Your starting point for anything. Type help to get a list of all commands, plus any user installed ones. Type 'help for more information on a command. Type help to get help for a specific option in a command too.

Thoughts on Swift 2 Errors

When Swift was first announced, I was gratified to see that one of the (few) philosophies that it shared with Objective-C was that exceptions should not be used for control flow, only for highlighting fatal programming errors at development time.

So it came as a surprise to me when Swift 2 brought (What appeared to be) traditional exception handling to the language.

Similarly surprised were the functional Swift programmers, who had put their faith in the Haskell-style approach to error handling, where every function returns an enum (or monad, if you like) containing either a valid result or an error. This seemed like a natural fit for Swift, so why did Apple instead opt for a solution originally designed for clumsy imperative languages?

I'm going to cover three things in this post:

Videos

Introduction to Functional Programming Johannes Weiß - https://vimeo.com/100786088
ReactiveCocoa at MobiDevDay Andrew Sardone - https://vimeo.com/65637501
The Future Of ReactiveCocoa Justin Spahr-Summers - https://www.youtube.com/watch?v=ICNjRS2X8WM
Enemy of the State Justin Spahr-Summers - https://www.youtube.com/watch?v=7AqXBuJOJkY
WWDC 2014 Session 229 - Advanced iOS Application Architecture and Patterns Andy Matuschak - https://developer.apple.com/videos/play/wwdc2014/229/
Functioning as a Functionalist Andy Matuschak - https://www.youtube.com/watch?v=rJosPrqBqrA
Controlling Complexity in Swift Andy Matuschak - https://realm.io/news/andy-matuschak-controlling-complexity/

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.

A bunch of good git tutorials

Intro to git

Simplest intro to git by github and codeschool - Try Git
PeepCode Git Internals PDF
[Intro to github]

	static func CloudFlareResponseSerializer<T: Decodable where T == T.DecodedType>() -> ResponseSerializer<T, CloudFlareError> {
	return ResponseSerializer { (request, response, data, error) in
	guard error == nil else {
	return .Failure(CloudFlareError.NetworkError(error: error!))
	}

	let JSONResult = Request.JSONResponseSerializer().serializeResponse(request, response, data, nil)
	guard case let .Success(responseJSON) = JSONResult else {
	return .Failure(CloudFlareError.SerializationError(error: JSONResult.error!))
	}

	//
	// ViewController.swift
	// SwiftTest
	//
	// Created by Josh Holtz on 8/3/14.
	// Copyright (c) 2014 Josh Holtz. All rights reserved.
	//

	import UIKit

	@implementation UIImage (scale)

	/**
	* Scales an image to fit within a bounds with a size governed by
	* the passed size. Also keeps the aspect ratio.
	*
	* Switch MIN to MAX for aspect fill instead of fit.
	*
	* @param newSize the size of the bounds the image must fit within.
	* @return a new scaled image.