8.2.1 What You Can and Cannot Do in +load

+load is to be used only as a last resort. Because it is executed very early, most of the Objective-C runtime machinery will not be ready when +load is executed; hence +load works best for executing C code that is independent on the Objective-C runtime.

The +load implementation in the GNU runtime guarantees you the following things:

you can write whatever C code you like;

you can allocate and send messages to objects whose class is implemented in the same file;

the +load implementation of all super classes of a class are executed before the +load of that class is executed;

the +load implementation of a class is executed before the +load implementation of any category.

In particular, the following things, even if they can work in a particular case, are not guaranteed:

allocation of or sending messages to arbitrary objects;

allocation of or sending messages to objects whose classes have a category implemented in the same file;

You should make no assumptions about receiving +load in sibling classes when you write +load of a class. The order in which sibling classes receive +load is not guaranteed.

The order in which +load and +initialize are called could be problematic if this matters. If you don’t allocate objects inside +load, it is guaranteed that +load is called before +initialize. If you create an object inside +load the +initialize method of object’s class is invoked even if +load was not invoked. Note if you explicitly call +load on a class, +initialize will be called first. To avoid possible problems try to implement only one of these methods.

The +load method is also invoked when a bundle is dynamically loaded into your running program. This happens automatically without any intervening operation from you. When you write bundles and you need to write +load you can safely create and send messages to objects whose classes already exist in the running program. The same restrictions as above apply to classes defined in bundle.