zumbojo

# Simple bijective function
#   Basically encodes any integer into a base(n) string,
#     where n is ALPHABET.length.
#   Based on pseudocode from http://stackoverflow.com/questions/742013/how-to-code-a-url-shortener/742047#742047

ALPHABET =
  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split(//)
  # make your own alphabet using:
  # (('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a).shuffle.join

henrik

tmux cheatsheet

As configured in my dotfiles.

start new:

tmux

start new with session name:

crabmusket

module Alphabet (
    Alphabet,
    encodeWithAlphabet,
    decodeFromAlphabet
 ) where

import Prelude
import Data.List(elemIndex, mapAccumR)
import Data.Maybe(fromMaybe)

dergachev

OS X Screencast to animated GIF

This gist shows how to create a GIF screencast using only free OS X tools: QuickTime, ffmpeg, and gifsicle.

Instructions

To capture the video (filesize: 19MB), using the free "QuickTime Player" application:

ArtFeel

//
//  MGNavigationTransitioningDelegate 
//
//  Created by Philip Vasilchenko on 27.11.13.
//

#import <UIKit/UIKit.h>


@interface MGNavigationTransitioningDelegate : NSObject <UINavigationControllerDelegate>

mattt

// See: https://devforums.apple.com/message/1000934#1000934

import Foundation

// Logic

operator prefix ¬ {}
@prefix func ¬ (value: Bool) -> Bool {
    return !value
}

andymatuschak

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,

michaelevensen

import UIKit

private let reuseIdentifier = "Cell"

class CollectionViewController: UICollectionViewController {

    /* Custom scrollView for paging */
    let pagingScrollView = UIScrollView()
    
    /* Return item size */

JohnSundell

class Cache<T> {
    private lazy var objects = [String : T]()
    
    func object(forKey key: String) -> T? {
        return objects[key]
    }
    
    func addObject(_ object: T, forKey key: String) {
        objects[key] = object
    }

samdods

//
//  Config.swift
//  Analytics
//

public protocol AnalyticsConfig {
    static var analyticsKey: String { get }
    static var appVersion: String { get }
}