1 files changed, 64 insertions, 50 deletions
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index 406b2e92..a70351b5 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -4,6 +4,7 @@ language: Objective-C
 contributors:
     - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
     - ["Yannick Loriot", "https://github.com/YannickL"]
+    - ["Levi Bostian", "https://github.com/levibostian"]
 filename: LearnObjectiveC.m
 
 ---
@@ -28,7 +29,9 @@ int main (int argc, const char * argv[])
 {
     // Create an autorelease pool to manage the memory into the program
     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
- 
+    // If using automatic reference counting (ARC), use @autoreleasepool instead:
+    @autoreleasepool {
+
     // Use NSLog to print lines to the console
     NSLog(@"Hello World!"); // Print the string "Hello World!"
  
@@ -74,16 +77,16 @@ int main (int argc, const char * argv[])
     short fortyTwoShort           = [fortyTwoShortNumber shortValue]; // or 42
     NSLog(@"%hi", fortyTwoShort);
 
-    NSNumber *fortyTwoShortNumber   = [NSNumber numberWithShort:41];
-    unsigned short fortyTwoUnsigned = [fortyTwoShortNumber unsignedShortValue]; // or 41
-    NSLog(@"%hu", fortyTwoUnsigned);
+    NSNumber *fortyOneShortNumber   = [NSNumber numberWithShort:41];
+    unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // or 41
+    NSLog(@"%u", fortyOneUnsigned);
     
     NSNumber *fortyTwoLongNumber = @42L;
     long fortyTwoLong            = [fortyTwoLongNumber longValue]; // or 42
     NSLog(@"%li", fortyTwoLong);
 
-    NSNumber *fortyTwoLongNumber     = @53L;
-    unsigned long fiftyThreeUnsigned = [fortyTwoLongNumber unsignedLongValue]; // or 53
+    NSNumber *fiftyThreeLongNumber   = @53L;
+    unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // or 53
     NSLog(@"%lu", fiftyThreeUnsigned);
 
     // Floating point literals
@@ -116,6 +119,7 @@ int main (int argc, const char * argv[])
     NSLog(@"%i", yesBool); // prints => 1
 
     // Array object
+    // May contain different data types, but must be an Objective-C object.
     NSArray *anArray      = @[@1, @2, @3, @4];
     NSNumber *thirdNumber = anArray[2];
     NSLog(@"Third number = %@", thirdNumber); // Print "Third number = 3"
@@ -146,10 +150,6 @@ int main (int argc, const char * argv[])
     [mutableSet addObject:@"Hello"];
     NSLog(@"%@", mutableSet); // prints => {(Hello)}
 
-    // Set object
-    NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
-    NSLog(@"%@", set); // prints => {(Hello, World)}
-
     ///////////////////////////////////////
     // Operators
     ///////////////////////////////////////
@@ -267,6 +267,9 @@ int main (int argc, const char * argv[])
 
     // Clean up the memory you used into your program
     [pool drain];
+
+    // End of @autoreleasepool.
+    }
     
     // End the program
     return 0;
@@ -276,41 +279,30 @@ int main (int argc, const char * argv[])
 // Classes And Functions
 ///////////////////////////////////////
 
-// Declare your class in a header(MyClass.h) file:
-// Class Declaration Syntax:
+// Declare your class in a header file (MyClass.h):
+// Class declaration syntax:
 // @interface ClassName : ParentClassName <ImplementedProtocols>
 // {
-//    Member variable declarations;
+//    type name; <= variable declarations;
 // }
-// -/+ (type) Method declarations;
+// @property type name; <= property declarations.
+// -/+ (type) Method declarations; <= Method declarations. 
 // @end
-@interface MyClass : NSObject <MyProtocol>
+@interface MyClass : NSObject <MyProtocol> // NSObject is Objective-C's base object class.
 {
-    // Instance variable declarations (can exist in either interface or implementation file)
+    // Instance variable declarations (can exist in either interface or implementation file).
     int count; // Protected access by default. 
-    @private id data; // Private access. (More convenient to declare in implementation file)
+    @private id data; // Private access. (More convenient to declare in implementation file).
     NSString *name; 
 }
-// Convenient notation to auto generate public access getter and setter
-@property int count;
-@property (copy) NSString *name; // Copy the object during assignment.
-@property (readonly) id data;    // Declare only a getter method.
-// To access public variable in implementation file, use '_' followed by variable name:
-_count = 5;
-NSLog(@"%d", _count); // prints => 5
-// To access public variable outside implementation file, @property generates setter method
-// automatically. Method name is 'set' followed by @property variable name:
-MyClass *myClass = [[MyClass alloc] init]; // create MyClass object instance.
-[myClass setCount:10]; 
-NSLog(@"%@", [myClass count]); // prints => 10
+// Convenient notation for public access variables to auto generate a setter method. 
+// By default, setter method name is 'set' followed by @property variable name.
+@property int count; // Setter method name = 'setCount'
+@property (copy) NSString *name; // (copy) => Copy the object during assignment.
+@property (readonly) id data;    // (readonly) => Cannot set value outside interface.
 // You can customize the getter and setter names instead of using default 'set' name:
-@property (getter=countGet, setter=countSet:) int count; 
-[myClass countSet:32];
-NSLog(@"%i", [myClass countGet]); // prints => 32
-// For convenience, you may use dot notation to set object instance variables:
-myClass.count = 45;
-NSLog(@"%i", myClass.count); // prints => 45
-
+@property (getter=lengthGet, setter=lengthSet:) int length;
+ 
 // Methods
 +/- (return type)methodSignature:(Parameter Type *)parameterName;
 
@@ -321,20 +313,39 @@ NSLog(@"%i", myClass.count); // prints => 45
 - (NSString *)instanceMethodWithParameter:(NSString *)string;
 - (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
 
-@end
+@end // States the end of the interface. 
+
+
+// To access public variables from the implementation file, @property generates a setter method
+// automatically. Method name is 'set' followed by @property variable name:
+MyClass *myClass = [[MyClass alloc] init]; // create MyClass object instance.
+[myClass setCount:10]; 
+NSLog(@"%d", [myClass count]); // prints => 10
+// Or using the custom getter and setter method defined in @interface:
+[myClass lengthSet:32];
+NSLog(@"%i", [myClass lengthGet]); // prints => 32
+// For convenience, you may use dot notation to set and access object instance variables:
+myClass.count = 45;
+NSLog(@"%i", myClass.count); // prints => 45
+
 
 // Implement the methods in an implementation (MyClass.m) file:
 @implementation MyClass {
-    long count; // Private access instance variable.
+    long distance; // Private access instance variable.
 }
 
+// To access a public variable from the interface file, use '_' followed by variable name:
+_count = 5; // References "int count" from MyClass interface. 
+// Access variables defined in implementation file:
+distance = 18; // References "long distance" from MyClass implementation.
+
 // Call when the object is releasing
 - (void)dealloc
 {
 }
 
 // Constructors are a way of creating classes
-// This is a default constructor which is called when the object is creating
+// This is a default constructor which is called when the object is initialized. 
 - (id)init
 {
     if ((self = [super init]))
@@ -365,7 +376,7 @@ NSLog(@"%i", myClass.count); // prints => 45
     // statements
 }
 
-@end
+@end // States the end of the implementation. 
 
 /*
  * A protocol declares methods that can be implemented by any class.
@@ -395,37 +406,40 @@ With all object interactions, follow the pattern of:
 (1) create the object, (2) use the object, (3) then free the object from memory. 
 */
 
-MyClass *classVar = [MyClass alloc]; // alloc sets classVar's reference count to one. Returns pointer to object.
+MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object.
 [classVar release]; // Decrements classVar's reference count.  
-// retain claims ownership of existing object instance and increments reference count. Returns pointer to object.
+// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object.
 MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner.
 [classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object.
 
-// @property can use retain or assign as well for small convenient definitions. 
+// @property can use 'retain' and 'assign' as well for small convenient definitions. 
 @property (retain) MyClass *instance; // Release old value and retain a new one (strong reference).
 @property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference).
 
+// Automatic Reference Counting (ARC)
 // Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC).
 // ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, 
 // you must not use retain, relase, or autorelease.
-MyClass *arcMyClass = [[MyClass alloc] init]; // Without ARC, you will need to call: [arcMyClass release] after
-// you're done using arcMyClass. But with ARC, there is no need. It will insert this release statement for you. 
+MyClass *arcMyClass = [[MyClass alloc] init]; 
+// ... code using arcMyClass
+// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, 
+// there is no need. It will insert this release statement for you. 
 
-// As for the "assign" and "retain" @property attributes, with ARC you use "weak" and "strong". 
-@property (weak) MyClass *weakVar; // weak does not take ownership of object. If original instance's reference count
+// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'. 
+@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count
 // is set to zero, weakVar will automatically receive value of nil to avoid application crashing.
-@property (strong) MyClass *strongVar; // strong takes ownership of object. Ensures object will stay in memory to use.
+@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use.
 
 // For regular variables (not @property declared variables), use the following:
 __strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope. 
 __weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil.
-__unsafe_unretained NSArray *unsafeArray; // Like __weak but unsafeArray not set to nil when existing object is released.
+__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released.
 
 ```
 ## Further Reading
 
 [Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C)
 
-[Learning Objective-C](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/)
+[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
 
 [iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)