Objective-C Fundamentals & Nuances

You may write Objective-C code for 1-2 years, but still you may not know some fundamentals and nuances, that this programming language has. This may be a reason, why you fail to get a good job. Here I will post some important notes, that every iOS developer should understand though they may not be used often practically. This is taken from Cocoa fundamentals guide:

Objective-C, the development language for Cocoa, is thoroughly object-oriented too, despite its grounding in ANSI C. It provides runtime support for message dispatch and specifies syntactical conventions for defining new classes. Objective-C supports most of the abstractions and mechanisms found in other object-oriented languages such as C++ and Java. These include inheritance, encapsulation, reusability, and polymorphism.

But Objective-C is different from these other object-oriented languages, often in important ways. For example, Objective-C, unlike C++, doesn’t allow operator overloading, templates, or multiple inheritance.

Every Objective-C object hides a data structure whose first member—or instance variable—is the isa pointer. (Most remaining members are defined by the object’s class and superclasses.) The isa pointer, as the name suggests, points to the object’s class, which is an object in its own right (see Figure 2-1) and is compiled from the class definition. The class object maintains a dispatch table consisting essentially of pointers to the methods it implements; it also holds a pointer to its superclass, which has its own dispatch table and superclass pointer. Through this chain of references, an object has access to the method implementations of its class and all its superclasses (as well as all inherited public and protected instance variables). The isa pointer is critical to the message-dispatch mechanism and to the dynamism of Cocoa objects.

Objective-C is a very dynamic language. Its dynamism frees a program from compile-time and link-time constraints and shifts much of the responsibility for symbol resolution to runtime, when the user is in control. Objective-C is more dynamic than other programming languages because its dynamism springs from three sources:

Dynamic typing—determining the class of an object at runtime

Dynamic binding—determining the method to invoke at runtime

Dynamic loading—adding new modules to a program at runtime

For dynamic typing, Objective-C introduces the id data type, which can represent any Cocoa object. The id data type makes it possible to substitute any type of object at runtime. You can thereby let runtime factors dictate what kind of object is to be used in your code. Dynamic typing permits associations between objects to be determined at runtime rather than forcing them to be encoded in a static design. Static type checking at compile time may ensure stricter data integrity, but in exchange for that stricter integrity, dynamic typing gives your program much greater flexibility. And through object introspection (for example, asking a dynamically typed, anonymous object what its class is) you can still verify the type of an object at runtime and thus validate its suitability for a particular operation. (Of course, you can always statically check the types of objects when you need to.)

Dynamic typing gives substance to dynamic binding, the second kind of dynamism in Objective-C. Just as dynamic typing defers the resolution of an object’s class membership until runtime, dynamic binding defers the decision of which method to invoke until runtime. Method invocations are not bound to code during compilation; they are bound only when a message is actually delivered. With both dynamic typing and dynamic binding, you can obtain different results in your code each time you execute it. Runtime factors determine which receiver is chosen and which method is invoked.

The runtime’s message-dispatch machinery enables dynamic binding. When you send a message to a dynamically typed object, the runtime system uses the receiver’s isa pointer to locate the object’s class, and from there the method implementation to invoke. The method is dynamically bound to the message. And you don’t have to do anything special in your Objective-C code to reap the benefits of dynamic binding. It happens routinely and transparently every time you send a message, especially one to a dynamically typed object.

Dynamic loading, the final type of dynamism, is a feature of Cocoa that depends on Objective-C for runtime support. With dynamic loading, a Cocoa program can load executable code and resources as they’re needed instead of having to load all program components at launch time. The executable code (which is linked prior to loading) often contains new classes that become integrated into the runtime image of the program. Both code and localized resources (including nib files) are packaged in bundles and are explicitly loaded with methods defined in Foundation’s NSBundle class.

This “lazy-loading” of program code and resources improves overall performance by placing lower memory demands on the system. Even more importantly, dynamic loading makes applications extensible. You can devise a plug-in architecture for your application that allows you and other developers to customize it with additional modules that the application can dynamically load months or even years after the application is released. If the design is right, the classes in these modules will not clash with the classes already in place because each class encapsulates its implementation and has its own namespace.

Check if folder exists and create it, if it doesn’t in iOS

It is interesting and quite uncommon that to check weather a folder exists, you should create a bool reference and pass it to the method fileExistsAtPath. This is a sample getter for a folderPath property, that I created. It can be used in various projects. It creates a folder in Documents folder of your app. Change amp to &.

Reference to StackOverflow

Using NSRegularExpression with NSAttributedString

I think, it is a very convenient way to use regular expressions to find a range for applying attributes to NSAttributedString. This is how I did it:

I was searching for a list of available attributes and didn’t find them in a class reference’s first page. So I decided to post here information on that.

Attributed strings support the following standard attributes for text.

Standart Attributes

NSAttributedString programming guide

A full class reference is here


Generating random BOOL and int values in Objective C

I had to generate random BOOL value to create a random error condition in my app and to test, how this error is handled.

So this is how I did it:

We create a seed from current time moment for a rand function. Then we get a random number and a module from division by 2. It can be only 0 or 1. Then we tell our apiCall object to get a BOOL value, which tells it to fail sometimes.

To create a random integer value use this:

It will return a uniformly distributed random number less than upper_bound. arc4random_uniform() is recommended over constructions like arc4random() % upper_bound” as it avoids “modulo bias” when the upper bound is not a power of two.

Reference: http://stackoverflow.com/questions/160890/generating-random-numbers-in-objective-c

No known class method for selector reachabilityWithHostName

I had a really weird experience recently.

Linker did not link Reachability after I added it as a pod.

In this line compiler was giving error ‘No known class method for selector reachabilityWithHostName:’.

I tried to readd reachability, tried to clean project, nothing helped. Then I just tried to rewrite this line and it compiled!

And now I understand why it worked. Because my old code was taken from another project with other version of Reachability and selector was with ‘HostName’ but new one is with ‘Hostname’.

Before rewriting I was checking if Reachability has this method and it seemed to me that it has and I couldn’t understand the problem. It turned out that I didn’t notice this small change in one letter!