View crash.log
0 swift 0x00000001109fac5a PrintStackTraceSignalHandler(void*) + 42
1 swift 0x00000001109fa066 SignalHandler(int) + 966
2 libsystem_platform.dylib 0x00007fff65e29d9a _sigtramp + 26
3 libsystem_malloc.dylib 0x00007fff65e09ed4 tiny_malloc_should_clear + 289
4 CoreNLP 0x00007fff4d7948eb invocation function for block in CoreNLP::NLModelTrainer::readSample(__CFString const*, std::__1::vector<CFRange, std::__1::allocator<CFRange> > const&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&, CoreNLP::NLTrainerDataType) + 1010
5 CoreNLP 0x00007fff4d751fd7 CoreNLP::CompositeTagger::enumerateTokens(NLTokenizerUnit, CFRange, unsigned long, void (NLToken, bool*) block_pointer) + 567
6 CoreNLP 0x00007fff4d7944c0 CoreNLP::NLModelTrainer::readSample(__CFString

This document was originally posted on 8/1/2013.

Rocket is a technique for building real-time functionality on top of REST web services that leverages web standards like [Server-Sent Events][SSE] and [JSON Patch][RFC6902]. Most importantly, it fits comfortably with how you're already building applications.

A Tale of Two Paradigms

Just as light can act as both a particle and a wave, so information can be thought as both a document and a stream.

Each approach has its particular strengths and weaknesses:

View Regex.swift
struct Regex {
let pattern: String
let options: NSRegularExpressionOptions!
private var matcher: NSRegularExpression {
return NSRegularExpression(pattern: self.pattern, options: self.options, error: nil)
init(pattern: String, options: NSRegularExpressionOptions = nil) {
self.pattern = pattern
View CoreGraphics.swift
import CoreGraphics
infix operator |> { precedence 50 associativity left }
// MARK: CGPoint
func +(lhs: CGPoint, rhs: CGPoint) -> CGPoint {
return CGPoint(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
View Calendar.swift
protocol Calendar {
typealias Unit: BidirectionalIndexType
typealias Era: Unit
typealias Year: Unit
typealias Month: Unit
typealias Week: Unit
typealias Day: Unit
typealias Weekday: Unit
typealias Hour: Unit
View URL.swift
struct URL {
var scheme: String?
var user: String?
var password: String?
var host: String?
var port: Int?
var path: String?
var query: String?
var fragment: String?
View Complex.swift
struct Complex<T: FloatLiteralConvertible> {
var real: T
var imaginary: T
func +(lhs: Complex<Double>, rhs: Complex<Double>) -> Complex<Double> {
return Complex<Double>(real: lhs.real + rhs.real, imaginary: lhs.imaginary + rhs.imaginary)
View random.swift
import Darwin
extension Int {
static func random() -> Int {
return Int(arc4random())
static func random(range: Range<Int>) -> Int {
return Int(arc4random_uniform(UInt32(range.endIndex - range.startIndex))) + range.startIndex
View NSDecimalNumber.swift
import Foundation
// MARK: - Comparable
extension NSDecimalNumber: Comparable {}
public func ==(lhs: NSDecimalNumber, rhs: NSDecimalNumber) -> Bool {
return == .OrderedSame

Season's Greetings, NSHipsters!

As the year winds down, and we take a moment to reflect on our experiences over the past months, one thing is clear: 2014 has been an incredible year professionally for Apple developers. So much has happened in such a short timespan, and yet it's hard to remember our relationship to Objective-C before Swift, or what APIs could have captivated our imagination as much as iOS 8 or WatchKit.

It's an NSHipster tradition to ask you, dear readers, to send in your favorite tips and tricks from the past year for publication over the New Year's holiday. This year, with the deluge of new developments—both from Cupertino and the community at large—there should be no shortage of interesting tidbits to share.

Submit your favorite piece of Swift or Objective-C trivia, framework arcana, hidden Xcode feature, or anything else you think is cool, and you could have it featured in the year-end blowout article. Just comment on this gist below!

If you're wondering about what to post, look to