What Is ARC?

For those of us who deal with dynamic languages for our days jobs, memory management isn’t something we find ourselves thinking about too frequently. I did low level programming like C and C++ in college, but long gone are the days of malloc/free, alloc/dealloc, new/delete and constructor/deconstructors.

For web developers/JavaScript developers the idea of dealing with memory might seem intimdating, but it’s pretty straight forward. It happens under the covers for you already, and it’s usually the case that understanding how it works can sometimes help you improve your code.

ARC stands for Automatic Reference Counting. In non-memory managed languages (C, C++, Objective-C…etc) you would have to ask the OS for memory for each of the object your system wish to hold in memory, and when you’d finished with it you’d need to release that memory. It’s all about being a good citizen, and in contrained environments like iOS, being greedy/inefficient can get you app killed by the OS.

In the old days there used to be the concept of reference counting, which is convention of managing memory/objects manually in your application. The idea being that your objects/data could have complex relationships and you can’t just discard the memory/object as soon as you hit the end of a particular method. So what you’d do is when you’d create an object, there would be a system that you would tell that, “I have created this object, and it is being used/owned by this other parent object thing, don’t destroy it”. Later that parent object would relinquish control over the object by decrementing the counter and as soon as the underlying reference system saw a count hit zero the system would destroy the object and free up memory to the OS.

ARC was a technology designed by Apple that does all the complex donkey working of incrementing/decrementing counters automatically for you. ARC is not “garage collection” as you might know it in a virtual machine. It is done at compile time. Where as VMs have a complex technology that traces an object throughout it’s lifecycle, reference counting adds a little overhead to each object to hang onto it’s references counter information. In a traced garage collecting system it does all these crazy algorithms where it traces the object, and moving between these zones, anyway, too complicated to explain here.

The logo of the LLVM compiler

ARC is possible thanks to technology baked into the CLang compiler system. Along as you give CLang the right pieces of general information that present how various object relate to one another, it would inject the reference counting calls into your code at compile time. That way when you system ran it would do so as though it was a hand code memory managed system.

There are reasons why you’d prefer garbage collection over reference counting. It’s clear that GC has won the world (look at the .NET stack for instance). Objective-C and Swift are reference counted because of the nature of the underlaying technologies. It’s likely if the system were redesigned all over again, it would use some sort of traced garage collector. But don’t quote me on that, I’m still learning about all this stuff.

If you want to learn more about the guts of ARC, read the Apple docs on “Transitioning to ARC Release Notes”.