Here you are, at the start of the final chapter of this book. Congratulations on the great job you’ve done throughout this journey! The advanced topic for this chapter is key-value programming, a set of language mechanisms and APIs that can enable you to both simplify program design and also implement more extensible and reusable code. The Objective-C key-value programming features are collectively referred to as key-value coding (KVC) and key-value observing (KVO). Key-value coding enables your code to access and manipulate an object’s properties indirectly, by name (i.e., key), rather than through accessor methods or backing instance variables. Key-value observing enables objects to be notified of changes to the properties of other objects. In this chapter, you will learn the fundamentals of these technologies, key implementation details, and how to use them in your programs.

Key-Value Coding

As stated earlier, key-value coding is a mechanism for accessing an object’s properties. In Chapter 2 of this book, you learned that properties encapsulate an object’s internal state. This state is not accessed directly, but rather using properties’ accessor methods (also known as getter and setter methods). The compiler can generate these methods automatically (according to the property declaration). This reduces the amount of code to write and also facilitates program consistency and maintainability. In the following code fragment, a class named Hello declares a property named greeting of type NSString.

@interface Hello : NSObject
@property NSString *greeting;
...
@end

This property can be accessed using either standard property accessors or dot notation syntax (recall that the compiler transforms property dot notation expressions into their corresponding accessor method invocations). Given a Hello instance named helloObject, the value for the greeting property can be retrieved using either of the following expressions:

[helloObject greeting]
helloObject.greeting

Conversely, the value for the greeting property can be set using either of the following expressions:

[helloObject setGreeting:newValue]
helloObject.greeting = newValue

Recall that a property's backing instance variable can also be accessed directly if the object associated with the property is not fully constructed (i.e., if the variable is accessed within a class init or dealloc method). The init method for the Hello class accesses the backing instance variable of the greeting property in Listing 18-1.

Listing 18-1.  Accessing a Property’s Backing Instance Variable

