This was with XCode 3.1.2 on 10.5.

- (void)someMethod {
    if( [_person age] == 21 ) { // do something }
}

In this example, it’s obvious I’m accessing the instance variable directly, when I should probably be doing this:

- (void)someMethod {
    if( [[self person] age] == 21 ) { // do something }
}

If my instance variable was just named person, it wouldn’t be so obvious.

Different developers use different ways to name their instance variables. Some use conventions such as m_person (‘m’ for member variable), others have the underscore on the end rather than the beginning.

I’ve heard differing interpretations of Apple’s official advice on this convention. One thing that they definitely recommend against is using an underscore on the front of a method name (e.g., if it’s not defined in the class’s public interface so is a ‘private’ method that should only be called from within another method in the same class). Apart from anything else, this is the convention they use for their own internal “Private API.” If you’re submitting App Store apps with classes that use underscore-prefixed methods, you run the risk of being flagged for using forbidden Private API, even if you’re only using your own methods.

- (void)setPerson:(NSManagedObject *)value {
	_person = value;
}

A strong reference would effectively be doing this:

- (void)setPerson:(NSManagedObject *)value {
	_person = [value retain];
}

though in reality, this kind of setter obviously needs to release the previous value (to avoid a memory leak), after making sure it isn’t the same as the new one (otherwise a release on what you think is the old object will actually release the new object before you can re-retain it).

There are various different styles of setter method, e.g.:

- (void)setPerson:(NSManagedObject *)value {
	if( _person == value ) return;
 
        [_person release];
        _person = [value retain];
}

or

- (void)setPerson:(NSManagedObject *)value {
	[_person autorelease];
	_person = [value retain];
}

If I were writing this post today, I’d use @property and @synthesize instead of including getter/setter methods:

(in the header file)

@property (nonatomic, assign) NSManagedObject *person;

(in the implementation file)

@synthesize person = _person;

The assign indicates a weak reference on an object; replacing assign with retain would make it a strong one.

Really great explanation.