NSHipster New Year's 2015

nshipster-new-years-2015.md

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 past year's write-ups for inspiration (2014, 2013).

I can't wait to see what you all send in!

If you gave up on reading the official iOS 7.1 to iOS 8.0 and the OS X v10.9 to OS X v10.10 API differences because of the noise mostly generated by transforming getter/setters into properties and id into instancetype, I created curated versions for iOS and OS X.

Also interesting is the source code that generated these curated documents. Less than 200 lines of code thanks to the powerful NSXMLDocument/XPath APIs.

If you are installing Xcode from the dmg, I highly recommend this technique by Joar Wingfors in order to avoid to accidentally modifying SDK headers.

Preserve ownership, permissions and hard links installing Xcode from a dmg:
sudo ditto /Volumes/Xcode/Xcode.app /<destination>/Xcode.app

I personally add the -V flag to ditto for verbose logging.

For reverse engineering purpose, it’s always useful to look at instance variables of objects. It’s usually pretty easy to do so with valueForKey: since very few classes override the +accessInstanceVariablesDirectly
method to disable ivar acces through Key-Value Coding.

There’s one case where it doesn’t work though: when the ivar has a void * type. Here is an excerpt of the MediaPlayer framework class-dump on iOS 6.1:

@interface MPMoviePlayerController : NSObject <MPMediaPlayback>
{
    void *_internal;    // 4 = 0x4
    BOOL _readyForDisplay;  // 8 = 0x8
}

Since id internal = [moviePlayerController valueForKey:@"internal"] doesn’t work, here is the hardcore way to access the internal ivar:

id internal = *((const id*)(void*)((uintptr_t)moviePlayerController + sizeof(Class)));

Don’t ship this code, its’s very fragile because the ivar layout may change. Use this for reverse engineering only!

Friendly reminder that if you are using -[NSDateFormatter setDateFormat:] without +[NSDateFormatter dateFormatFromTemplate:options:locale:], you’re probably doing it wrong.

Recently, Matthias Tretter asked on Twitter:

Does anyone know the default animation duration and springs for modal viewController presentation on iOS 8?

Here is how to answer this question in 3 minutes:

• Search for duration in a class-dump of UIKit

• Find the +[UITransitionView defaultDurationForTransition:] method

• Set a breakpoint for this method:

  (lldb) br set -n "+[UITransitionView defaultDurationForTransition:]"
  

• Present a modal view controller, you will hit the breakpoint, type finish to execute the method

  (lldb) finish
  

• At that point the defaultDurationForTransition: has executed and you can read the result, it’s in the xmm0 register.

  (lldb) register read xmm0 --format float64
      xmm0 = {0.4 0}
  

Answer: the default duration is 0.4s.

Quick tip from @bensge:

Wow +[UIViewController _printHierarchy] is like -[UIView recursiveDescription] but for view controllers! #Development

DIY weak associated objects, adapted from my Stack Overflow answer:

Unfortunately, the associated objects OBJC_ASSOCIATION_ASSIGN policy does not do zeroing weak reference. Fortunately, it’s quite easy to implement yourself. You just need a simple class to wrap an object with a weak reference:

@interface WeakObjectContainter : NSObject
@property (nonatomic, readonly, weak) id object;
@end

@implementation WeakObjectContainter
- (instancetype) initWithObject:(id)object
{
    if (!(self = [super init]))
        return nil;

    _object = object;

    return self;
}
@end

Then you must associate the WeakObjectContainter as OBJC_ASSOCIATION_RETAIN(_NONATOMIC):

objc_setAssociatedObject(self, &MyKey, [[WeakObjectContainter alloc] initWithObject:object], OBJC_ASSOCIATION_RETAIN_NONATOMIC);

and use the object property to access it in order to get a zeroing weak reference:

id object = [objc_getAssociatedObject(self, &MyKey) object];

Here is a convenient way to access child controllers inserted into Storyboard container views:

// 1. A property has the same name as a segue identifier in XIB
@property (nonatomic) ChildViewController1 *childController1;
@property (nonatomic) ChildViewController2 *childController2;

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{
    [super prepareForSegue:segue sender:sender];

    // 2. All known destination controllers assigned to properties
    if ([self respondsToSelector:NSSelectorFromString(segue.identifier)])
        [self setValue:segue.destinationViewController forKey:segue.identifier];
}

- (void)viewDidLoad
{
    [super viewDidLoad];

    // 3. Controllers already available bc viewDidLoad is called after prepareForSegue
    self.childController1.view.backgroundColor = [UIColor redColor];
    self.childController2.view.backgroundColor = [UIColor blueColor];
}

You can Edit Breakpoint in Xcode by Option-Command-Click on the blue indicator.

AppCode.

Member functions on Swift classes and structures always have the following type when used statically:

Object -> (Args) -> Thing

For example, you can call reverse() on an array in two ways

[1, 2, 3, 4].reverse()
Array.reverse([1, 2, 3, 4])()

I'm a fan of the Objective-C Runtime functions objc_getAssociatedObject and objc_setAssociatedObject. These allow the ability to "associate" an object with another object. This association can survive the life of the source object. Imagine tacking "data" onto a button that the button's IBAction can then access when tapped. Lots of possibilities with these functions.

Cool instruments tricks to counter memory leaks - https://medium.com/hacking-ios/a-day-with-instruments-tool-414ad50234f1
Also CGParallaxCollectionView written very early when Swift was annouced - https://github.com/kNeerajPro/CGParallaxCollectionView

Shameless plug for some Array extensions I wrote to mimic some of the popular methods from Ruby's Enumerable module. Attributions, where applicable, are in the source. https://github.com/bitops/swift-collections/blob/master/SwiftCollections.swift

Instead of if-testing a block against nil before calling it:

if (block) {
    result = block(param1, param2);
}
else {
    result = defaultValue;
}

if love using the one-liner:

result = block ? block(param1, param2) : defaultValue;

to declutter my code. For blocks returning void, simply use nil as default value:

voidBlock ? voidBlock(param1, param2) : nil;

Given the fact that literals are most of the time associated with numbers and collections, I often forget that they work for UTF8-encoded NULL-terminated C-strings as well, especially when I write code using the runtime:

NSString *propertyAttributesString = @(property_getAttributes(class_getProperty([NSObject class], "description")));         // T@"NSString",R,C

It is namely quite amusing that:

[@("someString") isEqualToString:@"someString"] == YES

is something I so easily forget, especially since this boxing syntax is totally natural.

Optionals should be avoided. Implicitly unwrapped optionals should be strongly avoided. Want to declare a var but don't necessarily have an initial value at init time? Use the lazy keyword, and just don't call the getter before you have your real value.

lazy var someModelStructure = ExpensiveClass()

if you call set on this var without having ever called the getter, the lazy expression is never evaluated. Great for references to views that you don't necessarily want to init until viewDidLoad, for instance.

Now that 10.10 is allowing easy screencasts of iOS devices (which itself is a neat tip), I find myself again using a framework I made some time back for showing touches on screen: Fingertips. Great for presentations, too.

You can optional chain calling a closure just like you can accessing a subscript

func foo(completion: ((String) -> Void)?) {
    completion?("Heyo!!") ?? println("Oyeh!!")
}

foo { println($0) }     // prints "Heyo"
foo(nil)                // prints "Oyeh"

Sometimes, you need to know which language your app is running in. Often, people will use +[NSLocale preferredLanguages]. Unfortunately this tells nothing about the language the app is actually displaying. It will just give you the ordered list as found in Settings → General → Language & Region → Preferred Language Order on iOS or System Preferences → Language & Region → Preferred Languages on OS X.

Imagine that the preferred language order is {English, French} but your app is German only. Calling [[NSLocale preferredLanguages] firstObject] will give you English when you want German.

The proper way to get the actual language used by the app is to use [[NSBundle mainBundle] preferredLocalizations].

From the documentation:

An array of NSString objects containing language IDs for localizations in the bundle. The strings are ordered according to the user's language preferences and available localizations.

From a comment in NSBundle.h:

a subset of this bundle's localizations, re-ordered into the preferred order for this process's current execution environment; the main bundle's preferred localizations indicate the language (of text) the user is most likely seeing in the UI

You may also need to use +[NSLocale canonicalLanguageIdentifierFromString:] in order to ensure a canonical language identifier.

Functional Programming vs OOP vs Imperative Programming

@samirGuerdah vs "Playground Driven Development" )))

When you have objects in a NSArray, you can extract another NSArray with the value returned from a selector applied to each object using -valueForKey. This call will turn the string into a @selector if it doesn't find a property with the same name, and call the selector:

NSArray *array = <some array of NSObject> ;
NSArray *descriptions = [array valueForKey:@"description"];

The cool thing is that this works with any selector you define on your objects.

This is part of the key-value coding conventions. Relevant documentation for NSArray is here

If you're repeatedly debugging the same problem over and over, you can run your app without rebuilding by using <ctrl>+<cmd>+r.

Swift Playgrounds all share the same Shared Playground Data folder that's symlinked to /Users/HOME/Documents/Shared Playground Data.

If you like using lots of Playgrounds, you'll want to organize the data that each Playground is using into subfolders of that shared folder, but then you've got to let the Playground know where to look. Here's a helper function that I use that makes that easy:

func pathToFileInSharedSubfolder(file: String) -> String {
    return XCPSharedDataDirectoryPath + "/" + NSProcessInfo.processInfo().processName + "/" + file
}

That processName property in NSProcessInfo contains the name of the Playground file, so as long as you have already created a sub-folder in the Shared Playground Data folder with the same name you can access those files pretty easily, like reading local JSON:

var jsonReadError:NSError?
let jsonData = NSFileManager.defaultManager().contentsAtPath(pathToFileInSharedSubfolder("data.json"))!
let jsonArray = NSJSONSerialization.JSONObjectWithData(jsonData, options: nil, error: &jsonReadError) as [AnyObject]

or pulling out a local image:

let imageView = UIImageView()
imageView.image = UIImage(contentsOfFile: pathToFileInSharedSubfolder("image.png"))

Cocoapods
@orta 😉

Playground as Documentation.

And also Firefox coming to iOS and looks to be mostly done in Swift. It's still early days and a great opportunity for community to get involved with the development. Contributing guidelines are non existent and so are code comments, making it difficult to get involved. If somebody can do some digging and come up with some simple guidelines and code comments for existing code, it will be great for everybody.