whathewhat chml

The attached lldb command pblock command lets you peek inside an Objective-C block. It tries to tell you where to find the source code for the block, and the values captured by the block when it was created.

Consider this example program:

#import <Foundation/Foundation.h>

@interface Foo: NSObject
@end

@implementation Foo

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

New Build System Tricks

Command Line

alias xcbuild=$(xcode-select -p)/../SharedFrameworks/XCBuild.framework/Versions/A/Support/xcbuild
# THIS DOESNT WORK YET: xcbuild openIDEConsole  # … then switch to Xcode ➡️
xcbuild showSpecs
xcbuild build <foo.pif> [—target <target>]

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,

	// See this Swift bug for more info: https://bugs.swift.org/browse/SR-9323

	import Benchmark

	struct User {
	var name = "Blob"
	var age = 42
	}

	@dynamicMemberLookup

	import ComposableArchitecture
	import Difference
	import Foundation

	/// A container for storing action filters.
	///
	/// The logic behind having this rather than a normal closure is that it allows us to namespace and gather action filters together in a consistent manner.
	/// - Note: You should be adding extensions in your modules and exposing common filters you might want to use to focus your debugging work, e.g.
	/// ```swift
	/// extension ActionFilter where Action == AppAction {

	javascript: Promise.all([import('https://unpkg.com/[email protected]?module'), import('https://unpkg.com/@tehshrike/[email protected]'), ]).then(async ([{
	default: Turndown
	}, {
	default: Readability
	}]) => {

	/* Optional vault name */
	const vault = "";

	/* Optional folder name such as "Clippings/" */

	//
	// The code snippets below showcase common "problem code" that can take a long time to compile.
	// These examples were primarily observed in Swift 2/3 and may no longer be relevant in Swift 4 or higher.
	//

	/// 1. Array concatenation
	// Observed by Robert Gummesson - https://medium.com/@RobertGummesson/regarding-swift-build-time-optimizations-fc92cdd91e31#c75c
	// Joining two arrays together with the '+' operator can be expensive to compile.

	let someArray = ["a", "b"] + ["c", "d"]

	//
	// MultiDirectionAdjudicatingScrollView.swift
	// Khan Academy
	//
	// Created by Andy Matuschak on 12/16/14.
	// Copyright (c) 2014 Khan Academy. All rights reserved.
	//

	import UIKit
	import UIKit.UIGestureRecognizerSubclass

whathewhat chml

Swift Concurrency Manifesto

Contents

New Build System Tricks

Command Line

A composable pattern for pure state machines with effects