Aleksei Bukhtin buh

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,

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE U

What I Wish I'd Known About Equity Before Joining A Unicorn

Disclaimer: This piece is written anonymously. The names of a few particular companies are mentioned, but as common examples only.

This is a short write-up on things that I wish I'd known and considered before joining a private company (aka startup, aka unicorn in some cases). I'm not trying to make the case that you should never join a private company, but the power imbalance between founder and employee is extreme, and that potential candidates would

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

DEPRECATED for Xcode 10 🎈

(check out What's New in Swift at 11:40, slide 42)

Whole Module Compilation Optimizations: Why these terms are sometimes misleading

When you look up how to compile swift faster for debug builds, people very earnestly give advice that seems contradictory: you should "try using the whole module optimization flag," and also "never use whole module optimization for debugging". [^1]

This is confusing because some of us are using these two general words:

compilation: "turning text into an executable program"

	!/bin/sh
	SAVEIFS=$IFS
	IFS=$(echo -en "\n\b")
	FILES=($(git ls-files -m \| grep ".\.swift$" \| grep -v ".R.generated.swift$"))

	if [[ ${FILES[@]} ]]; then
	export "SCRIPT_INPUT_FILE_COUNT"="${#FILES[@]}"
	for i in "${!FILES[@]}"; do
	export "SCRIPT_INPUT_FILE_$i"="${FILES[$i]}"
	done

	iOS Create a Carthage Supported Framework

	#iOSBySheldon
	A little bit Background of Carthage:
	- Carthage works like Cocoapods, but a little bit simpler.
	* When creating a Cocoapods supported framework need a .podspec file to do some config, which is not required by Carthage.
	* When using a Cocoapods supported framework, a workspace file will be automatically created, the umbrella header will be setup in a pod project inside workspace. It feels simple, but the whole process creates a lot files including a "giant" workspace.
	* When using a Carthage supported framework, it will just download the framework, and its dependencies if any, to a folder. All we need to do is to drag and drop it to the binary linking section in the project build setting tab, for the first time. It sounds complicated but it makes the project clean.
	- Carthage is written in Swift.
	- Carthage internally uses `-xcodebuild` to build dependency.

	/**
	```
	// Encode a model with properties of type [String : Any]
	var propertiesContainer = container.nestedContainer(keyedBy: DynamicKey.self, forKey: .properties)
	if let properties = properties {
	try propertiesContainer.encodeDynamicKeyValues(withDictionary: properties)
	}
	```
	*/
	struct DynamicKey: CodingKey {

	import Foundation

	let json = """
	{
	"a": 1,
	"b": 2,
	"c": 3
	}
	""".data(using: .utf8)!

	#const n = 5.
	#const m = 5.
	% define?
	cell(1..m, 1..n).

	% tiles, format:
	% pdef((tile name, rotation in 90deg increments), bottom edge, right edge, top edge, left edge)

	pdef((line_v, 0), empty, path, empty, path).
	pdef((line_v, 1), path, empty, path, empty).