sleepyfox

'Users hate change'

This week NN Group released a video by Jakob Nielsen in which he attempts to help designers deal with the problem of customers being resistant to their new site/product redesign. The argument goes thusly:

1. Humans naturally resist change
2. Your change is for the better
3. Customers should just get used to it and stop complaining

There's slightly more to it than that, he caveats his argument with requiring you to have of course followed their best practices on product design, and allows for a period of customers being able to elect to continue to use the old site, although he says this is obviously only a temporary solution as you don't want to support both.

andy-thomason

Genomics - A programmer's guide.

Andy Thomason is a Senior Programmer at Genomics PLC. He has been witing graphics systems, games and compilers since the '70s and specialises in code performance.

https://www.genomicsplc.com

chriseidhof

/*:
 
 This is an implementation of Algorithm W, as found in [Principal Types for functional programs](http://web.cs.wpi.edu/~cs4536/c12/milner-damas_principal_types.pdf).
 
 We'll start by defining literals and expressions:
 */

enum Literal {
    case string(String)
    case int(Int)

russbishop

// If you want types initializable from String literals
// but don't want to implement three separate initializers.


extension ExpressibleByUnicodeScalarLiteral where Self: ExpressibleByStringLiteral, Self.StringLiteralType == String {
    public init(unicodeScalarLiteral value: String) {
        self.init(stringLiteral: value)
    }
}

jspahrsummers

template<typename Left, typename Right>
struct Intersect
{
  // This will fail to compile if there's no specialization for Intersect<Right, Left>,
  // thereby verifying that we've handled all combinations.
  typename Intersect<Right, Left>::Result operator() (const Left &lhs, const Right &rhs) const
  {
    return Intersect<Right, Left>()(rhs, lhs);
  }
};

JadenGeller

/* -fno-objc-arc
 CFTypeRef _unsafeCreatePartiallyInitialized(Class c) {
 Method method = class_getInstanceMethod([NSObject class], @selector(init));
 IMP imp = method_getImplementation(method);
 return ((id (*)(id, SEL))imp)([c alloc], @selector(init));
 }

 void _unsafeDestructPartiallyInitialized(CFTypeRef x) {
 Method method = class_getInstanceMethod([NSObject class], @selector(dealloc));
 IMP imp = method_getImplementation(method);

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,

Catfish-Man

// Compile with clang -framework Foundation sethack.m

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

/*
 CFHashBytes from http://www.opensource.apple.com/source/CF/CF-1153.18/CFUtilities.c
 */
#define ELF_STEP(B) T1 = (H << 4) + B; T2 = T1 & 0xF0000000; if (T2) T1 ^= (T2 >> 24); T1 &= (~T2); H = T1;

NachoSoto

//
//  Signal+Extensions.swift
//  Khan Academy
//
//  Created by Nacho Soto on 10/1/15.
//  Copyright © 2015 Khan Academy. All rights reserved.
//

import ReactiveCocoa

jspahrsummers

#import <Foundation/Foundation.h>

int main (int argc, const char **argv) {
  @autoreleasepool {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"is main thread? %i", (int)[NSThread isMainThread]);
      });
    });