Automatic Reference Counting (ARC) in iOS (Part 2)

iOS SDKIn my last blog post, I wrote about ARC and discussed in detailed the __strong and __weak qualifiers, which should cover 80% or more of the use cases out there. In this article, I am going to complete the series by discussing the other two ARC ownership qualifiers __unsafe_unretained and __autoreleasing.

The __unsafe_unretained Qualifier

Variables qualified with __unsafe_unretained are telling the compiler that they do not want to participate in ARC at all. Hence the programmer is responsible for allocating/releasing memory and for handling object lifetimes.

Qualifiers __unsafe_unretained and __weak are actually similar in function. They both claim no ownership of any object that the variables are assigned to (hence “__unretained”) but merely act as a reference the objects. The key difference is that while a __weak variable is assigned to nil after the referenced object is released, a __unsafe_unretained variable to the same object still points to the memory space that was allocated to the object. Because of this, you can’t safely infer if an object has been of disposed with __unsafe_unretained (hence “__unsafe”).

One scenario where you would use __unsafe_unretained is when you declare a data member in a C-struct or union as an Objective-C object like NSString. See below:

struct MyStruct {
  NSString *text; // Won't compile.

You will get an error when you compile the code above. Under ARC, NSObject types can’t be members of a C-struct. This is because the compiler can’t manage the lifetime of a C-struct as it can’t determine the lifetime of a struct member. Therefore the developer must manage  the ownership of the Objective-C object manually (usually through CFRetain and CFRelease). Read here for a full explanation on the use of __unsafe_unretained in C-struct and the compiler error “ARC forbids Objective-C objects in structs or unions.”

struct MyStruct {
  NSString __unsafe_unretained *text; // Now it compiles.

The __autoreleasing Qualifier

From Apple document Transitioning to ARC Release Notes: “__autoreleasing is used to denote arguments that are passed by reference (id *) and are autoreleased on return.”

The __autoreleasing qualifier is used to track objects created outside the scope of the caller but still be “retained” so that the object can be accessed by the caller. __autoreleasing is typically used in a method (eg. see method doSomething: below) that returns a BOOL to indicate if the method call is successful or not. If the method fails, we can then access the NSError object for details of the failure. The NSError object is created in the method and returned as an __autoreleasing object to the caller.

@interface MyClass : NSObject
- (BOOL)doSomething:(NSError * __autoreleasing *)myError;

// ...

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    MyClass *obj = [[MyClass alloc] init];

    NSError * __autoreleasing error = nil;
    NSError * __autoreleasing * ptrToError = &error;

    [obj doSomething:ptrToError];

