WWDC 2013: Advances in Objective-C


@import optionally replaces the long, cumbersome process of:


Link binary with libraries

and makes it a whole lot more scalable to build large applications. What it does is a semantic import rather than a textual inclusion.

To use go into Settings and enable BUT it requires iOS7 and the OS X 10.9 SDK.

Tagged Pointers

For small value objects, the object is stored in the pointer itself which makes it over 100x faster and 3x more space efficient. 

BUT, public data structures are increasingly becoming private. i.e. use the APIs to introspect.

i.e. use object_getClass and isKindOfClass

Garbage Collection

ARC is increasingly being used in new frameworks. So, use it!

e.g. Xcode 5.0 now uses ARC.

To convert code use the ARC Migrator which does the heavy lifting.

See WWDC 2012 for more details on ARC.

New Memory Management Warnings

Improving CoreFoundation and ARC

NSString *string = (__bridge NSString *)CFDictionaryGetValue(_dict, @”key”);

The ARC compiler must reason about object lifetime.

This requires retain count “bridging” in and out of ARC.

+1 via CFBridgingRetain()

-1 via CFBridgingRelease()

0 via “__bridge” casts to avoid mistakes

Common CF APIs now allow implicit bridging.

Related sessions:

WWDC 2013: What’s New in the LLVM Compiler

WWDC 2013: Optimize Your Code Using LLVM


Compilers on the Mac

The version of compiler you’re running will affect all the software you compile.

Unfortunately, the default changes on the Mac. It dependsĀ on:

  • the version of OS X you’re running
  • whether you installed Xcode (and/or the Command Line Tools) and, if so,
  • what version of Xcode you have installed

So, how does it affect the software?

For starters, you’ll find some just doesn’t compile. E.g. take a look at some of the problems installing Ruby under Lion:


So, here’s a small guide.

Compilers have a front-end, that contains the parser and semantic analysis for the programming language and generates an intermediate representation of your code, and a backend which takes the stuff the front-end produced, optimizes it, and generates assembly code.

  • GCC: contains both front-ends for various languages and back-ends for many processor architectures
  • LLVM: a set of back-ends for various architectures
  • clang: a new front-end for C, Objective-C, and C++, uses the LLVM back-ends This generates more readable errors and warnings and shorter compile times. There may also be incompatibilities or bugs as clang is still very young
  • LLVM-GCC: is a GCC front-end with an LLVM back-end. LLVM’s back-end is faster than GCCs

clang’s (Objective-)C++ support is far from being complete so it calls llvm-gcc when it encounters a C++ source file. It also contains the static analyzer that is now integrated into Xcode. Some people say LLVM’s back-end generates better code than GCC’s but your mileage may vary. LLVM also supports link-time optimizations (which you can enable in Xcode’s project settings). They may produce faster code.

Apple wants to replace GCC with clang in the future because they have a policy against GPLv3 licensed code (GCC 4.2 is the last version that’s licensed under GPLv2).

Try it out:

gcc –version
i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5659)

means you’re running gcc.





enum and typedef

Brief intro:

An enum (or enumerated data type) is the C way to define constants for fixed values (like the styles for a table cell).

This declares integer values (Objective-C will assign values by default starting with 0):

This is an anonymous enum. We could give it a name or tag, e.g.

but this isn’t required.

A typedef creates a new type definition with a name and type. The type goes first and the name last:

Note that this is the anonymous version of the two previous enums although the typedef does have a name – UITableViewCellStyle.

Way more here on typedef / enum:

but a couple of short video explanations here:


Note that with iOS6 we have the new NS_ENUM and NS_OPTIONS. E.g.

More on them here:

Object allocation in a class method


Naming conventions:


however, note that the Autorelease stuff is no longer relevant due to ARC. E.g.

Objective-C: find the caller of a method

1. Put in a breakpoint and look in the Stack trace

2. Use this: