Jason Jobe wildthink

System Design Cheatsheet

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

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?

Add Graal JIT Compilation to Your JVM Language in 5 Steps, A Tutorial http://stefan-marr.de/2015/11/add-graal-jit-compilation-to-your-jvm-language-in-5-easy-steps-step-1/
The SimpleLanguage, an example of using Truffle with great JavaDocs. It is the officle getting-started project: https://github.com/graalvm/simplelanguage
Truffle Tutorial, Christan Wimmer, PLDI 2016, 3h recording https://youtu.be/FJY96_6Y3a4 Slides

	import Foundation

	protocol Currency { static var sign: String { get } }
	enum GBP: Currency { static let sign = "£" }
	enum EUR: Currency { static let sign = "€" }
	enum USD: Currency { static let sign = "$" }

	protocol _Money {
	associatedtype C: Currency
	var amount: NSDecimalNumber { get }

	class TranslucentWin:NSWindow, NSApplicationDelegate, NSWindowDelegate{
	/**
	*
	*/
	override init(contentRect: NSRect, styleMask aStyle: Int, backing bufferingType: NSBackingStoreType, `defer` flag: Bool) {
	super.init(contentRect: Win.sizeRect, styleMask: NSTitledWindowMask\|NSResizableWindowMask\|NSMiniaturizableWindowMask\|NSClosableWindowMask\|NSFullSizeContentViewWindowMask, backing: NSBackingStoreType.Buffered, `defer`: false)
	self.contentView!.wantsLayer = true;/this can and is set in the view/
	self.backgroundColor = NSColor.greenColor().alpha(0.2)
	self.opaque = false
	self.makeKeyAndOrderFront(nil)//moves the window to the front

	//
	// BitArray.swift
	// xFuncs
	//

	import Foundation

	public class BitArray : CollectionType {

	public typealias Index = Int

	import Foundation

	// A bunch of convenience things
	func const <A, B> (b: B) -> A -> B {
	return { _ in b }
	}
	func repeat <A> (n: Int) -> A -> [A] {
	return { a in
	return map(Array(1...n), const(a))
	}

	extension NSTextView {
	func rectForRange(range: NSRange) -> NSRect? {
	guard let layout = self.layoutManager, container = self.textContainer else {return nil}
	let rng = layout.glyphRangeForCharacterRange(range, actualCharacterRange: nil)
	let rct = layout.boundingRectForGlyphRange(rng, inTextContainer: container)
	return NSOffsetRect(rct, self.textContainerOrigin.x, self.textContainerOrigin.y)
	}

	func rectForSelectedRange() -> NSRect? {
	return rectForRange(self.selectedRange())

	import Swift

	/// `UUID` represents a 128-bit value suitable for uniquely identifying things.
	public struct UUID: Hashable {
	// MARK: -
	// MARK: Public Properties

	/// The raw bytes of the UUID.
	public let data: Data

	#if swift(>=3.0)
	extension Sequence {
	func reduce(combine: @noescape (Iterator.Element, Iterator.Element) throws -> Iterator.Element) rethrows -> Iterator.Element? {
	var iterator = makeIterator()
	guard var result = iterator.next() else { return nil }
	while let element = iterator.next() {
	result = try combine(result, element)
	}
	return result
	}

	import Cocoa

	//: # An exercise in specifying and simplifying Maths functions using Swift
	/*: This is cut-down version of some code I've been working on to parse, simplify and display mathematical expressions. The source below shows some of the power of pattern matching and (recursive) enumerated types within Swift in defining and evaluating the expression domain. Note, it doesn't cover all cases but is intended to give a flavour of what can be achieved.

	No optimisations applied
	*/

	//: # Supporting functions
	//: ### Function Pipeline