@implementation Hello
- (id)init
{
  if ((self = [super init]))
  {
    _greeting = @"Hello";
...
}

Note that these mechanisms for accessing a property are compile-time expressions, and hence tightly couple the calling code to the receiver object. With that background, you can now examine key-value coding. In a nutshell, it provides a key-value pair mechanism for accessing a property, where the key is the property’s name and the value is the property value. Now this mechanism should already be familiar to you, as it is identical to that used to access entries in a dictionary (e.g., an NSDictionary instance). For example, given a Hello instance named helloObject, the following expression uses key-value coding APIs to retrieve the value of the greeting property.

[helloObject valueForKey:@"greeting"]

Observe that the key provided is the name of the property, in this case greeting. Key-value coding APIs can also be used to set the value for the greeting property.

[helloObject setValue:@"Hello" forKey:@"greeting"]

OK, so this is all fine and good, but you may still be wondering, “What’s the advantage of using KVC to access properties versus the standard property accessor methods?” Well to begin with, key-value coding allows you to access a property using a string that can be varied at runtime, and thus provides a more dynamic, flexible approach for accessing and manipulating an object’s state. The following are several of the key benefits to key-value coding:

• Configuration-based property access. KVC enables your code to access properties using a parameter-driven, common API.
• Loose coupling. Use of KVC for property access reduces coupling between software components, thereby improving software maintainability.
• Simplifies code. KVC can reduce the amount of code that you have to write, particularly in scenarios where you need to access a specific property based on a variable. Instead of using conditional expressions to determine the correct property accessor method to invoke, you can employ one KVC expression using the variable as its parameter.

Let’s say that you need to dynamically update the state of a model based on an input from the user. Listing 18-2 provides an implementation of this logic using standard property accessors.

Listing 18-2.  Updating Model State Using Standard Property Accessors

- (void)updateModel:(NSString *)value forState:(NSString *)state
{
  if ([state isEqualToString:@"species"])
  {
    [self setSpecies:value];
  }
  else if ([state isEqualToString:@"genus"])
  {
    [self setGenus:value];
  }
  ...
}

As shown in Listing 18-2, this method uses conditional expressions and standard property accessors to update the value of the correct property. Although functional, this implementation doesn’t scale well and is difficult to maintain because the code must be updated whenever the property names and/or number of properties changes. Contrast that with Listing 18-3, which implements the same logic using key-value coding.

Listing 18-3.  Updating Model State Using Key-Value Coding

- (void)updateModel:(NSString *)value forState:(NSString *)state
{
  [self setValue:value forKey:state];
}

Comparing the two listings, it should be pretty obvious to you that the KVC-based implementation is a vast simplification over the earlier approach. As shown in Listing 18-3, KVC can greatly reduce the amount of code that you have to write to implement this type of logic. Compared to Listing 18-2, it is also easier to both maintain and evolve because changing the properties of the model does not require any updates to the method (shown in Listing 18-3) that uses KVC.

person.name.firstName = @"Bob";

[person setValue:@"Bob" forKeyPath:@"name.firstName"];

NSString *name = [person valueForKeyPath:@"name.firstName"];

NSArray *personKeys = @[@"name", @"address"];
NSDictionary *personValues = [person dictionaryWithValuesForKeys:personKeys];

Name *tom = [Name new];
Address *home = [Address new];
NSDictionary *personProperties = @{@"name":tom, @"address":home};
[person setValuesForKeysWithDictionary:personProperties];

KVC Design and Implementation

The design of key-value coding is based on the following two fundamental constructs:

• A mechanism that can be used to access the properties of an object indirectly by name (or key), rather than through direct invocation of accessor methods.
• A mechanism for mapping keys to the appropriate property accessor methods and/or property backing variables.

The NSKeyValueCoding informal protocol defines the mechanism for accessing objects indirectly by name/key. This protocol declares the key-value coding API, consisting of class and instance methods along with constant values. The methods enable you to get and set property values, perform property validation, and change the default behavior of the key-value coding methods for getting property values. Earlier in this chapter, you used several of these APIs (e.g., valueForKey:, selectValue:forKey:, etc.). NSObject provides the default implementation of the NSKeyValueCoding protocol, and thus any class that descends from NSObject has built-in support for key-value coding.

@implementation Hello
...
- (id)valueForUndefinedKey:(NSString *)key
{
  if ((nil != key) && ([@"hi" isEqualToString:key]))
  {
    return self.greeting;
  }
  [NSException raise:NSUndefinedKeyException
              format:@"Key %@ not defined", key];
  return nil;
}
...
@end

NSMutableArray *items = [order mutableArrayValueForKey:@"items"];

- (Type)person;
- (void)setPerson:(Type)newValue;

- (BOOL)isPerson;

- (NSString *)address
- (void)setAddress:(NSString *)

- (NSUInteger)countOfPeople
{
  return [self.people count];
}

- (Person *)objectInPeopleAtIndex:(NSUInteger)index
{
  return [self.people objectAtIndex:index];
}

- (NSEnumerator *)enumeratorOfPeople
{
  return [self.people objectEnumerator];
}

- (Person *)memberOfPeople:(Person *)obj
{
  return [self.people member:obj];
}

validate<Key>:error:

- (BOOL)validateCity:(id *)value error:(NSError * __autoreleasing *)error
{
  if (*value == nil)
  {
    if (error != NULL)
    {
      *error = [NSError errorWithDomain:@"Invalid Property Value (nil)"
                                   code:1
                               userInfo:nil];
    }
    return NO;
  }
  return YES;
}

- (BOOL)validate<Key>:(id *)value error:(NSError **)error;

NSError *error;
NSString *value = @"San Jose";
BOOL result = [address validateValue:&value forKey:@"city" error:&error];
if (result)
{
  [address setValue:value forKey:@"city"];
}

[email protected]

@interface OrderItem : NSObject

@property NSString *description;
@property NSUInteger *quantity;
@property float *price;

@end

NSNumber *totalPrice = [orderItems valueForKeyPath:@"@sum.price"];

NSNumber *totalItems = [orderItems valueForKeyPath:@"@count"];

NSArray *itemTypes = [orderItems
                      valueForKeyPath:@"@distinctUnionOfObjects.description"];

@interface Order : NSObject

@property NSArray *items;

@end

NSNumber *totalItems = [order valueForKeyPath:@"items.@count"];

Key-Value Observing

Key-value observing (KVO) is a mechanism that enables objects to be notified of changes to the properties of other objects. It is essentially an implementation of the observer software design pattern, and is implemented in numerous software libraries and frameworks. In fact, it is a key component of the model-view-controller (MVC) design pattern, a central component of the Cocoa and Cocoa Touch frameworks. Key-value observing provides numerous benefits, including the decoupling of observer objects from the object being observed (i.e., the subject), framework-level support, and a full-featured set of APIs. The following example uses key-value observing to register an Administrator object as an observer of the name property of a Person instance named person.

Administrator *admin = [Administrator new];
[person addObserver:admin
         forKeyPath:@"name"
            options:NSKeyValueObservingOptionNew
            context:NULL];

Invoking the addObserver:forKeyPath:options:context: method creates a connection between the subject and the observer object. When the value of the observed property changes, the subject invokes the observer’s observeValueForKeyPath:ofObject:change:context: method. In this method, an observer class implements logic to handle the property change. A subject automatically invokes this method when the value of an observed property is changed in a KVO-compliant manner, or the key on which it depends is changed. Observers must implement this method for key-value observing to work properly. Listing 18-13 provides an example implementation of this method for the Administrator class.

Listing 18-13.  Example Implementation of observeValueForKeyPath:ofObject:change:context: Method

@implementation Administrator

...
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
        change:(NSDictionary *)change context:(void *)context
{
  if ([@"name" isEqual:keyPath])
  {
    // Insert logic to handle update of person's name
    ....
  }
  // Invoke the superclass's implementation if it implements this!
  [super observeValueForKeyPath:keyPath
                       ofObject:object
                         change:change
                        context:context];
}
...

@end

The NSKeyValueObserving informal protocol defines the API for key-value observing. Its methods enable change notification, registering observers, notifying observers of changes, and customizing observing. NSObject provides the default implementation of the NSKeyValueObserving protocol, and thus any class that descends from NSObject has built-in support for key-value observing. In addition, you can further refine notifications by disabling automatic observer notifications and implementing manual notifications using the methods in this protocol.

Administrator *admin = [Administrator new];
[person addObserver:admin
         forKeyPath:@"name"
            options:NSKeyValueObservingOptionNew
            context:NULL];
[person removeObsserver:admin forKeyPath:@"name"];

- (void)changeName:(Name *)newName
{
  [self willChangeValueForKey:@"name"];
  self.name = newName;
  [self didChangeValueForKey:@"name"];
}

+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
{
  NSSet *keyPaths = [super keyPathsForValuesAffectingValueForKey:key];
  if ([key isEqualToString:@"zip"])
  {
    NSArray *affectingKeys = @[@"street", @"city", @"state"];
    keyPaths = [keyPaths setByAddingObjectsFromArray:affectingKeys];
  }
   
  return keyPaths;
}

KVO Design and Implementation

Key-value observing is implemented through the power of the Objective-C runtime. When you register an observer on an object, the KVO infrastructure dynamically creates a new subclass of the object’s original class. It then adjusts the isa pointer of the object to point to the subclass; thus messages to the original class will actually be sent to the subclass. You may recall from Chapter 8 that the isa pointer points to the object’s class and this class maintains a dispatch table with pointers to the methods the class implements. The new subclass implements the KVO infrastructure. It intercepts messages to the object and inspects them for those matching certain patterns (such as the getters, setters, and collection access), posting notifications to observers, and so forth. This technique of dynamically swapping out the class that the isa pointer points to is called isa-swizzling.

Using Key-Value Programming

Now you will implement an example program that uses key-value programming to perform a variety of tasks. The program demonstrates the use of key-value coding and key-value observing in a system whose class diagram is depicted in Figure 18-2.

In Xcode, create a new project by selecting New Project . . . from the Xcode File menu. In the New Project Assistant pane, create a command-line application. In the Project Options window, specify Coders for the Product Name, choose Foundation for the Project Type, and select ARC memory management by checking the Use Automatic Reference Counting check box. Specify the location in your file system where you want the project to be created (if necessary, select New Folder and enter the name and location for the folder), uncheck the Source Control check box, and then click the Create button.

You’re going to create several classes here that declare various properties. Select New File . . . from the Xcode File menu, select the Objective-C class template, and name the class Person. Select the Coders folder for the files location and the Coders project as the target, and then click the Create button. Next, in the Xcode project navigator pane, select the Person.h file and update the class interface, as shown in Listing 18-17.

Listing 18-17.  Person Class Interface

#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (readonly) NSString *fullName;
@property NSString *firstName;
@property NSString *lastName;

- (id)initWithFirstName:(NSString *)fname lastName:(NSString *)lname;

@end

The interface declares three properties and a single initialization method. A Person has a first name, last name, and full name.  The fullName property is read-only, and is derived from the firstName and lastName properties. Next, use the Xcode project navigator to select the Person.m file and code the implementation, as shown in Listing 18-18.

Listing 18-18.  Person Class Implementation

#import "Person.h"
#define CodersErrorDomain   @"CodersErrorDomain"
#define kInvalidValueError  1

@implementation Person

- (id)initWithFirstName:(NSString *)fname lastName:(NSString *)lname
{
  if ((self = [super init]))
  {
    _firstName = fname;
    _lastName = lname;
  }
   
  return self;
}

- (NSString *)fullName
{
  return [NSString stringWithFormat:@"%@ %@", self.firstName, self.lastName];
}

- (BOOL)validateLastName:(id *)value error:(NSError * __autoreleasing *)error
{
  // Check for nil value
  if (*value == nil)
  {
    if (error != NULL)
    {
      NSDictionary *reason = @{NSLocalizedDescriptionKey:
                               @"Last name cannot be nil"};
      *error = [NSError errorWithDomain:CodersErrorDomain
                                   code:kInvalidValueError
                               userInfo:reason];
    }
    return NO;
  }
  // Check for empty value
  NSUInteger length = [[(NSString *)*value stringByTrimmingCharactersInSet:
                       [NSCharacterSet whitespaceAndNewlineCharacterSet]] length];
  if (length == 0)
  {
    if (error != NULL)
    {
      NSDictionary *reason = @{NSLocalizedDescriptionKey:
                               @"Last name cannot be empty"};
      *error = [NSError errorWithDomain:CodersErrorDomain
                                   code:kInvalidValueError
                               userInfo:reason];
    }
    return NO;
  }
  return YES;
}

+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
{
  NSSet *keyPaths = [super keyPathsForValuesAffectingValueForKey:key];
  if ([key isEqualToString:@"fullName"])
  {
    NSArray *affectingKeys = @[@"firstName", @"lastName"];
    keyPaths = [keyPaths setByAddingObjectsFromArray:affectingKeys];
  }
   
  return keyPaths;
}

@end

The initWithFirstName:lastName: method is used to initialize a Person instance with the input first and last names. The accessor method fullName returns the derived value of a Person object’s full name as the concatenation of the firstName and lastName property values. The validateLastName:error: method is used to perform KVC property validation on the lastName property. It returns NO and an NSError object if the input last name is nil or an empty string; otherwise, it returns YES. The keyPathsForValuesAffectingValueForKey: method registers dependent keys. The method utilizes the fullName property, which depends on the firstName and lastName properties, to obtain the keys that are added to the returned key path.

Next, you will implement the Coder class. Select New File . . . from the Xcode File menu, select the Objective-C class template, and name the class Coder. Select the Coders folder for the files location and the Coders project as the target, and then click the Create button. In the Xcode project navigator pane, select the Coder.h file and update the class interface, as shown in Listing 18-19.

Listing 18-19.  Coder Class Interface

#import <Foundation/Foundation.h>

@class Person;
@interface Coder : NSObject

@property Person *person;
@property NSMutableArray *languages;

@end

The class declares two properties: a Person property named person, and an NSMutableArray property named languages. The languages property is an array that contains the names of programming languages that a Coder uses. Notice that a @class directive is used to forward declare the Person class, thereby removing the need to import its header file in this interface. Now use the Xcode project navigator to select the Coder.m file and code the implementation, as shown in Listing 18-20.

Listing 18-20.  Coder Class Implementation

#import "Coder.h"

@implementation Coder

- (NSUInteger)countOfLanguages
{
  return [self.languages count];
}

- (NSString *)objectInLanguagesAtIndex:(NSUInteger)index
{
  return [self.languages objectAtIndex:index];
}

- (void)insertObject:(NSString *)object inLanguagesAtIndex:(NSUInteger)index
{
  [self.languages insertObject:object atIndex:index];
}

- (void)removeObjectFromLanguagesAtIndex:(NSUInteger)index
{
  [self.languages removeObjectAtIndex:index];
}

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context
{
  NSString *newValue = change[NSKeyValueChangeNewKey];
  NSLog(@"Value changed for %@ object, key path: %@, new value: %@",
        [object className], keyPath, newValue);
}

@end

The Coder implementation includes the KVO-recommended methods for the ordered, to-many relationship of the languages property. The observeValueForKeyPath:ofObject:change:context: method is executed when a Coder property with the input key path is changed. In this case, the method just prints out the new value for the object and key path in question.

Finally, you will implement the Coders class. As depicted in Figure 18-2, the Coders class holds a collection (an NSSet) of Coder instances. Select New File . . . from the Xcode File menu, select the Objective-C class template, and name the class Coders. Select the Coders folder for the files location and the Coders project as the target, and then click the Create button. Next, in the Xcode project navigator pane, select the Coders.h file and update the class interface, as shown in Listing 18-21.

Listing 18-21.  Coders Class Interface

#import <Foundation/Foundation.h>

@class Coder;
@interface Coders : NSObject

@property NSSet *developers;

@end

The Coders interface declares a single property, an NSSet named developers that contains the collection of Coder objects. Now use the Xcode project navigator to select the Coders.m file and code the implementation, as shown in Listing 18-22.

Listing 18-22.  Coders Class Implementation

#import "Coders.h"

@implementation Coders

- (NSUInteger)countOfDevelopers
{
  return [self.developers count];
}

- (NSEnumerator *)enumeratorOfDevelopers
{
  return [self.developers objectEnumerator];
}

- (Coder *)memberOfDevelopers:(Coder *)member object:(Coder *)anObject
{
  return [self.developers member:anObject];
}

@end

The Coders implementation includes the KVO-recommended methods for the unordered, to-many relationship of the developers property.

Now that you have finished implementing the classes, let’s move on to the main() function. In the Xcode project navigator, select the main.m file and update the main() function, as shown in Listing 18-23.

Listing 18-23.  Coders main( ) function

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Coder.h"
#import "Coders.h"

int main(int argc, const char * argv[])
{
  @autoreleasepool
  {
    Person *curly = [[Person alloc] initWithFirstName:@"Curly" lastName:@"Howard"];
    NSLog(@"Person first name: %@", [curly valueForKey:@"firstName"]);
    NSLog(@"Person full name: %@", [curly valueForKey:@"fullName"]);
    NSArray *langs1 = @[@"Objective-C", @"C"];
    Coder *coder1 = [Coder new];
    coder1.person = curly;
    coder1.languages = [langs1 mutableCopy];
    NSLog(@"
Coder name: %@
	  languages: %@",
          [coder1 valueForKeyPath:@"person.fullName"],
          [coder1 valueForKey:@"languages"]);
     
    Coder *coder2 = [Coder new];
    coder2.person = [[Person alloc] initWithFirstName:@"Larry" lastName:@"Fine"];
    coder2.languages = [@[@"Objective-C", @"C++"] mutableCopy];
    NSLog(@"
Coder name: %@
	  languages: %@",
          [coder2 valueForKeyPath:@"person.fullName"],
          [coder2 valueForKey:@"languages"]);
     
    [curly addObserver:coder1
            forKeyPath:@"fullName"
               options:NSKeyValueObservingOptionNew
               context:NULL];
    curly.lastName = @"Fine";
    [curly removeObserver:coder1 forKeyPath:@"fullName"];
     
    Coders *bestCoders = [Coders new];
    bestCoders.developers = [[NSSet alloc] initWithArray:@[coder1, coder2]];
    [bestCoders valueForKey:@"developers"];
    NSLog(@"Number of coders = %@", [bestCoders.developers
                                     valueForKeyPath:@"@count"]);
    NSError *error;
    NSString *emptyName = @"";
    BOOL valid = [curly validateValue:&emptyName forKey:@"lastName" error:&error];
    if (!valid)
    {
      NSLog(@"Error: %@", ([error userInfo])[NSLocalizedDescriptionKey]);
    }
  }
  return 0;
}

The function first creates a Person instance and then uses key-value coding to retrieve values for its properties. Next, a Coder instance is created, and its person and languages property are set. The key-value coding APIs are then used to retrieve the corresponding property values. Another Coder instance is then created and its property values are set accordingly. Key-value observing is then demonstrated, with a Coder instance registered to receive notifications when the fullName property of a Person instance is changed. A Coders instance (remember, the Coders class holds a collection of Coder instances) is then created and its developers property is assigned to the collection of Coder instances created previously. A collection operator is then used to return the total number of coders in the collection. Finally, key-value coding validation is demonstrated on the lastName property of a Person instance.

When you compile and run the program, you should observe the messages in the output pane shown in Figure 18-3.

Excellent! This completes your in-depth examination of the key-value programming APIs and infrastructure. Knowledge of key-value coding and key-value observing will be extremely useful to you when programming with Objective-C and using Apple’s various software frameworks and services.

Roundup

In this chapter, you learned about key-value programming, a powerful set of mechanisms and APIs in the Objective-C language. Key-value programming is an important component of general Objective-C programming, along with the Cocoa and Cocoa Touch frameworks, hence it is important to understand its details and how it can be effectively used in your programs. This chapter provided an in-depth examination of key-value programming infrastructure, specifically key-value coding and key-value observing. Its key takeaways include the following:

• Key-value coding enables your code to access and manipulate an object’s properties indirectly, by name (i.e., key), rather than through accessor methods or backing instance variables.
• Key-value coding allows you to access a property using a string that can be varied at runtime, and thus provides a more dynamic, flexible approach for accessing and manipulating an object’s state. Its key benefits include loose coupling, configuration-based property access, and code simplification.
• Key-value coding uses keys and key paths for property access. A key is a string that identifies a specific property. A key path specifies a sequence of object properties (within an object graph) that are traversed to identify a specific property. The KVC APIs support accessing both individual and multiple properties of an object. The properties can be primitives, C structs, object types (including collections). Primitives and structs are automatically wrapped to/from corresponding object types.
• The NSKeyValueCoding informal protocol defines the mechanism for accessing objects indirectly by name/key. This protocol declares the key-value coding API, consisting of class and instance methods along with constant values. The methods enable you to get and set property values, perform property validation, and change the default behavior of the key-value coding methods for getting property values.
• Key-value coding utilizes a mechanism for mapping keys to the appropriate property accessor methods and/or property backing variables. This mechanism utilizes a set of standard search patterns that rely on property accessor method naming conventions.
• Key-value coding also includes infrastructure for validating property values. The KVC validation mechanism comprises a set of APIs and a standard convention for custom property validation methods. The KVC validation methods can be called directly or indirectly.
• The key-value coding collection operators allow actions to be performed on the items of a collection using key path dot notation.
• Key-value observing enables other objects to be notified of changes to the properties of other objects. It is essentially an implementation of the observer software design pattern, and is implemented in numerous software libraries and frameworks. In fact, it is a key component of the model-view-controller (MVC) design pattern, a central component of the Cocoa and Cocoa Touch frameworks. Key-value observing is built on key-value coding.
• Key-value observing provides numerous benefits, including decoupling of observer objects from the object being observed (i.e., the subject), framework-level support, and a full-featured set of APIs. It provides event notification, similar to the Foundation Framework notification APIs, but a different set of features. Hence, you should compare the two before deciding which to use in your programs.
• Key-value observing provides APIs that support both automatic and manual key-value property change notification. They enable an observer to perform logic both before and after a property value is changed. The APIs support attributes, to-one, and to-many relationship properties. Automatic property change notification is implemented by the default NSObject KVO implementation. Manual change notification provides more fine-grained control over the sending of change notifications, eliminates unnecessary notifications (e.g., for cases when the new property value is the same as its old value), and enables you to group notifications.

Congratulations, you should now be well on your way to mastering the Objective-C language! Perhaps there’s some material that you want to review again, or maybe you would just like to give your brain a well-deserved rest. Go right ahead, but please take advantage of the numerous code listings and programs to thoroughly explore the topics covered. The more you do this, the more skilled you will become at Objective-C programming.

This is the final chapter of this book—but guess what, you’re not done yet. The next stop is the appendices, where you’ll explore a variety of additional topics that will further enhance your Objective-C skills.