In the early 1980s, two engineers from the company StepStone, named Brad J. Cox and Tom Love, designed a C-based language inspired by SmallTalk-80. Their goal was to implement an object-oriented extension to the C language. The result was called Objective-C.

In 1985, Steve Jobs founded NeXT, a computer platform development company specializing in the higher education and business markets.

In 1988, NeXT licensed Objective-C from StepStone and wrote libraries and a compiler to build NeXTSTEP’s user interface and interface builder. NeXTSTEP, NeXT’s Unix-based operating system was particularly notable because of its focus on object-oriented programming and its many powerful toolkits.

Writing applications for NeXTSTEP was known to be far easier than on many competing systems. The UI was consistent and refined. Tim Berners-Lee, credited as the inventor of the World Wide Web, wrote the very first web browser, called WorldWideWeb, in 1990 on NeXT (Figure 3.1, “Screenshot of WorldWideWeb, the very first web browser”), and even claimed that he could not have done what he did as easily if he had to use other technologies.

Figure 3.1. Screenshot of WorldWideWeb, the very first web browser

WorldWideWeb was not the only ground-breaking application developed on NeXTSTEP. Apple’s Interface Builder, the initial implementations of Doom, Macromedia FreeHand, and Lotus Improv were also built on that platform.

In 1996, NeXT was acquired by Apple, which used parts from NeXTSTEP and from the open source Berkeley Software Distribution systems to build its new operating system: Mac OS X. The new OS included Objective-C as well as NeXT’s developer and interface tools/frameworks, which became the base of the Cocoa API.

What’s known as the Cocoa API is really a collection of several frameworks. More precisely, it is what is known as an “umbrella framework,” a framework built up from other frameworks.

In this context, when we talk about frameworks, we are referring to application frameworks, which are usually a collection of advanced object-oriented APIs allowing software developers to work in a specific development environment.

Developers writing applications usually spend a lot of time coding the same features over and over: creating and managing a window, creating a menu and menu items, handling undos and redos, and so on.

Apple, and NeXTSTEP before them, saw the need to streamline the application development process. To do that, the two companies decided to provide developers with all the common features required to build Mac OS X applications. OS X developers can rely on these building blocks to focus on the unique values of their applications instead of constantly reinventing the wheel.

Cocoa takes advantage of common object-oriented design patterns and best practices identified and implemented by NeXTSTEP, resulting in a dynamic, mature, consistent, and extensive set of libraries.

The Cocoa API minimum set is an umbrella framework called Cocoa.framework. When loading this framework, you really load three Objective-C frameworks: Foundation, AppKit, and CoreData.

But more than a collection of APIs, the Cocoa framework enforces conventions when it comes to the UI. By using the APIs, you buy into Apple’s view of how the user should see and interact with the device. These conventions also allow for tools such as Xcode to exist and to leverage APIs, while enforcing a consistent user experience.

Apple’s Reference Library will soon become your best friend. It describes all the Objective-C methods, C functions, and constants made available by the Cocoa API and other various related frameworks. Thanks to MacRuby, they are all accessible to you.

You can access this reference API offline by using Xcode, or online at http://developer.apple.com.

After you connect to the Apple Developer Connection website, choose the Mac Dev Center. At this point, if you haven’t created an account, you might want to sign up. Signing up is free and will give you access to the latest version of the Xcode package, as well as some development videos.

In the Development Resources section of the page, you will find some sample code and training videos, but more important, the Mac Reference Library.

The library is maintained and kept up to date by Apple. You will notice that the documents are organized by types, topics, and frameworks. If you find a document that you are interested in, you can download it as a PDF to consult it later offline.

Let’s do a search on NSDate and open the NSDate Class Reference page (Figure 3.2, “NSDate class reference”). API reference documents appear basically the same whether you view them online or via Xcode.

Figure 3.2. NSDate class reference

It’s important to understand how the documentation is structured, so you can efficiently find the information you need when you need it.

Before looking a bit at some key Cocoa classes, we need to talk about mutability. By definition, an immutable object is an object whose state cannot be modified after being created. In contrast, a mutable object can be modified after creation.

Some Cocoa classes even come in two separate versions, mutable and immutable. Mutable classes descend from their nonmutable counterparts and therefore share the same methods. The main reason for having both classes is that immutable classes are optimized to be more efficient, based on the expectation that their contents are fixed:

framework 'foundation'
mutable_array = []           # => []
mutable_array << 'foo'       # => ["foo"]


immutable_array = NSArray.alloc.initWithArray(['foo', 'bar'])  # => ["foo", "bar"]
immutable_array << 'foo'  # RuntimeError: can't modify frozen/immutable array

Ruby classes are usually mutable, but the state of a Ruby object can be frozen. In other words, in Ruby, you can make a mutable object immutable by freezing it. Cocoa accomplishes this by having two versions of a class, a mutable version and an immutable version:

my_string = "Understanding Ruby"
my_string.freeze
my_string.upcase! # => RuntimeError: can't modify frozen string

array = Array.new   # => []
array << 'foo'      # => ["foo"]

array.freeze
array << 'bar'      # RuntimeError: can't modify frozen/immutable array

Now it’s time to get a quick tour of some of the classes you are going to encounter frequently.