Catfish-Man

Ok, so.

A processor has things called "registers", which are essentially its local variables. Anything it wants to operate on, it loads from memory (RAM) into registers, does the operations, and then stores them back to memory. One of those registers is the "program counter", which holds the location of the next instruction to run. Now, there's a fixed quantity of registers, while you're allowed to have unlimited local variables, so there's also a dedicated region of memory for storing local variables that aren't currently in registers, which is called "the stack" (it's a stack because each time you call a function its variables get added to the top, and each time you return from a function they get taken off the top).

A thread is:
 * The state of all the registers
 * The stack
 * A pointer for the operating system (the kernel scheduler specifically) to keep track of it
 * A few odds and ends of metadata and extra state like priority and such

Catfish-Man

import Foundation

func examine(_ str: String) {
    print("\"\(str)\"")
    print("bridges as: \(type(of: str as NSString))")
    str.withCString {
        print("inits an NSString as: \(type(of: NSString(cString: $0, encoding: String.Encoding.ascii.rawValue)!))")
    }
    print("\n")
}

Catfish-Man

/*
This code is completely untested but should be close enough to correct to demonstrate the concepts
*/

struct RegularMonkey {
  var bananaCount: Int
}

struct KlingonMonkey {
  var bananaCount: Int

Catfish-Man

import Foundation

func test() {
  let object = NSObject()
  let cocoa = NSMutableArray()
  var swift = Array<AnyObject>()

  var start = Date()
  for _ in 1 ... 200_000 {
    cocoa.insert(object, at: 0)

Catfish-Man

#import <Foundation/Foundation.h>
#import <time.h>

#define USE_CF_NONOBJC 1

#if USE_CF_NONOBJC
extern CFTypeRef _CFNonObjCRetain(CFTypeRef cf);
extern void _CFNonObjCRelease(CFTypeRef cf);
#endif

Catfish-Man

#import <stdlib.h>
#import <malloc/malloc.h>

#define SLOW 1

int main(int argc, const char * argv[]) {
#if SLOW
  int sizes[] = { 256032, 512032, 1024032, 1792032 };
  
  for (int ii = 0; ii < 10000; ii++) {

Catfish-Man

/*
Shell version:

paste -d , oldoutput.txt output.txt | awk -F "," '{printf "%s %s %s %f\n", $2, $8, $16, $8 / $16}' | sort -k4 | egrep -v "(1\.0|0\.9[1-9])"
*/

import Foundation

// "paste -d , oldfile.txt newfile.txt"
let paths = CommandLine.arguments[1...2].map(URL.init(fileURLWithPath:))

Catfish-Man

func g(_ x: inout Int) {
    x = x * x
}

func f() { 
     var computed:Int { 
         get { return 5 } 
         set { print(newValue) } 
     } 
     g(&computed) 

Catfish-Man

//compile with "clang -framework Foundation -arch i386 failbuzz.m -o FizzBuzz"
//Yes, it only works in 32 bit
//No, I can't fix it to work correctly past 12 without coming up with a new implementation strategy, 
//or compiling a new CoreFoundation that caches more CFNumbers (…I did do that to be sure it worked though)

#import <Foundation/Foundation.h>
#import <libgen.h>

static void setup(const char * argv[]) {
    for (int i = 1; i <= 100; i++) {

Catfish-Man

#import <Foundation/Foundation.h>
#import <assert.h>

//Compile with `clang -Os -framework Foundation -fno-objc-arc inlinestorage.m -o inline, run with `inline clever` or `inline naive`

/*
 NaiveArray implements a simple immutable NSArray-like interface in probably the most obvious way: store a pointer to a C array of objects
 */
@interface NaiveArray : NSObject {
    NSUInteger count;