Before we get into the details of ARC, we need to rewind the time machine to a previous epoch. The year is 1988, and Objective-C is licensed by NeXT and starting to make its way into their operating system. In 1996, Apple acquires NeXT, alongside the release of OS X, a new and modern toolchain based on Objective-C. Objective-C is a strict superset of C, which means that any valid C code is valid Objective-C code, but unlike C, Objective-C has a modern and efficient memory management engine, based on reference counting.

Reference counting is a technique that accounts for the exact number of references to a particular object that exist at any given time in the memory. Once there are no references, an object, it is deallocated. This is a very different memory management technique, as compared to garbage collection, which you can find in Java...

Automatic Reference Counting was introduced at the 2011 WWDC, in Session 323. If you want to see the original presentation, feel free to visit https://developer.apple.com/videos/play/wwdc2011/323/. 

ARC is made possible by Clang and LLVM. LLVM and Clang are two technologies that enable compiling C, C++, and Objective-C code. LLVM is also used alongside the Swift compiler. With ARC, a Clang feature, developers don't have to write the tedious retain and release calls. There are multiple benefits to letting the compiler handle it, as follows:

• Memory management is difficult
• The compiler is often more correct than you are
• There are fewer lines of code to write
• It has the same performance as manual reference counting

With Swift being a modern language and the successor of Objective-C, you've never had to call retain. Swift programs...

Xcode and Swift come with a powerful memory debugging infrastructure, letting you inspect the contents of existing and destroyed objects, inspect the contents and relationships between your objects, and more. In this section, we'll get you started with these powerful tools, so that later on, you'll be able to debug complicated pieces of code with ease.

In order to see the memory allocation backtraces, we need to enable Malloc Stack in our Scheme. You can do so by following these steps:

1. Open your Scheme settings with ⌘ | <, or by navigating to Product | Scheme | Edit Scheme...
2. Navigate to the Diagnostics tab

3. Ensure that you select the options shown in the...

Let's dive into examples of the two most common issues: leaks and crashes related to memory issues. A memory leak occurs when one or many objects become unreachable from the rest of your program but still, in one way or another, form a cycle.

In the first example, we'll look at how to effectively leak memory, using Xcode's powerful memory graph hierarchy tool to track down issues.

In the second example, we'll explore how to debug and investigate crashes related to accessing properties that may have been deallocated.

One common way to leak objects and their memory is to create strong references between different instances, and cut off any external...

In this chapter, we explored the origins of ARC, the performant memory management paradigm available in Swift. With great power comes great responsibility, so you're still required to design your memory model with ARC in mind; failing to do so will lead to memory leaks or crashes caused by dangling pointers. By now, you should be comfortable with the advantages and drawbacks of both weak and unowned references. You should also understand why weak or unowned don't apply to value types. Last but not least, you should now be comfortable with setting your project up to efficiently debug memory with the tools from Xcode.

ARC sits at the compiler level, injected into your code as it is built. In the next chapter, we'll continue to refresh the basics and stretch our muscles, as we explore Foundation and the standard library.