    // This following works as well. I used a more complex approach
    // above to illustrate the intricacies of __autoreleasing.
    [obj doSomething:&error];

How should we implement doSomething:? If the following won’t work.

- (BOOL) doSomething:(NSError * __autoreleasing *)myError {
  NSError *error = [[NSError alloc] init];
  myError = &error;

  // ...

  return NO;

The problem is that the object variable error is declared implicitly as __strong. And when error varialbe goes out of scope after the control flow leaves doSomething, the error object will be disposed. This won’t work if we want to retain error so that it can be passed back to the caller. To make it work, qualify error with __autoreleasing.

NSError __autoreleasing *error = [[NSError alloc] init];
myError = &error;

Or simply do the following:

- (BOOL) doSomething:(NSError * __autoreleasing *)myError {
  *myError = [[NSError alloc] init];

  // ...

  return NO;

By qualifying the parameter myError as __autoreleasing, we ensure that the NSError object created in doSomething is assigned to the autorelease pool and can be safely assigned to an object variable when the control flow is returned back to the caller.

Last but not least, note that all id * is implicitly qualified with __autoreleasing.

Reference and Further Reading

Automatic Reference Counting (ARC) in iOS (Part I)

iOS SDKPrior to iOS 5 SDK, memory management in Objective-C is a manual process where developers are solely responsible for handling memory allocation and release, and object lifecycles. Apple introduced Automatic Reference Counting (or ARC) in iOS 5 to simplify memory management and made memory management the job of the new LLVM compiler.

Objective-C Memory Management Policy

The best way to understand memory management in Objective-C is to think of object ownership (see Memrory Management Policy for more info). Here are the rules to memory management prior to ARC:

  • You own any object you create – Method names that include alloc, new, copy, or mutableCopy creates an object
  • You can take ownership of an object using retain – An object can have more than 1 owner
  • When you no longer need it, you must relinquish ownership of an object you own – As long as an object has 1 owner, it continue to exist. Ownership to the object is relinquished by calling release. When an object is no longer owned, it gets disposed by the system
  • You must not relinquish ownership of an object you do not own – This is a conventional rule. Break this rule and the app may crash

These rules still apply to ARC even though retain, release, and autorelease are no longer supported in the new model. In ARC the rules are fulfilled automatically in the background and is primarily handled by the compiler. The key to understanding ARC is to distinguish the difference between an object and an object (pointer) variable referencing that object. As soon as there are no owners (or variables pointing) to an object, the system disposes that object. Also it is important to note that there’s no garbage collection in Objective-C. ARC is a compiler-time feature where the compiler analyzes code and insert code to track the lifecycles of objects.

When an object (NSObject type or its subclass) is created, we can assign the object to a variable. In ARC, an object variable can have one of the following 4 ownership qualifiers:

  • __strong
  • __weak
  • __unsafe_unretained
  • __autoreleasing

In this blog post, we will review the first two qualifiers __strong and __weak in detail and save the latter two in the next blog post.

The __strong Qualifier

__strong is akin to retain in non-ARC and it’s the default qualifier of an object variable if no ownership qualifier is specified. The following code snippets are identical.

- (void)nonARC {
  id obj = [[MyClass alloc] init];
  [obj release];

- (void)ARC {
  // Obj has a strong reference to MyClass object so it owns
  // MyClass object.
  id obj = [[MyClass alloc] init];

  // When the object variable goes out of scope, the owner
  // is discarded and consequently relinquishing ownership of
  // MyClass object.

For __strong qualifier, we rely on variable assignment and the end of a variable scope to gain and relinquish object ownership respectively.

The __weak Qualifier

The __weak qualifier is akin to the assign keyword in non-ARC and is typically used to reference an object but claims no ownership on that object. A __weak qualified variable is automatically assigned to nil (effectively disposing the pointer variable) after the object it is pointing to is released. We can perform a conditional check on a __weak qualified variable. If the variable is nil, we know that the referenced object has already been disposed.

__weak qualified variable is useful for for referencing up a parent-child object hierarchy ie. a child object should only establish a weak reference to its parent. For example, a table view can be implemented in iOS by creating a UITableView object and assign it to a UIViewController. Both objects reference each other. UIViewController references UITableView via the view property while UITableView references UIViewController via the delegate property. If we qualify all referencing properties as __strong, we will get into a circular reference situation. Under such circumstances, even though the referencing object variables have gone out of scope, the objects themselves are still not properly disposed. Due to the circular strong reference, the system still thinks that the 2 objects are owned, leading to memory leaks. A detailed explanation of circular reference is available here.

Reference reference between UITableView and UIViewController

The best way to handle circular reference especially if there’s a clear parent-child object relationship is to use a strong/weak reference pattern. UIViewController owns the UITableView object, so it makes sense to qualify this reference with a __strong qualifier. On the other hand, the delegate property in UITableView should be qualified as __weak given that UITableView doesn’t own UIViewController but merely referencing it.

We will talk about __unsafe_unretained and __autoreleasing qualifiers in the next blog post.


Cliff Notes on How We Build Our Frisbee Thrower

Since I uploaded the videos of the frisbee thrower that my team built to YouTube, I have been getting questions about how the machine was constructed. Regretfully, the team dismantled the machine at the end of the project, team members graduated from school and moved across the country/world, and other than the videos, most other notes on the project are now gone.

I still receive plenty of messages and emails from people, especially high-schoolers and teams competing in robotic competitions, asking and requesting for more details on the construction of the frisbee thrower. I haven’t been very helpful since I don’t have all the answers (like the exact technique and parts that we used). I found some notes in my hard drive a year ago and post them to I don’t think they are very useful – they are most sketches of prototypes. Nonetheless you can review them here if you want.

The good news is that I do want to help people who want to build their own version of the frisbee thrower. I will try to talk to from other team members and hopefully write a more detailed article on the construction of the frisbee thrower in the next few weeks. Hopefully, someone out there can learn something and build a more kick-ass frisbee thrower machine.

For now, maybe I can shed some light on the frisbee thrower to the people interested in building the machine by highlighting some of the key elements of the machine. The following video demonstrates how the machine is build. Watch carefully…

YouTube Preview Image

I have also extracted and annotated the following still images in the video that I think are important:

Frisbee thrower prototype (cross section)

Frisbee thrower prototype (top view)

Frisbee thrower (bending the metal guide)

Frisbee thrower (turning the shaft)

Frisbee thrower prototype (adjusting speed of the drill)

UI Design – Lessons Learned, Principles, and Best Practices

This is a presentation I gave earlier this summer on user interface (UI) and user experience (UX) in software. I was motivated to share the lessons that I learned from my own projects as well as my observations I made from working with clients. As I reflected on the UX/UI aspects of the projects, I remember a course I sat in at MIT called 6.831 – UI Design and Implementation. While I didn’t end up taking that class, I learned quite a bit from it. And thanks to MIT OpenCourseware, I can now review the course materials again, which I find very useful. Much of the presentation is adapted and referenced from the course materials archived at MIT OpenCourseware.

Here’s the deck on

HackStar Boston 2011 (Part 2)

TechStarsIn the first part of the article, I recount my HackStar experience at TechStars Boston. Today, I am going to talk about the impact of HackStar has on me and my current endeavor of doing a startup.

Before joining the program, I had thought that my time as a HackStar would be spent mostly coding, which is something I was more than happy to do. While being a HackStar is a lot of hard work, the truth is that I found that there is more than just battening down the hatches and code. To my surprise, HackStars are actually treated as participants of the program, just like any of the team members in the program. While Hackstars don’t get the one-on-one mentorship (since we are not founders), we like the teams have access and participate in activities like lectures, talks, and workshops led by mentors and guest lecturers. Of course there are times when I had to skip a few of the classes and events as I needed to spent more time working in tasks that may be time sensitive. However, I found these lectures and workshops extremely valuable (more so than the classes on entrepreneurship that I took in business school). TechStars lectures and workshops have highly relevant, useful content for starting entrepreneurs to take their startup to the next level. I would encourage any HackStar to attend these classes as much as possible. At the end of the day, it is all about time management and balancing between working on a project and attending classes. Nonetheless, HackStars at TechStars Boston really have unprecedental access and opportunities.

As an entrepreneur who recently started a startup called Invantory, I regularly seek veterans who are doing or have done a startup before. Conversation with them often bring new insights and perspectives, which adds tremendous value and clarity to what I am doing. The network that I built at TechStars has been very beneficial in this regards. Since starting Invantory, I have met with mentors and alumni asking them for their help and advice. In fact, many of them were enthusiastic about helping me in my endeavor. I have also found it gratifying to see how the teams grew in maturity and confidence during the course of the program. I am happy for the alumni of TechStars 2011, with whom I still maintain close interpersonal relationship. I really enjoyed the camaraderie of TechStars Boston.

I have had a long career working in big firms. Nonetheless I have always contemplated with starting my own company and struggled in pondering what is best for me. Do I choose job security and stability over starting my own startup with no or little money? The HackStar program provided that opportunity for aspiring entrepreneurs like me to try out the startup life for 3 months and gain skills that they can immediately apply when they can become real entreprneurs. The program has influenced my outlook, identified seeing what is missing, and discovering what are needed to be done in the context of building my startup.

TechStars’s official HackStars webpage provides a pretty comprehensive list of compelling reasons for joining HackStar. But if you are an aspiring entrepreneur and that your objective is to gain more exposure as well as expanding your network in this space, the choice is a no-brainer. Feel free to reach out to me if you have any questions about the program.

HackStar Boston 2011 (Part 1)

TechStarsIn this blog I hope to share my personal insights to TechStars Boston, a startup accelerator program, from the perspective of a HackStar. The term HackStar is a TechStars slang for a hacker (typically a software developer, a UX designer, or any technical contributor) who provides his/her time and technical skills to help companies selected for the program to become viable businesses by the end of the program. I joined TechStars Boston class of 2011 as a Hackstar in March 2011. For me, I didn’t apply for the program directly or formally. In fact the process happened quite impromptu. I first learned about the program from friends Brent and Eric at Everture, one of the incoming teams, two days before the start of the program. As I already know the managing staff at TechStars, I quickly arranged a meeting to meet with them to learn more about the program before being invited to join the program as a HackStar by the end of the day. The opportunity was great timing since I was transitioning from the industry to the freelance consultancy and entrepreneurship space in the software and Internet space. I already had some spare capacity which allowed me to commit to the program full-time. I also can’t pass up the opportunity of working with the incoming TechStars cohort and learning more about doing a startup. So my decision was really a no brainer. I accepted the invitation and joined the program.

TechStars Boston 2011 WorkshopThere were 12 teams that participated in TechStars Boston 2011. The teams brought a diverse background to the program. Geographically, half of the team were from outside of Boston with 3 teams from the UK, Estonia, and Israel. There was also more female representation in the program with 2 female founders and 1 female co-founder. The teams represent a pretty diverse group of businesses ranging from enterprise software to game to even hardware. I just love the diversity of the cohort. One of the important aspects of TechStars Boston has always been the people. The staff, teams, interns, and HackStars at TechStars Boston are all part of a very big, fun family. Everyone learn from each other. It’s an amicable, highly-collaborative environment. Teams and HackStars collaborated with each other. HackStars have as much to receive and learn from the teams as they do in contributing to the teams. Strong relationships extend beyond the program. TechStars also fosters building strong relationships with mentors, investors, and the startup community. The program invited veterans in the startup space to come mentor the teams or run workshops with variety of topics that are pertinent to the success of the companies.

Skill sets and seniority can very considerably among HackStars. However that didn’t distinguish any HackStar from the others. We are all equals despite our age, seniority, and background. HackStars assist anyone (staff and teams) in every way possible. Nonetheless, it is easy to get overwhelmed sometimes. HackStars could be assigned to a team long-term or be allocated to different teams or projects for quick hacks. There were 12 teams in our cohort and every team needed engineering help in some form or capacity. As a result, it was important to coordinate any work with the managing director. Katie Rae, the managing director at TechStars Boston, often asked for our preference in the types of projects we are interested in working. This helps her to coordinate and manage the needs as well as interests between the teams and Hackstars. The first six weeks at TechStars can be overwhelming for everyone. Something that I learned in my former job is that the busier people get, the more important it is for everyone to meet and sync up on a regular basis. One advice I have for any HackStar reading this post is that you should try meeting with the managing director at least once a week to sync up even if it is for 10 minutes. During the meeting, try to provide some feedback of the teams, update him/her what you are doing, and mention any coming tasks (standard stand-up meeting format from the Agile methodology). In general, there is no right or wrong way of doing things. The HackStar program, just like TechStars is constantly evolving. It’s a startup environment, so don’t be afraid to be a self-starter and be creative, while staying professional (always).

There are more I would want to write. But I have babbled enough (for now). I will continue the second part of this article in the next blog post tomorrow.

Blogging (Again)

BloggingI am ashamed of myself. I have not been updating this blog for sometime. So when my business partner Ian wrote a blog post on our company blog about derelict blogging and why it may not be good for everyone, I realize that something need to be done with this blog site. I can’t just leave it untended. So it’s blogging time again.

HTTP basic access authentication with Objective-C and iOS

iOS SDKIn this blog post I am going to show how you can make an HTTP request to a webserver that supports basic access authentication using Objective-C and the iOS framework. Regretfully, I don’t have the time to create an Xcode project as an example. But the information and code should give you an idea of how you can build basic access authentication support in your iOS code.

Before we dive into the code, let’s do a quick review of how basic access authentication works. Before an HTTP request is sent to the server, we need to append an HTTP header called Authorization to the request. Here are the steps to generating the Authorization HTTP header:

Using username = myusername and password = mypassword as reference.

  1. Concatenate user name + colon + password. ie. “myusername:mypassword”
  2. Encode the concatenated string with the base64 algorithm. ie. “myusername:mypassword becomes” “bXl1c2VybmFtZTpteXBhc3N3b3Jk”
  3. Append the Base64 encoded string to the “Basic ” string. ie. “Basic bXl1c2VybmFtZTpteXBhc3N3b3Jk”
  4. Finally assign the value to the Authorization header

In Objective-C code, the above logic is translated to:

NSString *authStr = [NSString stringWithFormat:@"%@:%@", @"myusername", @"mypassword"];
NSData *authData = [authStr dataUsingEncoding:NSUTF8StringEncoding];
NSString *authValue = [NSString stringWithFormat:@"Basic %@", [authData base64Encoding]];
[request setValue:authValue forHTTPHeaderField:@"Authorization"];

Just one problem, NSData doesn’t inherently support Base64 encoding. We need to add Base64 encoding algorithm to NSData via Category, a mechanism Objective-C that allows programmers to extend an existing class without subclassing it. Anyway, you can download the Base64 encoding code below.

NSData+Additions source code

Credits and Reference:

Note that you can certainly implement Base64 encoding using C functions or by other means. But I find Category most intuitive to achieving our goal.

If you are still stuck, use the curl command on a shell to troubleshoot. Here are some examples:

% curl -v -H 'Authorization: Basic bXl1c2VybmFtZTpteXBhc3N3b3Jk' 'http://host/path'

% curl -v --trace-ascii dump.txt 'http://myusername:mypassword@host/path'

Creating multi-variants of an iOS app from a single Xcode project

iOS SDKWhen someone at work asked me about creating multiple variants of an iOS app  from a common codebase (ie. from a single Xcode project), I thought couldn’t this be achieved through defining multiple targets in that Xcode project?

I have done this before for a project where I created a “lite” version and an “HD” (iPad-only) version from a full-featured iPhone codebase I originally created. I was about to document the process on this post before coming across this blog post from Just2Us, which does a great job in explaining the entire process. Instead of duplicating the content, just refer to the blog post.

One thing I would do differently from what is described in the referenced post is that instead of adding a new target, I would recommend duplicating an existing target – this way I avoid the hassle of configuring the new build target and including the files to my target phases manually.

Duplicating a build target in Xcode

I have also created a project to demonstrate the multi-target in Xcode. You can download the file here.

Quick guide to iOS dateformatting


This blogpost will focus on the setDateFormat: method of NSDateFormatter which allow us to define the date format of the textual representation of the date and time in iOS/Cocoa. Here’s a summary of the specifiers used in the date format string.

The most commonly used date format specifiers are (keep in mind that they are case sensitive):

  • y = year
  • Q = quarter
  • M = month
  • w = week of year
  • W = week of month
  • d = day of the month
  • D = day of year
  • E = day of week
  • a = period (AM or PM)
  • h = hour (1-12)
  • H = hour (0-23)
  • m = minute
  • s = second

In general, the number of characters in a specifier determine the size of date field. Let’s use an example to illustrate date formatting.

eg. Input date = 2011-05-01 Sunday

1-character = 1-digit/character number or word (if number/word can’t be 1 character long then abbreviation or fullname is displayed).

[dateFormatter setDateFormat:@"E, d M y"];  // Output: Sun, 1 5 2011

2-character = 2-digit/character number or word (if number/word can’t be 2 character long then abbreviation is displayed).

[dateFormatter setDateFormat:@"EE, dd MM yy"];  // Output: Sun, 01 05 11

3-character = 3-digit/character number or word, or abbreviation (generally).

[dateFormatter setDateFormat:@"EEE, ddd MMM yyy"];  // Output: Sun, 001 May 2011

4-character = full name (generally).

[dateFormatter setDateFormat:@"EEEE, dddd MMMM yyyy"];  // Output: Sunday, 0001 May 2011

Here’s the weird part though, if you specify 5 E’s, you get an rather unexpected output. You would think that the output date field would be longer than 1 character:

[dateFormatter setDateFormat:@"EEEEE, ddddd MMMMM yyyyy"];  // Output: S, 00001 M 2011

For date formatting, the following reference table has been very useful:

Date Field Symbol Table (UTS #35 Unicode Locale Data Markup Language)