From 14849d69fdad6d7cb3af0531b128780d0ae249eb Mon Sep 17 00:00:00 2001 From: Luca Bernardi Date: Tue, 8 Jul 2014 21:55:30 +0100 Subject: [PATCH] First release --- README.md | 2284 ++++++++++++++++++++++++++++++++++++ images/blocks_debugger.png | Bin 0 -> 76021 bytes images/yoda.png | Bin 0 -> 6938 bytes images/zen-logo-big.png | Bin 0 -> 145534 bytes images/zen-logo-thumb.png | Bin 0 -> 56639 bytes scripts/make_toc.rb | 17 + 6 files changed, 2301 insertions(+) create mode 100644 README.md create mode 100644 images/blocks_debugger.png create mode 100644 images/yoda.png create mode 100644 images/zen-logo-big.png create mode 100644 images/zen-logo-thumb.png create mode 100644 scripts/make_toc.rb diff --git a/README.md b/README.md new file mode 100644 index 0000000..8345573 --- /dev/null +++ b/README.md @@ -0,0 +1,2284 @@ +# Zen and the Art of the Objective-C Craftsmanship + + + +![](./images/zen-logo-thumb.png) + + + + +* [Preface](#preface) + * [Swift](#swift) + * [For the Community](#for-the-community) + * [Authors](#authors) +* [Conditionals](#conditionals) + * [Yoda conditions](#yoda-conditions) + * [nil and BOOL checks](#nil-and-bool-checks) + * [Golden Path](#golden-path) + * [Complex Conditions](#complex-conditions) + * [Ternary Operator](#ternary-operator) + * [Error handling](#error-handling) +* [Case Statements](#case-statements) + * [Enumerated Types](#enumerated-types) +* [Naming](#naming) + * [General conventions](#general-conventions) + * [Constants](#constants) + * [Methods](#methods) + * [Literals](#literals) +* [Class](#class) + * [Class name](#class-name) + * [Initializer and dealloc](#initializer-and-dealloc) + * [Designated and Secondary Initializers](#designated-and-secondary-initializers) + * [Designated Initializer](#designated-initializer) + * [Secondary Initializer](#secondary-initializer) + * [References](#references) + * [instancetype](#instancetype) + * [Reference](#reference) + * [Initialization Patterns](#initialization-patterns) + * [Class cluster](#class-cluster) + * [Singleton](#singleton) + * [Properties](#properties) + * [Init and Dealloc](#init-and-dealloc) + * [Dot-Notation](#dot-notation) + * [Property Declaration](#property-declaration) + * [Private Properties](#private-properties) + * [Mutable Object](#mutable-object) + * [Lazy Loading](#lazy-loading) + * [Methods](#methods) + * [Parameter Assert](#parameter-assert) + * [Private methods](#private-methods) + * [Equality](#equality) +* [Categories](#categories) +* [Protocols](#protocols) +* [NSNotification](#nsnotification) +* [Beautifying the code](#beautifying-the-code) + * [Spacing](#spacing) + * [Line Breaks](#line-breaks) + * [Brackets](#brackets) +* [Code Organization](#code-organization) + * [Exploit Code Block](#exploit-code-block) + * [Pragma](#pragma) + * [Pragma Mark](#pragma-mark) + * [Explicit warnings and errors](#explicit-warnings-and-errors) + * [Docstrings](#docstrings) + * [Comments](#comments) + * [Header Documentation](#header-documentation) +* [Inter-Object Communication](#inter-object-communication) + * [Blocks](#blocks) + * [Under the Hood](#under-the-hood) + * [Retain cycles on self](#retain-cycles-on-self) + * [Delegate and DataSource](#delegate-and-datasource) + * [Inheritance](#inheritance) + * [Multiple Delegation](#multiple-delegation) +* [Aspect Oriented Programming](#aspect-oriented-programming) +* [References](#references) + * [Other Objective-C Style Guides](#other-objective-c-style-guides) + + + + +# Preface + +We started writing this book on November 2013. The initial goal was to provide guidelines to write the most clean Objective-C code possible: there are too many guidelines out there and all of them are debatable. We didn't aim introducing hard rules but, instead, a way for writing code to be more uniform as possible across different developers. +With time the scope moved to explain how to design and architecture good code. + +The idea underneath is that the code should not only compile, instead it should "validate". Good code has several characteristics: should be concise, self-explanatory, well organized, well documented, well named, well designed and stand the test of time. +The main goals behind the curtain are that clarity always wins over performance and a rationale for a choice should always be provided. +Some topics discussed here are general and independent from the language even if everything is tied up to Objective-C. + +## Swift + +On June 6th, 2014 Apple announced the new programming language to be used for iOS and Mac development in future: Swift. +This new language is a radical departure from Objective-C and, of course, has caused a change in our plan for writing this book. It boiled down to the decision of releasing the current status of this essay without continuing our journey in unfolding the topics we originally planned to include. +Objective-C is not going anywhere but at the same time continuing to write a book on a language that will not receive the same attention as it used to, is not a wise move. + +## For the Community + +We have released this book for free and for the community because we hope to provide value to the reader, if each one of you can learn at least one best practice we have reached our goal. + +We have done our best to polish this text and make it pleasant to the reader but we may have made typos, mistakes or left any part incomplete. We strongly encourage you to give us feedback and suggest improvements, so please get in touch with us if have any. We particularly appreciate pull requests. + +## Authors + +**Luca Bernardi** + +- http://lucabernardi.com +- @luka_bernardi +- http://github.com/lukabernardi + +**Alberto De Bortoli** + +- http://albertodebortoli.com +- @albertodebo +- http://github.com/albertodebortoli + + +# Conditionals + +Conditional bodies should always use braces even when a conditional body could be written without braces (e.g., it is one line only) to prevent errors. These errors include adding a second line and expecting it to be part of the if-statement. Another, even more dangerous defect, may happen where the line "inside" the if-statement is commented out, and the next line unwittingly becomes part of the if-statement. + +**Preferred:** + +```objc +if (!error) { + return success; +} +``` + +**Not preferred:** + +```objc +if (!error) + return success; +``` + +or + +```objc +if (!error) return success; +``` + +In February 2014 the well-know [goto fail](https://gotofail.com/) was found in the Apple's SSL/TLS implementation. +The bug was due to a repeated `goto` statement after an `if` condition, wrapping the `if` branch in parentheses would have prevented the issue. + +The code extract: + +```objc +static OSStatus +SSLVerifySignedServerKeyExchange(SSLContext *ctx, bool isRsa, SSLBuffer signedParams, + uint8_t *signature, UInt16 signatureLen) +{ + OSStatus err; + ... + + if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0) + goto fail; + if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0) + goto fail; + goto fail; + if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0) + goto fail; + ... + +fail: + SSLFreeBuffer(&signedHashes); + SSLFreeBuffer(&hashCtx); + return err; +} +``` + +Easy to spot, there are 2 `goto fail;` lines one after the other without parentheses. We definitely don't want to risk creating bugs like the one above right? + +In addition, this style is more consistent with all other conditionals, and therefore more easily scannable. + + +## Yoda conditions + +Always avoid Yoda conditions. A Yoda condition is when comparing a constant to a variable instead of the other way around. It's like saying "if blue is the sky" or "if tall is the man" instead of "if the sky is blue" or "if the man is tall". + +![Yoda](./images/yoda.png) + +**Preferred:** +```objc +if ([myValue isEqual:@42]) { ... +``` + +**Not preferred:** +```objc +if ([@42 isEqual:myValue]) { ... +``` + +## nil and BOOL checks + +On a similar note of the Yoda conditions, also the nil check has been at the centre of debates. Some notous libraries out there use to check for an object to be or not to be nil as so: + +```objc +if (nil == myValue) { ... +``` + +One could argue that this is amiss or similar to a Yoda condition as nil is kind of a constant. The reason why sometimes programmers use this approach to prevent error that are difficult to debug. Consider the following code: + +```objc +if (myValue == nil) { ... +``` + +If a typo occurs and the programmer actually types: + +```objc +if (myValue = nil) { ... +``` + +it would be a valid assignment, indeed hard to debug if you are an experienced programmer (and therefore probably with some kind of visual impairment). That could never occur putting `nil` as argument on the left as it is nor assignable. There is also to be said that if the programmer uses this approach, he or she is perfectly aware of the underlying motivation and therefore the whole thing decades as it would be better to just double check what just typed. + +More on this, to avoid all this fuss the approach that leave no space to doubt is to use the exclamation mark. Since `nil` resolves to `NO` it is unnecessary to compare it in conditions. Also, never compare something directly to `YES`, because `YES` is defined to 1 and a `BOOL` can be up to 8 bits as it is a char underneath. + +**Preferred:** +```objc +if (someObject) { ... +if (![someObject boolValue]) { ... +if (!someObject) { ... +``` + +**Not Preferred:** +```objc +if (someObject == YES) { ... // Wrong +if (myRawValue == YES) { ... // Never do this. +if ([someObject boolValue] == NO) { ... +``` + +This allows also for more consistency across files and greater visual clarity. + +## Golden Path + +When coding with conditionals, the left hand margin of the code should be the "golden" or "happy" path. That is, don't nest `if` statements. Multiple return statements are OK. This will avoid the growth of cyclomatic complexity and make the code easier to read because the important part of your method is not nested inside a branch but you have a visual clue of what is the most relevant code. + +**Preferred:** + +```objc +- (void)someMethod { + if (![someOther boolValue]) { + return; + } + + //Do something important +} +``` + +**Not preferred:** + +```objc +- (void)someMethod { + if ([someOther boolValue]) { + //Do something important + } +} +``` +## Complex Conditions + +When you have complex condition in the `if` clause you should always extract them and assign to a `BOOL` variable to make more clear the logic and the meaning of every single conditions. + +```objc +BOOL nameContainsSwift = [sessionName containsString:@"Swift"]; +BOOL isCurrentYear = [sessionDateCompontents year] == 2014; +BOOL isSwiftSession = nameContainsSwift && isCurrentYear; + +if (isSwiftSession) { + // Do someting very cool +} +``` + +## Ternary Operator + +The Ternary operator, `?` , should only be used when it increases clarity or code neatness. A single condition is usually all that should be evaluated. Evaluating multiple conditions is usually more understandable as an if statement, or refactored into instance variables. + +**Preferred:** +```objc +result = a > b ? x : y; +``` + +**Not preferred:** +```objc +result = a > b ? x = c > d ? c : d : y; +``` + +When the second argument of the ternary operator (the if branch) returns the same object that was checked for existance in the condition, the following syntax is neat: + +**Preferred:** +```objc +result = object ? : [self createObject]; +``` + +**Not preferred:** +```objc +result = object ? object : [self createObject]; +``` + +## Error handling + +When methods return an error parameter by reference, check the returned value, not the error variable. + +**Preferred:** +```objc +NSError *error = nil; +if (![self trySomethingWithError:&error]) { + // Handle Error +} +``` + +Moreover, some of Apple's APIs write garbage values to the error parameter (if non-NULL) in successful cases, so checking the error can cause false negatives (and subsequently crash). + + +# Case Statements + +Braces are not required for case statements, unless enforced by the complier. +When a case contains more than one line, braces should be added. + +```objc +switch (condition) { + case 1: + // ... + break; + case 2: { + // ... + // Multi-line example using braces + break; + } + case 3: + // ... + break; + default: + // ... + break; +} +``` + +There are times when the same code can be used for multiple cases, and a fall-through should be used. A fall-through is the removal of the 'break' statement for a case thus allowing the flow of execution to pass to the next case value. + +```objc +switch (condition) { + case 1: + case 2: + // code executed for values 1 and 2 + break; + default: + // ... + break; +} +``` + +When using an enumerated type for a switch, `default` is not needed. For example: + +```objc +switch (menuType) { + case ZOCEnumNone: + // ... + break; + case ZOCEnumValue1: + // ... + break; + case ZOCEnumValue2: + // ... + break; +} +``` + +Moreover, avoiding the default case, if new values are added to the enum, the programmer is immediately notified with a warning: + +`Enumeration value 'ZOCEnumValue3' not handled in switch.` + +### Enumerated Types + +When using `enum`s, it is recommended to use the new fixed underlying type specification because it has stronger type checking and code completion. The SDK now includes a macro to facilitate and encourage use of fixed underlying types — `NS_ENUM()` + +**Example:** + +```objc +typedef NS_ENUM(NSUInteger, ZOCMachineState) { + ZOCMachineStateNone, + ZOCMachineStateIdle, + ZOCMachineStateRunning, + ZOCMachineStatePaused +}; +``` + +# Naming + +## General conventions + +Apple naming conventions should be adhered to wherever possible, especially those related to [memory management rules](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/MemoryMgmt/Articles/MemoryMgmt.html) ([NARC](http://stackoverflow.com/a/2865194/340508)). + +Long, descriptive method and variable names are good. + +**Preferred:** + +```objc +UIButton *settingsButton; +``` + +**Not Preferred:** +```objc +UIButton *setBut; +``` + +## Constants + +Constants should be camel-case with all words capitalized and prefixed by the related class name for clarity. + +**Preferred:** +```objc +static const NSTimeInterval ZOCSignInViewControllerFadeOutAnimationDuration = 0.4; +``` + +**Not Preferred:** +```objc +static const NSTimeInterval fadeOutTime = 0.4; +``` + +Constants are preferred over in-line string literals or numbers, as they allow for easy reproduction of commonly used variables and can be quickly changed without the need for find and replace. Constants should be declared as `static` constants and not `#define`s unless explicitly being used as a macro. + +**Preferred:** +```objc +static NSString * const ZOCCacheControllerDidClearCacheNotification = @"ZOCCacheControllerDidClearCacheNotification"; +static const CGFloat ZOCImageThumbnailHeight = 50.0f; +``` + +**Not Preferred:** + +```objc +#define CompanyName @"Apple Inc." +#define magicNumber 42 +``` + +Constants exposed externally should use this pattern in the interface file: + +```objc +extern NSString *const ZOCCacheControllerDidClearCacheNotification; +``` +and the previously defined assignment should be in the implementation file. + +You only need to add the namespace to a constant that is made public. Even though constants used within an implementation could follow a different pattern, there is no need not to be consistent with the rule. + + +## Methods + +In method signatures, there should be a space after the method type (`-`/`+` symbol). There should be a space between the method segments (matching Apple's style). Always include a keyword and be descriptive with the word before the argument which describes the argument. + +The usage of the word "and" is reserved. It should not be used for multiple parameters as illustrated in the `initWithWidth:height:` example below. + +**Preferred:** +```objc +- (void)setExampleText:(NSString *)text image:(UIImage *)image; +- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag; +- (id)viewWithTag:(NSInteger)tag; +- (instancetype)initWithWidth:(CGFloat)width height:(CGFloat)height; +``` + +**Not Preferred:** + +```objc +-(void)setT:(NSString *)text i:(UIImage *)image; +- (void)sendAction:(SEL)aSelector :(id)anObject :(BOOL)flag; +- (id)taggedView:(NSInteger)tag; +- (instancetype)initWithWidth:(CGFloat)width andHeight:(CGFloat)height; +- (instancetype)initWith:(int)width and:(int)height; // Never do this. +``` + +## Literals + +`NSString`, `NSDictionary`, `NSArray`, and `NSNumber` literals should be used whenever creating immutable instances of those objects. Pay special care that `nil` values not be passed into `NSArray` and `NSDictionary` literals, as this will cause a crash. + +**For example:** + +```objc +NSArray *names = @[@"Brian", @"Matt", @"Chris", @"Alex", @"Steve", @"Paul"]; +NSDictionary *productManagers = @{@"iPhone" : @"Kate", @"iPad" : @"Kamal", @"Mobile Web" : @"Bill"}; +NSNumber *shouldUseLiterals = @YES; +NSNumber *buildingZIPCode = @10018; +``` + +**Not:** + +```objc +NSArray *names = [NSArray arrayWithObjects:@"Brian", @"Matt", @"Chris", @"Alex", @"Steve", @"Paul", nil]; +NSDictionary *productManagers = [NSDictionary dictionaryWithObjectsAndKeys: @"Kate", @"iPhone", @"Kamal", @"iPad", @"Bill", @"Mobile Web", nil]; +NSNumber *shouldUseLiterals = [NSNumber numberWithBool:YES]; +NSNumber *buildingZIPCode = [NSNumber numberWithInteger:10018]; +``` + +# Class + +## Class name + +You should always prefix your class with **three** capital-case letters (two letters are reserved for Apple classes), this looking-weird practice is done to mitigate the notable absence of namespaces in our favorite language. +Some developers don't follow this practice for model objects (we observed this practice especially for Core Data objects), we advice to strictly follow this convention also in the case of Core Data objects because you might end up merging your Managed Object Model with other MOMs, maybe coming from third party library. +As you may already have noticed, in this book the class (but not only) prefix is `ZOC`. + +There is another good practice that you might want to follow while choosing while naming you class that is, when you're creating a subclass, you should put the specifying name part between the class prefix and the superclass name. This is better explained with an example: if you have a class named `ZOCNetworkClient`, example of subclass name will be `ZOCTwitterNetworkClient` (note "Twitter" between "ZOC" and "NetworkClient"); or following the same rule a subclass of `UIViewController` is `ZOCTimelineViewController`. + + +## Initializer and dealloc + +The recommended way to organize the code is to have `dealloc` method placed at the top of the implementation (directly after the `@synthesize` and `@dynamic` statements) and the `init` should be placed directly below the `dealloc` methods of any class. In case of multiple initializer the designated initializer should be placed as first method, because is the one where most likely there is more logic, and the secondary initializers should follow. +In these days with ARC, it is less likely that you will implement the dealloc method, but still the rationale is that by having the dealloc very close to your init methods your visually emphasizing the pairing between the methods,. Usually in the dealloc method you will undo things that you have done in the init methods. + +`init` methods should be structured like this: + +```objc +- (instancetype)init +{ + self = [super init]; // call the designated initializer + if (self) { + // Custom initialization + } + return self; +} +``` + +It's interesting to understand why do we need to set the value of `self` with the return value of `[super init]` and what happens if we don't do that. +Let's do a step back, we are so used to type expressions like `[[NSObject alloc] init]` that the difference between between `alloc` and `init` fades away. A peculiarity of Objective-C is the so called *two stage creation*. This means that the allocation and the initialization are two separate steps, and therefore two different methods need to be called: `alloc` and `init`. +- `alloc` is responsible for the object allocation. This process involve the allocation of enough memory to hold the object from the application virtual memory, writing the `isa` pointer, initializes the retain count, and zeroing all the instance varibales. This method will return a valid instance of an uninitialized object; +- `init` is responsible for initializing the object, that means brings the object in an usable state. This typically means set the instance variable of an object to reasonable and useful initial values. + +The interesting part is that the `init` implementation of NSObject is simply returning `self`, this is because the variable `self` is written after the `alloc` method where all the initialization logic is done. This is also needed to allow the `NSObject'`s subclass to follow the previously exposed pattern. There is another important part of the contract with `init`: the method can (and should) signal to the caller that it wasn't able to successfully finish the initialization by returning `nil`; the initialization can fail for various reasons such as an input passed in the wrong format or the failure in successfully initialize a needed object. +This is lead us to understand why you should always call `self = [super init]`, if your superclass is stating that it wasn't able to successfully initialize itself, you must assume that you are in an inconsistent state and therefore do not proceed with your own initialization and return `nil` as well in your implementation. If you fail to do so you might end up dealing with an object that is not usable, that will not behave as expected and that might eventually lead to crash your app. + +### Designated and Secondary Initializers + +Objective-C have the concept of designated and secondary initializers. +The designated initializer is the initializer that takes the full complement of initialization parameters, the secondary initializers are one or more initializer methods that calls the designated initializer providing one or more default values for the initialization parameter. + +```objc +@implementation ZOCEvent + +- (instancetype)initWithTitle:(NSString *)title + date:(NSDate *)date + location:(CLLocation *)location +{ + self = [super init]; + if (self) { + _title = title; + _date = date; + _location = location; + } + return self; +} + +- (instancetype)initWithTitle:(NSString *)title + date:(NSDate *)date +{ + return [self initWithTitle:title date:date location:nil]; +} + +- (instancetype)initWithTitle:(NSString *)title +{ + return [self initWithTitle:title date:[NSDate date] location:nil]; +} + +@end +``` + +Given the above example `initWithTitle:date:location:` is the designated initializer. The other two init methods are the secondary initializers because they are just calling the designated initializer of the class where they are implemented. + +#### Designated Initializer + +A class should always have one and only one designated initializer, all other init methods should call the designated one (even thought there are an exception to this case). +This dichotomy does not dictate any requirement about which initializer should be called. +It should rather be valid to call any designated initializer in the class hierarchy, and it should be guaranteed that *all* the designated initializer in the class hierarchy are called starting from the furthest ancestor (typically `NSObject`) down to your class. +Practically speaking this means that the first initialization code executed is the furthest ancestor, and then going down to the class hierarchy; giving to all the classes in the hierarchy the chance to do their specific part of initialization. This totally make sense: you want that everything you inherit from your superclass is in an usable state before doing your actual work. +Even though it isn't explicitly stated, all the classes in Apple's frameworks are guaranteed to respect this contract and your classes should do the same to be sure to be a good citizen and behave correctly and as expected. + +There are three different situations that may present when defining a new class: + +1. No need to override any initializers +2. Overriding designated initializer +3. Define a new designated initializer + +The first case is the most trivial: we you don't need to add any specific logic at the initialization of your class you simply rely on you parent designated initializer. +When you want to provide additional initialization logic you can decide to override the designated initializer. You should only override your immediate superclass's designated initializer and be sure that your implementation calls the super of the method you're overriding. +A typical example is whether you create a `UIViewController` subclass overriding `initWithNibName:bundle:`: + +```objc +@implementation ZOCViewController + +- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil +{ + // call to the superclass designated initializer + self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil]; + if (self) { + // Custom initialization + } + return self; +} + +@end +``` + +In case of `UIViewController` subclass it would be an error to override `init` as, in the case that the caller will try to initialize your class by calling `initWithNib:bundle`, your implementation will not be called. This also contradicts the rule that states that it should be valid to call any designated initializer. + +In case you want to provide your own designated initializer there are three steps that you need to follow in order to guarantee the correct behavior: + +1. Declare your designated initializer, being sure to call your immediate superclass's designated initializer. +2. Override the immediate superclass's designated initializer calling your new designated initializer. +3. Document the new designated initializer. + +Lots of developers often miss the last two steps, this is not only a sign of little care, but in the case of the step two is clearly against the contract with the framework and can lead to very non-deterministic behaviors and bugs. +Let's see an example of the correct way to implement this: + +```objc +@implementation ZOCNewsViewController + +- (id)initWithNews:(ZOCNews *)news +{ + // call to the immediate superclass's designated initializer + self = [super initWithNibName:nil bundle:nil]; + if (self) { + _news = news; + } + return self; +} + +// Override the immediate superclass's designated initializer +- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil +{ + // call the new designated initializer + return [self initWithNews:nil]; +} + +@end +``` + +In case you don't override `initWithNibName:bundle:` and the caller decides to initialize you class with this method (that would be a perfectly valid option) the method `initWithNews:` will never get called and this will bring to an incorrect initialization sequence where the specific initialization logic of your class is not executed. + +Even though it should be possible to infer what method is the designate initializer, it is always good to be clear and explicit (the future you or other developers that will work on your code will thank you). There are two strategies (non mutually exclusive) that you can decide to use: the first one you is to clearly state in the documentation which initializer is the designated one, but better yet you can be nice with your compiler and by using the compiler directive `__attribute__((objc_designated_initializer))` you can signal your intent. +Using that directive will also helps the compiler helping you and in fact the compiler will issue a warning if in your new designate initializer you don't call your superclass's designated initializer. +There are, though, cases in which not calling the class designated initializer (and in turn providing the required parameters) and calling another designated initializer in the class hierarchy will bring the class in an useless state. Referring to the previous example, there is no point in instantiate a `ZOCNewsViewController` that should present a news, without the news itself. In this case you can enforce even more the need to call a very specific designated initializer by simply making all the other designated initializers not available. It is possible to do that by using another compiler directive `__attribute__((unavailable("Invoke the designated initializer"))) `, decorating a method with this attribute will make the compiler issuing an error if you try to call this method. + +Here the header relative to the implementation of the previous example (note the use of macros to don't repeat the code and being less verbose). + +```objc + +@interface ZOCNewsViewController : UIViewController + +- (instancetype)initWithNews:(ZOCNews *)news ZOC_DESIGNATED_INITIALIZER; +- (instancetype)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil ZOC_UNAVAILABLE_INSTEAD(initWithNews:); +- (instancetype)init ZOC_UNAVAILABLE_INSTEAD(initWithNews:); + +@end + +``` + +A corollary of what described above is that you should never call a secondary initializer from within the designated one (if the secondary initializer respects the contract, it will call the designated one). Doing so, the call is very likely to invoke one of the subclass's overriden init methos and it will result in infinite recursion. + +There is however an exception to all the rules laid out before that is whether an object conforms to the `NSCoding` protocol and it is initialized through the method `initWithCoder:`. +We should distinguish between the case where the superclass is adopting `NSCoding` and when not. +In the former case, if you just call `[super initWithCoder:]` you will probably have some shared initialization code with the designated initializer. A good way to handle this is to extract this code in a private method (i.e. `p_commonInit`). +When your superclass does not adopt `NSCoding` the recommendation is to threat `initWithCoder:` as a secondary initializer and therefore call the `self` designated initializer. Note that this is against what suggested by Apple in the [Archives and Serializations Programming Guide](https://developer.apple.com/library/mac/documentation/cocoa/Conceptual/Archiving/Articles/codingobjects.html#//apple_ref/doc/uid/20000948-BCIHBJDE) where is stated: + +> the object should first invoke its superclass's designated initializer to initialize inherited state + +following this will actually lead to a non-deterministic behavior that will change if your class is or not a direct subclass of `NSObject`. + +#### Secondary Initializer + +As stated in the previous paragraph, a secondary initializer is a sort of convenience method to provide default values / behaviors to the designated initializer. +That said, it seems clear that you should not do any mandatory initialization in such method and you should never assume that this method will gets called. Again, the only methods that we are guaranteed to get called are the designated initializer. +This imply that in your designated initializer you should always call another secondary initializer or your `self` designated initializer. Sometimes, by mistake, one can type `super`; doing this will cause not to respect the aforementioned sequence of initialization (in this specific case by skipping the initialization of the current class). + +##### References + +- https://developer.apple.com/library/ios/Documentation/General/Conceptual/DevPedia-CocoaCore/ObjectCreation.html +- https://developer.apple.com/library/ios/documentation/General/Conceptual/CocoaEncyclopedia/Initialization/Initialization.html +- https://developer.apple.com/library/ios/Documentation/General/Conceptual/DevPedia-CocoaCore/MultipleInitializers.html +- https://blog.twitter.com/2014/how-to-objective-c-initializer-patterns + + + +### instancetype + +One often doesn't realize that Cocoa is full of conventions, and they can help the compiler being a little bit more smart. Whether the compiler encounters `alloc` or `init` methods, it will know that, even though the return type of both method is `id`, those methods will always return objects that are an instance of the receiving class's type. As a consequence, this allows the compiler to provide and enforce the type checking (i.e. check that the methods called on the returned instance are valid). This kind of Clang smartness is due to what is called [related result type](http://clang.llvm.org/docs/LanguageExtensions.html#related-result-types), meaning that + +> messages sent to one of alloc and init methods will have the same static type as the instance of the receiver class + +To have more information about the convention that allow to automatically identify the related result type please refer to the [appropriate section]((http://clang.llvm.org/docs/LanguageExtensions.html#related-result-types)) in the Clang Language Extensions guide. +A related result type can be explicitly stated using the `instancetype` keyword as return type and this can be very helpful in situation where a factory method or convenience constructor is used. This will hint the compiler with the correct type checking and, probably more important, will behave correctly also when subclassing. + +```objc +@interface ZOCPerson ++ (instancetype)personWithName:(NSString *)name; +@end +``` + +Even though, according to the clang specification, `id` can be promoted to `instancetype` by the compiler. In the case of `alloc` or `init` we strongly encourage to use the return type `instancetype` for all class and instance methods that returns an instance of the class. +This is mostly to form the habit and to be consistent (and possibly having a more readable interface) in all your APIs. Once again, by making small adjustments to your code you can improve the readability: with a simple glance you will be able to distinguish which methods are returning an instance of your class. Sort of details you will appreciate in the long run. + +##### Reference +- http://tewha.net/2013/02/why-you-should-use-instancetype-instead-of-id/ +- http://tewha.net/2013/01/when-is-id-promoted-to-instancetype/ +- http://clang.llvm.org/docs/LanguageExtensions.html#related-result-types +- http://nshipster.com/instancetype/ + + + +### Initialization Patterns + +#### Class cluster +Class cluster as described in the Apple's documentation is +> an architecture that groups a number of private, concrete subclasses under a public, abstract superclass. + +If this descriptions sounds familiar probably your instinct is correct. Class cluster is the Apple lingo for the [Abstract Factory](http://en.wikipedia.org/wiki/Abstract_factory_pattern) design pattern. +The idea with class cluster is very simple: you typically have an abstract class that during the initialization process use information, generally provided as parameter of the initializer method or available in the environment, to apply a logic and instantiate a concrete subclass. This "public facing" class should internally have a good knowledge of its subclass to be able to return the private subclass that best suited the task. +This pattern is very useful because removes the complexity of this initialization logic from the caller that only knows about the interface to comunicate with the object without actually caring about the underlying implementation. +Class clusters are widely used in the Apple's frameworks; some of the most notably examples are `NSNumber` that can return an appropriate subclass depending of the type of number provided (Integer, Float, etc...) or `NSArray` that will return a concrete subclass with the best storage policy. +The beauty of this pattern is that the caller can be completely unaware of the concrete subclass; in fact it can be used when designing a library to be able to swap the underlaying returned class without leaking any implementation detail as long as is respectful of the contract established in the abstract class. + +In our experience the use of a Class Cluster can very helpful in removing a lot of conditional code. +A typical example of this is when you have the same UIViewController subclass for both iPhone and iPad, but the behavior is slightly different depending on the the device. +The naïve implementation is to put some conditional code checking the device in the methods where the different logic si needed, even thought initially the place where this conditional logic is applied may be quite few they naturally tend to grow producing and explosion of code paths. +A better design can be achieved by creating an abstract and generic view controller that will contain all the shared logic and then two specializing subclass for every device. +The generic view controller will check the current device idiom and depending on that it will return the appropriate subclass. + + +``` +@implementation ZOCKintsugiPhotoViewController + +- (id)initWithPhotos:(NSArray *)photos +{ + + if ([self isMemberOfClass:ZOCKintsugiPhotoViewController.class]) { + self = nil; + + if ([UIDevice isPad]) { + self = [[ZOCKintsugiPhotoViewController_iPad alloc] initWithPhotos:photos]; + } else { + self = [[ZOCKintsugiPhotoViewController_iPhone alloc] initWithPhotos:photos]; + } + return self; + } + return [super initWithNibName:nil bundle:nil]; +} + +@end +``` + +The previous code example show how to create a class cluster. First of all the `[self isMemberOfClass:ZOCKintsugiPhotoViewController.class]` is done to prevent the necessity to override the init method in the subclass in order to prevent an infinite recursion. +When `[[ZOCKintsugiPhotoViewController alloc] initWithPhotos:photos]` will get called the previous check will be true, the `self = nil` is to remove every reference to the instance of `ZOCKintsugiPhotoViewController` that it will be deallocated , following there is the logic to choose which subclass should be initialized. +Let's assume that we are running this code on an iPhone and that `ZOCKintsugiPhotoViewController_iPhone` is not overriding `initWithPhotos:`; in this case, when executing `self = [[ZOCKintsugiPhotoViewController_iPhone alloc] initWithPhotos:photos];` the `ZOCKintsugiPhotoViewController` will be called and here is when the first check comes handy, given that now is not exactly `ZOCKintsugiPhotoViewController` the check will be false calling the `return [super initWithNibName:nil bundle:nil];` this will make continue the initialization following the correct initialization path highlighted in the previous session. + +#### Singleton + +Generally avoid using them if possible, use dependency injection instead. +Nevertheless, unavoidable singleton objects should use a thread-safe pattern for creating their shared instance. As of GCD, it is possible to use the `dispatch_once()` function to + +```objc ++ (instancetype)sharedInstance +{ + static id sharedInstance = nil; + static dispatch_once_t onceToken = 0; + dispatch_once(&onceToken, ^{ + sharedInstance = [[self alloc] init]; + }); + return sharedInstance; +} +``` + +The use of dispatch_once(), which is synchronous, replaces the following, yet obsolete, idiom: + +```objc ++ (instancetype)sharedInstance +{ + static id sharedInstance; + @synchronized(self) { + if (sharedInstance == nil) { + sharedInstance = [[MyClass alloc] init]; + } + } + return sharedInstance; +} +``` + +The benefits of `dispatch_once()` over this are that it's faster, it's also semantically cleaner, because the entire idea of dispatch_once() is "perform something once and only once", which is precisely what we're doing. This approach will also prevent [possible and sometimes prolific crashes][singleton_cocoasamurai]. + +Classic examples of acceptable singleton objects are the GPS and the accelerometer of a device. Even though Singleton objects can be subclassed, the cases where this comes useful are rare. The interface should put in evidence that the given class is intended to be used as a Singleton. Therefore, often a single public `sharedInstance` class method would suffice and no writable properties should be exposed. + +Trying to use a Singleton as a container for objects to share across the code or layer of your application is ugly and nasty, and should be interpreted as a design smell. + +[singleton_cocoasamurai]: http://cocoasamurai.blogspot.com/2011/04/singletons-your-doing-them-wrong.html + +## Properties + +Properties should be named as much descriptively as possible, avoiding abbreviation, and camel-case with the leading word being lowercase. Luckily our tool of choice is able to autocomplete everything we type (well... almost everything. Yes, I'm looking at you Xcode's Derived Data) so there is no reason to save a couple of chars, but is better to convey more information as possible in your source code. +property should be named as descriptively as possible, avoiding abbreviation, and camel-case with the leading word being lowercase. Luckily our tool of choice is able to autocomplete everything we type (well...almost always. Yes, I'm looking at you Xcode's Derived Data) so there is no reason to save a couple of characters, but is better to convey more information as possible in your source code. + +**For example:** +```objc +NSString *text; +``` + +**Not:** +```objc +NSString* text; +NSString * text; +``` + +`` not `NSString* text` or `NSString * text`, except in the case of constants. +This is actually a matter of common sense and readability: C++ developers often prefer to separate the type from the name of the variable, and as the type in its pure form would be `NSString*` (for objects allocated on the heap, as in C++ it'd be possible to allocate objects on the stack) the first not suggested choice above is used. + +Use auto-synthesize for properties rather than manual `@synthesize` statements unless your properties are part of a protocol rather than a concrete class. If Xcode can automatically synthesize the variable, then let it do so; moreover it'd be a part of the code that is just redundant and that you have to maintain without a real benefit. + +You should always use the setter and getter to access the property, except for the `init` and `dealloc` methods. Generally speaking, using the property gives you an increased visual clue that what you're accessing is outside you current scope and therefor is subject to side-effect. + +You should always prefer the setter because: + +* Using the setter will respect the defined memory-management semantics (`strong`, `weak`, `copy` etc...). This was definitely more relevant before ARC but it's still relevant; think, for example, the `copy` semantic, every time you use the setter the passed value is copied without any additional operation; +* KVO notifications (`willChangeValueForKey`, `didChangeValueForKey`) are fired automatically; +* It is easier to debug: you can set a breakpoint on the property declaration and the breakpoint will fire every time the getter/setter is called, or you can set a breakpoint inside a custom setter/getter; +* It allows to add extra logic when setting a value in a single place. + +You should alway prefer the getter: + +* It is resilient to future change (e.g. the property is dynamically generated); +* It allows subclassing; +* It is easier to debug (i.e. Is possible to put a breakpoint in the getter and see who's accessing that specific getter); +* It makes the intent clear and explicit: by accessing an ivar `_anIvar` you are actually accessing `self->_anIvar`. This can lead to problems, for instance, accessing the iVar inside a block (you're capturing and retaining self even if you don't explicitly see the keyword `self`); +* It automatically fires KVO notifications; +* The overhead introduced by the message sending is very low and in the most of the case is negligible. For more information on the performance penalty introduced by the property you may find an interesting performance rundown [Should I Use a Property or an Instance Variable?](http://blog.bignerdranch.com/4005-should-i-use-a-property-or-an-instance-variable/) + +#### Init and Dealloc + +There is however an exception to what stated before: you must never use the setter (or the getter) in the `init` (and other initializer method), and instead you should always access directly the variable using the instance variable. This is to be defensive against subclassing: eventually a subclass can override the setter (or getter) and trying to call other methods, access properties or iVars that aren't in a consistent state or fully-initialized. Remember that an object is considered fully initialized and in a consistent state only after the init returns. The same applies for the `dealloc` method (during the `dealloc` method an object can be in a inconsistent state). This is also clearly stated many times over time: + +* [Advanced Memory Management Programming Guide](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmPractical.html#//apple_ref/doc/uid/TP40004447-SW6) under the self-explanatory section "Don't Use Accessor Methods in Initializer Methods and dealloc"; +* [Migrating to Modern Objective-C](http://adcdownload.apple.com//wwdc_2012/wwdc_2012_session_pdfs/session_413__migrating_to_modern_objectivec.pdf) at WWDC 2012 at slide 27; +* in a [pull request](https://github.com/NYTimes/objective-c-style-guide/issues/6) form Dave DeLong's. + +Moreover, using the setter in the init will not play nicely with `UIAppearence` proxy (please refer to [UIAppearance for Custom Views](http://petersteinberger.com/blog/2013/uiappearance-for-custom-views/) for additional informations). + +#### Dot-Notation + +When using the setter/getter always prefer the dot notation. +Dot-notation should *always* be used for accessing and mutating properties. + +**For example:** +```objc +view.backgroundColor = [UIColor orangeColor]; +[UIApplication sharedApplication].delegate; +``` + +**Not:** +```objc +[view setBackgroundColor:[UIColor orangeColor]]; +UIApplication.sharedApplication.delegate; +``` +Using the dot notation will ensure a visual clue to help distinguish between a property or a typical method call. + +### Property Declaration + +The preferred way to declare a property is the following format + +```objc +@property (nonatomic, readwrite, copy) NSString *name; +``` + +The property attributes should be ordered as following: atomicity, read/write and memory-managements storage. By doing this your attributes are more likely to change in the right most position and it's easier to scan with your eyes. + +You must use `nonatomic` attribute, unless strictly necessary. On iOS, the locking introduced by `atomic` can significantly affect the performances. + +Properties that stores a block, in order to keep it alive after the end of the declaration scope, must be `copy` (the block is initially created on the stack, calling `copy` cause the block to be copied on the heap). + +In order to achieve a public getter and a private setter, you can declare the public property as `readonly` and re-declare the same property in the the class extension as `readwrite`: + +```objc +@interface MyClass : NSObject +@property (nonatomic, readonly) NSObject *object +@end + +@implementation MyClass () +@property (nonatomic, readwrite, strong) NSObject *object +@end +``` + +If the name of a `BOOL` property is expressed as an adjective, the property can omit the "is" prefix but specifies the conventional name for the get accessor, for example: + +```objc +@property (assign, getter=isEditable) BOOL editable; +``` +Text and example taken from the [Cocoa Naming Guidelines](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CodingGuidelines/Articles/NamingIvarsAndTypes.html#//apple_ref/doc/uid/20001284-BAJGIIJE). + +In the implementation file avoid the use of `@synthesize`, Xcode is already adding this for you. + +#### Private Properties + +Private properties should be declared in class extensions (anonymous categories) in the implementation file of a class. Named categories (e.g. `ZOCPrivate`) should never be used unless extending another class. + +**For example:** + +```objc +@interface ZOCViewController () +@property (nonatomic, strong) UIView *bannerView; +@end +``` + +### Mutable Object + +Any property that potentially can be set with a mutable object (e.g. `NSString`,`NSArray`,`NSURL`) must have the memory-management type to `copy`. This is done in order to ensure the encapsulation and prevent that the value is changed after the property is set without that the object know it. + +You should also avoid to expose mutable object in the public interface, because this allows clients of your class to change your own internal representation and break the encapsulation. You can provide a read-only property that returns an immutable copy of your object: + +``` +/* .h */ +@property (nonatomic, readonly) NSArray *elements + +/* .m */ +- (NSArray *)elements { + return [self.mutableElements copy]; +} +``` + +### Lazy Loading + +There are cases when instantiate an object can be expensive and/or needs to be configured once and has some configuration involved that you don't want to clutter the caller method. + +In this case, instead of allocating the object in the init method one could opt for overriding the property getter for lazy instantiation. Usually the template for this kind of operation is the following: + +```objc +- (NSDateFormatter *)dateFormatter { + if (!_dateFormatter) { + _dateFormatter = [[NSDateFormatter alloc] init]; + NSLocale *enUSPOSIXLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"]; + [dateFormatter setLocale:enUSPOSIXLocale]; + [dateFormatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss.SSSSS"]; + } + return _dateFormatter; +} +``` + +Even though this can be beneficial in some circumstance we advice to be thoughtful when you decide to do, and actually this should be avoided. The following are the arguments against the use of property with lazy initialization: + +* The getter should not have side effect. By looking a getter on the right-hand side you're not thinking that this is causing an object to be allocated or will lead to side effect. In fact, trying to call a getter without using the returned value the compiler will emit the warning "getter should not used for side effect"; +* You're moving the cost of the initialization as side effect of the first access, this will lead to difficulties to optimize performance issues (that are also hard to instrument); +* The moment of instantiation can be non deterministic: for example you're expecting that this property is first accessed by a method but as soon as you change the class implementation, the accessor gets called before your original expectation. This can cause problems especially if the instantiation logic has dependencies on other state of the class that may be different. In general is better to explicitly express the dependency; +* This behavior might not be KVO friendly. If the getter changes the reference it should fire a KVO notification for notify the change, it can be weird to receive a change notification when accessing a getter. + + +## Methods + +### Parameter Assert +Your method may require some parameter to satisfy certain condition (i.e. not to be nil): in such cases it's a good practice to use `NSParameterAssert()` to assert the condition and eventually throwing an exception. + +### Private methods + +Never prefix your private method with a single underscore `_`, this prefix is reserved by Apple, doing otherwise expose you to the risk of overriding an existing Apple's private method. + +## Equality + +In case you need to implement equality remember the contract: you need to implement both the `isEqual` and the `hash` methods. If two objects are considered equal through `isEqual`, the `hash` method must return the same value, but if `hash` returns the same value the object are not guaranteed to be equals. + +This contracts boils down to how the lookup of those objects is done when are stored in collections (i.e. `NSDictionary` and `NSSet` use hash table data structure underneath). + +```objc +@implementation ZOCPerson + +- (BOOL)isEqual:(id)object { + if (self == object) { + return YES; + } + + if (![object isKindOfClass:[ZOCPerson class]]) { + return NO; + } + + // check objects properties (name and birthday) for equality + ... + return propertiesMatch; +} + +- (NSUInteger)hash { + return [self.name hash] ^ [self.birthday hash]; +} + +@end +``` + +It is important to notice that the hash method must not return a constant. This is a typical error and causes serious problems as it will cause 100% of collisions in the hash table as the value returned by the hash method is actually used as key in the hash table. + +You should also always implement a typed equality check method with the following format `isEqualTo<#class-name-without-prefix#>:` +If you can, it's always preferable to call the typed equal method in order to avoid the type checking overhead. + +A complete pattern for the isEqual* method should be as so: + +```objc +- (BOOL)isEqual:(id)object { + if (self == object) { + return YES; + } + + if (![object isKindOfClass:[ZOCPerson class]]) { + return NO; + } + + return [self isEqualToPerson:(ZOCPerson *)object]; +} + +- (BOOL)isEqualToPerson:(Person *)person { + if (!person) { + return NO; + } + + BOOL namesMatch = (!self.name && !person.name) || + [self.name isEqualToString:person.name]; + BOOL birthdaysMatch = (!self.birthday && !person.birthday) || + [self.birthday isEqualToDate:person.birthday]; + + return haveEqualNames && haveEqualBirthdays; +} +``` + +Given an object instance the computation of the `hash` should be deterministic, this is extremely important if the object is added to a container object (i.e. `NSArray`, `NSSet`, or `NSDictionary`) otherwise the behavior will be undefined (all container objects use the object's hash to do the lookup and enforce specific property like the uniqueness of the objects contained). That said, the calculation of the hash should always be made only by using immutable properties or, better yet, by guarantee the immutability of the objects. + + +# Categories + +It is ugly, we know, but categories should always be prefixed with your lower case prefix and an underscore i.e. `- (id)zoc_myCategoryMethod`. This practice is also [recommended by Apple](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html#//apple_ref/doc/uid/TP40011210-CH6-SW4). + +This is absolutely needed because implementing a category method with a name already existing in the extended object or in another category may result in an undefined behavior. Practically, what is going to happen is that the implementation of the last category loaded will be the one that gets called. + +In case you want to be sure that you're not replacing any implementation with your own category you can set the environment variable `OBJC_PRINT_REPLACED_METHODS` to `YES`, this will print in the console the names of the methods that have been replaced. +At the time of writing LLVM 5.1 does not emit any warning or error for this, so be careful and don't override methods in categories. + +A good practice is to use prefix also for category names. + +**Example:** + +```objc +@interface NSDate (ZOCTimeExtensions) +- (NSString *)zoc_timeAgoShort; +@end +``` + +**Not:** + +```objc +@interface NSDate (ZOCTimeExtensions) +- (NSString *)timeAgoShort; +@end +``` + +Category can be used to group related method in a header file. This is a very common practice in Apple's framework (nearby is proposed an extract from `NSDate` header) and we strongly encourage to do the same in your code. +In our experience creating this groups can be helpful in further refactoring: when the interface of a class starts growing can be a signal that your class is doing to much and therefor violating the Single Responsibility Principle, the previously created groups be used to better understand the different responsibilities and help in breaking down the class in more self-contained components. + +```objc + +@interface NSDate : NSObject + +@property (readonly) NSTimeInterval timeIntervalSinceReferenceDate; + +@end + +@interface NSDate (NSDateCreation) + ++ (instancetype)date; ++ (instancetype)dateWithTimeIntervalSinceNow:(NSTimeInterval)secs; ++ (instancetype)dateWithTimeIntervalSinceReferenceDate:(NSTimeInterval)ti; ++ (instancetype)dateWithTimeIntervalSince1970:(NSTimeInterval)secs; ++ (instancetype)dateWithTimeInterval:(NSTimeInterval)secsToBeAdded sinceDate:(NSDate *)date; +// ... +@end +``` + +# Protocols + +A great miss in the Objective-C world is the outcome of the latest decades about abstract interfaces. The term interface is typically used to refer to the `.h` file of a class but it has also another meaning well known to Java programmers which is basically used to describe to a set of methods not backed by a concrete implementation. +In Objective-C the latter case is achieved by using protocols. For historical reasons, protocols (used as Java interfaces) are not so much used in Objective-C code and in general by the community. It's mainly because the majority of the code developed at Apple don't embrace this approach and almost all developers tend to follow Apple's patterns and guidelines. Apple uses protocols almost only for the delegation pattern. +The concept of abstract interface is very powerful, has roots in the computer science history and there are no reasons to pretend it can't be used in Objective-C. + +Here will be explained a powerful usage of protocols (intended as abstract interfaces) going through a concrete example: starting from a very bad designed architecture up to reaching a very well and reusable piece of code. + +The example presented is the implementation of a RSS feed reader (think of it as a common test task asked during technical interviews). + +The requirement is straightforward: presenting a remote RSS feed in a table view. + +A very naïve approach would be to create a `UITableViewController` subclass and code the entire logic for the retrieving of the feed data, the parsing and the displaying in one place, which is, in other words, a MVC (Massive View Controller). This would work but it's very bad designed and unfortunately it'd suffice to pass the interview step in some not-so-demanding tech startups. + +A minimal step forward would be to follow the Single Responsibility Principle and create at least 2 components to do the different tasks: + +- a feed parser to parse the results gathered from an endpoint +- a feed reader to display the results + +The interfaces for these classes could be as so: + +```objective-c + +@interface ZOCFeedParser : NSObject + +@property (nonatomic, weak) id delegate; +@property (nonatomic, strong) NSURL *url; + +- (id)initWithURL:(NSURL *)url; + +- (BOOL)start; +- (void)stop; + +@end + +``` + +```objective-c + +@interface ZOCTableViewController : UITableViewController + +- (instancetype)initWithFeedParser:(ZOCFeedParser *)feedParser; + +@end + +``` + +The `ZOCFeedParser` is initialized with a `NSURL` to the endpoint to fetch the RSS feed (under the hood it will probably use NSXMLParser and NSXMLParserDelegate to create meaningful data) and the `ZOCTableViewController` is initialized with the parser. We want it to display the values retrieved by the parser and we do it using delegation with the following protocol: + +```objective-c + +@protocol ZOCFeedParserDelegate +@optional +- (void)feedParserDidStart:(ZOCFeedParser *)parser; +- (void)feedParser:(ZOCFeedParser *)parser didParseFeedInfo:(ZOCFeedInfoDTO *)info; +- (void)feedParser:(ZOCFeedParser *)parser didParseFeedItem:(ZOCFeedItemDTO *)item; +- (void)feedParserDidFinish:(ZOCFeedParser *)parser; +- (void)feedParser:(ZOCFeedParser *)parser didFailWithError:(NSError *)error; +@end + +``` + +It's a perfectly reasonable and suitable protocol to deal with RSS, I'd say. The view controller will conform to it in the public interface: + +```objective-c +@interface ZOCTableViewController : UITableViewController +``` + +and the final creation code is like so: + +```objective-c +NSURL *feedURL = [NSURL URLWithString:@"http://bbc.co.uk/feed.rss"]; + +ZOCFeedParser *feedParser = [[ZOCFeedParser alloc] initWithURL:feedURL]; + +ZOCTableViewController *tableViewController = [[ZOCTableViewController alloc] initWithFeedParser:feedParser]; +feedParser.delegate = tableViewController; +``` + +So far so good and you're probably happy with this new code, but how much of this code can be effectively reused? The view controller can only deal with objects of type `ZOCFeedParser`: at this point we just split the code in 2 components without any additional and tangible value than separation of responsibilities. + +The responsibility of the view controller should be to "display items provided by " but if we are allowed to pass to it only `ZOCFeedParser` objects this can't hold. Here surfaces the need for a more general type of object to be used by the view controller. + +We modify our feed parser introducing the `ZOCFeedParserProtocol` protocol (in the ZOCFeedParserProtocol.h file where also `ZOCFeedParserDelegate` will be). + +```objective-c + +@protocol ZOCFeedParserProtocol + +@property (nonatomic, weak) id delegate; +@property (nonatomic, strong) NSURL *url; + +- (BOOL)start; +- (void)stop; + +@end + +@protocol ZOCFeedParserDelegate +@optional +- (void)feedParserDidStart:(id)parser; +- (void)feedParser:(id)parser didParseFeedInfo:(ZOCFeedInfoDTO *)info; +- (void)feedParser:(id)parser didParseFeedItem:(ZOCFeedItemDTO *)item; +- (void)feedParserDidFinish:(id)parser; +- (void)feedParser:(id)parser didFailWithError:(NSError *)error; +@end + +``` + +Notice that the delegate protocol now deals with objects conforming to our new protocol and the interface file of the ZOCFeedParser would be more skinny: + +```objective-c + +@interface ZOCFeedParser : NSObject + +- (id)initWithURL:(NSURL *)url; + +@end + +``` + +As `ZOCFeedParser`now conforms to `ZOCFeedParserProtocol`, it must implement all the required methods. +At this point the view controller can accept any object conforming to the new protocol, having the certaincy that the object will respond to `start` and `stop` methods and that it will provide info through the delegate property. This is all the view controller should know about the given objects and no implementation details should concern it. + + +```objective-c + +@interface ZOCTableViewController : UITableViewController + +- (instancetype)initWithFeedParser:(id)feedParser; + +@end + +``` + +This might seems as a little change, but indeed is a huge improvement because now the view controller is working against a contract, not a concrete implementation this lead to many advantages: + +- the view controller can now accept any object that provide some information via the delegate property: this can be a RSS remote feed parser, a local one, a service that read other types of data remotely or even a service that fetch data from the local database; +- the feed parser object can be totally reused (as it was before after the first refactoring step); +- ZOCFeedParser and ZOCFeedParserDelegate can be reused by other components; +- ZOCViewController (UI logic apart) can be reused. +- it is very easy to test the code because it is very easy to inject a test double conforming to the expected protocol + + +Everything that is designed to be reused in future is implicitly better code and should be always the programmer's goal. Code designed this way is what makes the difference between an experienced programmer and a newbie. + +The final code proposed here can be found [here](http://github.com/albertodebortoli/ADBFeedReader). + +When implementing a protocol you should always strive to adhere to the Liskov Substitution Principle meaning that you should be able to replace one implementation of an interface with another without breaking either the client or the implementation. +In other words this means that your protocol should not leak the detail of the implementing classes; be even more careful when designing the abstraction expressed by you protocol and alway keep in mind that the underlay implementation is irrelevant, what really matters is the contract that the abstraction expose to the consumer. + +# NSNotification + +When you define you own `NSNotification` you should define your notification's name as a string constant. Like any string constant, it should be declared as extern in the public interface, and defined privately in the corresponding implementation. The value of the constant should be a reverse DNS identifier. + +```objc +// Foo.h +extern NSString * const ZOCFooDidBarNotification + +// Foo.m +NSString * const ZOCFooDidBarNotification = @"com.zenobjective-c.ZOCFooDidBarNotification"; +``` + +# Beautifying the code + +### Spacing + +* Indent using 4 spaces. Never indent with tabs. Be sure to set this preference in Xcode. +* Method braces and other braces (`if`/`else`/`switch`/`while` etc.) always open on the same line as the statement but close on a new line. + +**Preferred:** +```objc +if (user.isHappy) { + //Do something +} +else { + //Do something else +} +``` + +**Not Preferred:** +```objc +if (user.isHappy) +{ + //Do something +} else { + //Do something else +} +``` + +* There should be exactly one blank line between methods to aid in visual clarity and organization. Whitespace within methods should separate functionality, but often there should probably be new methods. +* Prefer using auto-synthesis. But if necessary, `@synthesize` and `@dynamic` should each be declared on new lines in the implementation. +* Colon-aligning method invocation should often be avoided. There are cases where a method signature may have more than 3 colons and colon-aligning makes the code more readable. Always colon align methods, even if they contain blocks. + +**Preferred:** + +```objc +[UIView animateWithDuration:1.0 + animations:^{ + // something + } + completion:^(BOOL finished) { + // something + }]; +``` + + +**Not Preferred:** + +```objc +[UIView animateWithDuration:1.0 animations:^{ + // something +} completion:^(BOOL finished) { + // something +}]; +``` + +If auto indentation falls into bad readability, declare blocks in variables before or reconsider your method signature. + +### Line Breaks +Line breaks are an important topic since this style guide is focused for print and online readability. + +For example: +```objc +self.productsRequest = [[SKProductsRequest alloc] initWithProductIdentifiers:productIdentifiers]; +``` + +A long line of code like the one above should be carried on to the second line adhering to this style guide's Spacing section (two spaces). + +```objc +self.productsRequest = [[SKProductsRequest alloc] + initWithProductIdentifiers:productIdentifiers]; +``` + +### Brackets + +Use egyptian brackets for: + +* control structures (if-else, for, switch) + +Non-egyptian brackets are accepted for: + +* class implementations (if any) +* method implementations + + + + +# Code Organization + +[Quoting](http://nshipster.com/pragma/) Mattt Thompson + +> code organization is a matter of hygiene + +We could not agree more. Having you code clearly organized in a clean and defined manner is a way to show respect for yourself and other people that will read and change you code (consider the future you included). + +## Exploit Code Block + +A very obscure GCC behavior that it is also supported by Clang is the ability of a code block to return the value of the latest statement if enclosing in round bracket. + +```objc +NSURL *url = ({ + NSString *urlString = [NSString stringWithFormat:@"%@/%@", baseURLString, endpoint]; + [NSURL URLWithString:urlString]; +}); +``` +This feature can be nicely organized to group small chunk of code that usually are necessary only for the sole purpose of setting up a class. +This gives a reader an important visual clue and help reduce the visual noise focusing on the most important variable in the function. +Additionally, this technique has the advantage that all the variables declared inside the code block, as one might expect, are valid only inside that scope, this mean that the your not polluting the method's stack trace and you can reuse the variable name without having duplicated symbols. + +## Pragma + +### Pragma Mark + +`#pragma mark -` is a great way to organize the code inside a class and helps you grouping methods implementation. +We suggest to use `#pragma mark -`to separate: + +- methods in functional groupings +- protocols implementations. +- methods overridden from a superclass + + +```objc + +- (void)dealloc { /* ... */ } +- (instancetype)init { /* ... */ } + +#pragma mark - View Lifecycle + +- (void)viewDidLoad { /* ... */ } +- (void)viewWillAppear:(BOOL)animated { /* ... */ } +- (void)didReceiveMemoryWarning { /* ... */ } + +#pragma mark - Custom Accessors + +- (void)setCustomProperty:(id)value { /* ... */ } +- (id)customProperty { /* ... */ } + +#pragma mark - IBActions + +- (IBAction)submitData:(id)sender { /* ... */ } + +#pragma mark - Public + +- (void)publicMethod { /* ... */ } + +#pragma mark - Private + +- (void)_privateMethod { /* ... */ } + +#pragma mark - UITableViewDataSource + +- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { /* ... */ } + +#pragma mark - ZOCSuperclass + +// ... overridden methods from ZOCSuperclass + +#pragma mark - NSObject + +- (NSString *)description { /* ... */ } + +``` + +The above marks will help to visually separate and organize the code. One of the pros is that you can cmd+click on the mark to jump to the symbol definition. +Be aware that even though the use of pragma mark is a sign of craftmanship, it's not a good reason to make grow the number of methods in your class in a unbounded fashion: having too many of them should be a warning sign that your class has too many responsibilities and a good opportunity for refactoring. + + +### Notes about pragma + +At http://raptureinvenice.com/pragmas-arent-just-for-marks there's a great discussion about pragmas, reported in part here. + +While most iOS developers don't play around much with compiler options, some options are useful to control how strictly to check (or not check) your code for errors. Sometimes, though, you want to make an exception directly in your code using a pragma, which purpose is to temporarily disable a compiler behavior. + +When you use ARC, the compiler inserts memory-management calls for you. There are cases, though, where it can get confused. One such case is when you use `NSSelectorFromString` to have a dynamically-named selector called. Since ARC can't know what the method will be and what kind of memory management to use, you'll be warned with `performSelector may cause a leak because its selector is unknown`. + +If you know your code won't leak, you can suppress the warning for just this instance by wrapping it like this: + +```objc +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Warc-performSelector-leaks" + +[myObj performSelector:mySelector withObject:name]; + +#pragma clang diagnostic pop +``` + +Note how we disable the -Warc-performSelector-leaks check by pushing and popping the change around our code. This assures us we don't disable it globally, which would be a huge mistake. + +The entire list of options that can be enable or disabled can be found at [The Clang User's Manual](http://clang.llvm.org/docs/UsersManual.html) to learn about all of them. + +Suppressing warnings for unused variables + +It's useful to be told that a variable you've defined is going unused. In most cases, you want to remove these references to improve performance (however slightly), but sometimes you want to keep them. Why? Perhaps they have a future usage or the functionality is only temporarily removed. Either way, a smarter way to suppress the warning without brutally commenting out the relevant lines, is to use the `#pragma unused()`: + +```objc +- (void)giveMeFive +{ + NSString *foo; + #pragma unused (foo) + + return 5; +} +``` + +Now you can keep your code in place without the compiler complaining about it. And yes, that pragma needs to go below the offending code. + +## Explicit warnings and errors + +The compiler is a robot: it will mark what's wrong with your code using a set of rules that've been defined by Clang. But, every so often you're smarter than it. Often, you might find some offending code that you know will lead to problems but, for whatever reason, can't fix yourself at the moment. You can explicitly signal errors like this: + +```objc +- (NSInteger)divide:(NSInteger)dividend by:(NSInteger)divisor +{ + #error Whoa, buddy, you need to check for zero here! + return (dividend / divisor); +} +``` + +You can signal warnings similarly: + +```objc +- (float)divide:(float)dividend by:(float)divisor +{ + #warning Dude, don't compare floating point numbers like this! + if (divisor != 0.0) { + return (dividend / divisor); + } else { + return NAN; + } +} +``` + +## Docstrings + +All non-trivial methods, interfaces, categories, and protocol declarations should have accompanying comments describing their purpose and how they fit into the larger picture. For more examples, see the Google Style Guide around [File and Declaration Comments](http://google-styleguide.googlecode.com/svn/trunk/objcguide.xml#File_Comments). + +To summarize: There are two types of docstrings, long-form and short-form. + +A short-form docstring fits entirely on one line, including the comment slashes. It is used for simple functions, especially (though by no means exclusively) ones that are not part of a public API: + +``` +// Return a user-readable form of a Frobnozz, html-escaped. +``` + +Note that the text is specified as an action ("return") rather than a description ("returns"). + +If the description spills past one line, you should move to the long-form docstring: a summary line (one physical line) preceded by an opening block comment with two asterisks on a line of its own (/\*\*, terminated by a period, question mark, or exclamation point, followed by a blank line, followed by the rest of the doc string starting at the same cursor position as the first quote of the first line, ending with an end-block comment (\*/) on a line by itself. + +``` +/** + This comment serves to demonstrate the format of a docstring. + + Note that the summary line is always at most one line long, and + after the opening block comment, and each line of text is preceded + by a single space. +*/ +``` + +A function must have a docstring unless it meets all of the following criteria: + +* not externally visible +* very short +* obvious + +The docstring should describe the function's calling syntax and its semantics, not its implementation. + +## Comments + +When they are needed, comments should be used to explain why a particular piece of code does something. Any comments that are used must be kept up-to-date or deleted. + +Block comments should generally be avoided, as code should be as self-documenting as possible, with only the need for intermittent, few-line explanations. *Exception: This does not apply to those comments used to generate documentation.* + +### Header Documentation + +The documentation of class should be done using the Doxygen/AppleDoc syntax only in the .h files when possible. Documentation should be provided for methods and properties. + +**For example:** + +```objc +/** + * Designated initializer. + * + * @param store The store for CRUD operations. + * @param searchService The search service used to query the store. + * + * @return A ZOCCRUDOperationsStore object. + */ +- (instancetype)initWithOperationsStore:(id)store + searchService:(id)searchService; +``` + + + + +# Inter-Object Communication + +Every non-trivial software is based on objects that need to communicate with each other to meet complex goals. This chapter is about design concepts going first into deep explanations on how the armory to achieve great architectures works and how it should be used. + +## Blocks + +Blocks are the Objective-C version of well-knows constructs called lambdas or closures available in other languages many years now. + +They are a great way to design asynchronous APIs as so: + +```objc +- (void)downloadObjectsAtPath:(NSString *)path + completion:(void(^)(NSArray *objects, NSError *error))completion; +``` + +When designing something like the above, try to declare functions and methods to take no more than one block and always make the blocks be the last arguments. It is a good approach trying to combine data and error in one block instead of two separate blocks (usually one for the success and one for the failure). + +You should do this because: + +* Usually there are part of code that are shared between them (i.e. dismiss a progress or an activity indicator); +* Apple is doing the same, and it is always good to be consistent with the platform; +* Since Blocks are typically multiple lines of code, having the block be other than the last argument would break up the call site[1]; +* Taking more than one block as arguments would make the call site potentially unwieldy in length. It also introduces complexity[1]. + +Consider the above method, the signature of the completion block is very common: the first parameter regards the data the caller is interested in, the second parameter is the error encountered. The contract should be therefore as follow: + +* if `objects` is not nil, then `error` must be nil +* if `objects` is nil, then `error` must not be nil + +as the caller of this method is first interested in the actual data, an implementation like so is preferred: + +```objective-c +- (void)downloadObjectsAtPath:(NSString *)path + completion:(void(^)(NSArray *objects, NSError *error))completion { + if (objects) { + // do something with the data + } + else { + // some error occurred, 'error' variable should not be nil by contract + } +} +``` + +Moreover, as for synchronous methods, some of Apple's APIs write garbage values to the error parameter (if non-NULL) in successful cases, so checking the error can cause false positives. + + +### Under the Hood + +Some key points: + +* Blocks are created on the stack +* Blocks can be copied to the heap +* Blocks have their own private const copies of stack variables (and pointers) +* Mutable stack variables and pointers must be declared with the __block keyword + +If blocks aren't kept around anywhere, will remain on the stack and will go away when their stack frame returns. While on the stack, a block has no effect on the storage or lifetime of anything it accesses. If blocks need to exist after the stack frame returns, they can be copied to the heap and this action is an explicit operation. This way, a block will gain reference-counting as all objects in Cocoa. When they are copied, they take their captured scope with them, retaining any objects they refer. If a block references a stack variable or pointer, then when the block is initialized it is given its own copy of that variable declared const, so assignments won't work. When a block is copied, the `__block` stack variables it reference are copied to the heap and after the copy operation both block on the stack and brand new block on the heap refer to the variables on the heap. + +LLDB shows that a block is a nice piece of things. + +![](./images/blocks_debugger.png) + +The most important thing to note is that `__block` variables and pointers are treated inside the block as structs that obviously handle the reference to the real value/object. + +Blocks are first-class citizens in the Objective-C runtime: they have an `isa` pointer which defines a class through which the Objective-C runtime can access methods and storage. In a non-ARC environment you can mess things up for sure, and cause crashes due to dangling pointers. `__block` applies only when using the variables in the block, it simply says to the block: + +> Hey, this pointer or primitive type relies on the stack with its own address. Please refer to this little friend with a new variable on the stack. I mean… refer to the object with double dereference, and don't retain it. +Thank you, sir. + +If at some time after the declaration but before the invocation of the block, the object has been released and deallocated, the execution of the block will cause a crash. `__block` variables are not retained within the block. In the deep end… it's all about pointers, references, dereferences and retain count stuff. + +[blocks_uth1]: http://developer.apple.com/library/ios/#documentation/cocoa/Conceptual/Blocks/Articles/00_Introduction.html +[blocks_uth2]: http://ios-blog.co.uk/tutorials/programming-with-blocks-an-overview/ + + +### Retain cycles on self + +It's important not to get into retain cycles when using blocks and asynchronous dispatches. Always set a `weak` reference to any variable that could cause a retain cycle. Moreover, it is a good practice to nil the properties holding the blocks (i.e. `self.completionBlock = nil`) this will break potential retain cycle introduced by the block capturing the scope. + + +**Example:** + +```objc +__weak __typeof(self) weakSelf = self; +[self executeBlock:^(NSData *data, NSError *error) { + [weakSelf doSomethingWithData:data]; +}]; +``` + +**Not:** + +```objc +[self executeBlock:^(NSData *data, NSError *error) { + [self doSomethingWithData:data]; +}]; +``` + +**Example with multiple statements:** + +```objc +__weak __typeof(self)weakSelf = self; +[self executeBlock:^(NSData *data, NSError *error) { + __strong __typeof(weakSelf)strongSelf = weakSelf; + + [strongSelf doSomethingWithData:data]; + [strongSelf doSomethingWithData:data]; +}]; +``` + +**Not:** + +```objc +__weak __typeof(self)weakSelf = self; +[self executeBlock:^(NSData *data, NSError *error) { + [weakSelf doSomethingWithData:data]; + [weakSelf doSomethingWithData:data]; +}]; +``` + +You should add these two lines as snippets to Xcode and always use them exactly like this: + +```objc +__weak __typeof(self)weakSelf = self; +__strong __typeof(weakSelf)strongSelf = weakSelf; +``` + +Here we dig further about the subtle things to consider about the `__weak` and the `__strong` qualifiers for self inside blocks. To summarize, we can refer to self in three different ways inside a block: + +1. using the keyword `self` directly inside the block +2. declaring a `__weak` reference to self outside the block and referring to the object via this weak reference inside the block +3. declaring a `__weak` reference to self outside the block and creating a `__strong` reference to self using the weak reference inside the block + +**Case 1: using the keyword `self` inside a block** + +If we use directly the keyword `self` inside a block, the object is retained at block declaration time within the block (actually when the block is [copied][blocks_caveat13] but for sake of simplicity we can forget about it) . A const reference to self has its place inside the block and this affects the reference counting of the object. If the block is used by other classes and/or passed around we may want to retain self as well as all the other objects used by the block since they are *needed* for the execution of the block. + +```objc +dispatch_block_t completionBlock = ^{ + NSLog(@"%@", self); +} + +MyViewController *myController = [[MyViewController alloc] init...]; +[self presentViewController:myController + animated:YES + completion:completionHandler]; +``` + +No big deal. But... what if the block is retained by self in a property (as the following example) and therefore the object (self) retains the block? + +```objc +self.completionHandler = ^{ + NSLog(@"%@", self); +} + +MyViewController *myController = [[MyViewController alloc] init...]; +[self presentViewController:myController + animated:YES + completion:self.completionHandler]; +``` + +This is what is well known as a retain cycle and retain cycles usually should be avoided. The warning we receive from CLANG is: + +```objc +Capturing 'self' strongly in this block is likely to lead to a retain cycle +``` + +Here comes in the `__weak` qualifier. + +**Case 2: declaring a `__weak` reference to self outside the block and use it inside the block** + +Declaring a `__weak` reference to self outside the block and referring to it via this weak reference inside the block avoids retain cycles. This is what we usually want to do if the block is already retained by self in a property. + +```objc +__weak typeof(self) weakSelf = self; +self.completionHandler = ^{ + NSLog(@"%@", weakSelf); +}; + +MyViewController *myController = [[MyViewController alloc] init...]; +[self presentViewController:myController + animated:YES + completion:self.completionHandler]; +``` + +In this example the block does not retain the object and the object retains the block in a property. Cool. We are sure that we can refer to self safely, at worst, it is nilled out by someone. The question is: how is it possible for self to be "destroyed" (deallocated) within the scope of a block? + +Consider the case of a block being copied from an object to another (let's say myController) as a result of the assignment of a property. The former object is then released before the copied block has had a chance to execute. + +The next step is interesting. + +**Case 3: declaring a `__weak` reference to self outside the block and use a `__strong` reference inside the block** + +You may think, at first, this is a trick to use self inside the block avoiding the retain cycle warning. This is not the case. The strong reference to self is created at *block execution time* while using self in the block is evaluated at *block declaration time*, thus retaining the object. + +[Apple documentation][blocks_caveat1] reports that "For non-trivial cycles, however, you should use" this approach: + +```objc +MyViewController *myController = [[MyViewController alloc] init...]; +// ... +MyViewController * __weak weakMyController = myController; +myController.completionHandler = ^(NSInteger result) { + MyViewController *strongMyController = weakMyController; + if (strongMyController) { + // ... + [strongMyController dismissViewControllerAnimated:YES completion:nil]; + // ... + } + else { + // Probably nothing... + } +}; +``` + +First of all, this example looks wrong to me. How can self be deallocated and be nilled out if the block itself is retained in the `completionHandler` property? The `completionHandler` property can be declared as `assign` or `unsafe_unretained` to allow the object to be deallocated after the block is passed around. +I can't see the reason for doing that. If other objects need the object (self), the block that is passed around should retain the object and therefore the block should not be assigned to a property. No `__weak`/`__strong` usage should be involved in this case. + +Anyway, in other cases it is possible for weakSelf to become nil just like the second case explained (declaring a weak reference outside the block and use it inside). + +Moreover, what is the meaning of "trivial block" for Apple? It is my understanding that a trivial block is a block that is not passed around, it's used within a well defined and controlled scope and therefore the usage of the weak qualifier is just to avoid a retain cycle. + +As [a][blocks_caveat2] [lot][blocks_caveat3] [of][blocks_caveat4] [online][blocks_caveat5] [references][blocks_caveat6], books ([Effective Objective-C 2.0][blocks_caveat14] by [Matt Galloway][blocks_caveat16] and [Pro Multithreading and Memory Management for iOS and OS X][blocks_caveat15] by Kazuki Sakamoto & Tomohiko Furumoto) discuss this edge case, the topic is not well understood yet by the majority of the developers. + +The real benefit of using the strong reference inside of a block is to be robust to preemption. Going again through the above 3 cases, during the execution of a block: + +**Case 1: using the keyword `self` inside a block** + +If the block is retained by a property, a retain cycle is created between self and the block and both objects can't be destroyed anymore. If the block is passed around and copied by others, self is retained for each copy. + +**Case 2: declaring a `__weak` reference to self outside the block and use it inside the block** + +There is no retain cycle and no matter if the block is retained or not by a property. If the block is passed around and copied by others, when executed, weakSelf can have been turned nil. +The execution of the block can be preempted and different subsequent evaluations of the weakSelf pointer can lead to different values (i.e. weakSelf can become nil at a certain evaluation). + +```objc +__weak typeof(self) weakSelf = self; +dispatch_block_t block = ^{ + [weakSelf doSomething]; // weakSelf != nil + // preemption, weakSelf turned nil + [weakSelf doSomethingElse]; // weakSelf == nil +}; +``` + +**Case 3: declaring a `__weak` reference to self outside the block and use a `__strong` reference inside the block** + +There is no retain cycle and, again, no matter if the block is retained or not by a property. If the block is passed around and copied by others, when executed, `weakSelf` can have been turned nil. When the strong reference is assigned and it is not nil, we are sure that the object is retained for the entire execution of the block if preemption occurs and therefore subsequent evaluations of strongSelf will be consistent and will lead to the same value since the object is now retained. If strongSelf evaluates to nil usually the execution is returned since the block cannot execute properly. + +```objc +__weak typeof(self) weakSelf = self; +myObj.myBlock = ^{ + __strong typeof(self) strongSelf = weakSelf; + if (strongSelf) { + [strongSelf doSomething]; // strongSelf != nil + // preemption, strongSelf still not nil + [strongSelf doSomethingElse]; // strongSelf != nil + } + else { + // Probably nothing... + return; + } +}; +``` + +In an ARC-based environment, the compiler itself alerts us with an error if trying to access an instance variable using the `->` notation. The error is very clear: + +```objc +Dereferencing a __weak pointer is not allowed due to possible null value caused by race condition, assign it to a strong variable first. +``` + +It can be shown with the following code: + +```obcs +__weak typeof(self) weakSelf = self; +myObj.myBlock = ^{ + id localVal = weakSelf->someIVar; +}; +``` + +In the very end: + +* **Case 1**: should be used only when the block is not assigned to a property, otherwise it will lead to a retain cycle. + +* **Case 2**: should be used when the block is assigned to a property. + +* **Case 3**: it is related to concurrent executions. When asynchronous services are involved, the blocks that are passed to them can be executed at a later period and there is no certainty about the existence of the self object. + +[blocks_caveat1]: http://developer.apple.com/library/mac/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html +[blocks_caveat2]: http://dhoerl.wordpress.com/2013/04/23/i-finally-figured-out-weakself-and-strongself/ +[blocks_caveat3]: http://blog.random-ideas.net/?p=160 +[blocks_caveat4]: http://stackoverflow.com/questions/7904568/disappearing-reference-to-self-in-a-block-under-arc + +[blocks_caveat5]: http://stackoverflow.com/questions/12218767/objective-c-blocks-and-memory-management +[blocks_caveat6]: https://github.com/AFNetworking/AFNetworking/issues/807 +[blocks_caveat10]: https://twitter.com/pedrogomes +[blocks_caveat11]: https://twitter.com/dmakarenko +[blocks_caveat12]: https://ef.com +[blocks_caveat13]: https://developer.apple.com/library/ios/documentation/cocoa/conceptual/Blocks/Articles/bxVariables.html#//apple_ref/doc/uid/TP40007502-CH6-SW4 +[blocks_caveat14]: http://www.effectiveobjectivec.com/ +[blocks_caveat15]: http://www.amazon.it/Pro-Multithreading-Memory-Management-Ios/dp/1430241160 +[blocks_caveat16]: https://twitter.com/mattjgalloway + +## Delegate and DataSource + +Delegation is a widespread pattern throughout Apple's frameworks and it is one of the most important pattern in the Gang of Four's book "Design Patterns". The delegation pattern is unidirectional, the message sender (the delegant) needs to know about the recipient (the delegate), but not the other way around. The coupling between the objects is loosen the sender only knows that its delegate conforms to a specific protocol. + +In its pure form, delegation is about providing callbacks to the delegate, which means that the delegate implements a set of methods with void return type. + +Unfortunately this has not been respected over years by the APIs from Apple and therefore developers acted imitating this misleading approach. A classic example is the [UITableViewDelegate](https://developer.apple.com/library/ios/documentation/uikit/reference/UITableViewDelegate_Protocol/Reference/Reference.html) protocol. + +While some methods have void return type and look like callbacks: + +```objective-c +- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath; +- (void)tableView:(UITableView *)tableView didHighlightRowAtIndexPath:(NSIndexPath *)indexPath; +``` + +others are definitely not: + +```objective-c +- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath; +- (BOOL)tableView:(UITableView *)tableView canPerformAction:(SEL)action forRowAtIndexPath:(NSIndexPath *)indexPath withSender:(id)sender; +``` + +When the delegant asks for some kind of information to the delegate object, the direction implied is from the delegate to the delegant and to the other way around anymore. This is conceptually different and a new name should be use to describe the pattern: DataSource. + +One could argue that Apple has a [UITableViewDataSouce](https://developer.apple.com/library/ios/documentation/uikit/reference/UITableViewDataSource_Protocol/Reference/Reference.html) protocol for it (forced under the name of the delegate pattern) but in reality it is used for methods providing information about how the real data should be presented. + +```objective-c +- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath; +- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView; +``` + +Moreover, in the above 2 methods Apple mixed the presentation layer with the data layer which is clearly ugly and in the end very few developers felt bad about it over times and even here we'll call delegate methods both methods with void return type and not void for simplicity. + +To split the concepts, the following approach should be used: + +* delegate pattern: when the delegant needs to notify the delegate about event occurred +* datasource pattern: when the delegant needs to fetch information from the datasource object + +Here is a concrete example: + +```objective-c +@class ZOCSignUpViewController; + +@protocol ZOCSignUpViewControllerDelegate +- (void)signUpViewControllerDidPressSignUpButton:(ZOCSignUpViewController *)controller; +@end + +@protocol ZOCSignUpViewControllerDataSource +- (ZOCUserCredentials *)credentialsForSignUpViewController:(ZOCSignUpViewController *)controller; +@end + +@protocol ZOCSignUpViewControllerDataSource + +@interface ZOCSignUpViewController : UIViewController + +@property (nonatomic, weak) id delegate; +@property (nonatomic, weak) id dataSource; + +@end + +``` + +Delegate methods should be always have the caller as first parameter as in the above example otherwise delegate objects could not be able to distinguish between different instances of delegants. In other words, if the caller is not passed to the delegate object, there would be no way for any delegate to deal with 2 delegant object. So, following is close to blasphemy: + +```objc +- (void)calculatorDidCalculateValue:(CGFloat)value; +``` + +By default, methods in protocols are required to be implemented by delegate objects. It is possible to mark some of them as optional and to be explicit about the required method using the `@required` and `@optional` keywords as so: + +```objective-c +@protocol ZOCSignUpViewControllerDelegate +@required +- (void)signUpViewController:(ZOCSignUpViewController *)controller didProvideSignUpInfo:(NSDictionary *); +@optional +- (void)signUpViewControllerDidPressSignUpButton:(ZOCSignUpViewController *)controller; +@end +``` + +For optional method, the delegant must check if the delegate actually implements a specific method before sending the message to it (otherwise a crash would occur) as so: + +```objective-c +if ([self.delegate respondsToSelector:@selector(signUpViewControllerDidPressSignUpButton:)]) { + [self.delegate signUpViewControllerDidPressSignUpButton:self]; +} +``` + +### Inheritance + +Sometimes you may need to override delegate methods. Consider the case of having two UIViewController subclasses: UIViewControllerA and UIViewControllerB, with the following class hierarchy. + +`UIViewControllerB < UIViewControllerA < UIViewController` + +`UIViewControllerA` conforms to `UITableViewDelegate` and implements `- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath`. + +You want to provide a different implementation for the method above in `UIViewControllerB`. An implementation like the following will work: + +```objective-c + +- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath { + CGFloat retVal = 0; + if ([super respondsToSelector:@selector(tableView:heightForRowAtIndexPath:)]) { + retVal = [super tableView:self.tableView heightForRowAtIndexPath:indexPath]; + } + return retVal + 10.0f; +} + +``` + +But what if the given method was not implemented in the superclass (`UIViewControllerA`)? + +The invocation + +```objective-c +[super respondsToSelector:@selector(tableView:heightForRowAtIndexPath:)] +``` + +will use the NSObject's implementation that will lookup, under the hood, in the context of `self` and clearly self implements the method but the app will crash at the next line with the following error: + +``` +*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[UIViewControllerB tableView:heightForRowAtIndexPath:]: unrecognized selector sent to instance 0x8d82820' +``` + +In this case we need to ask if instances of a specific class can respond to a given selector. The following code would do the trick: + +```objective-c + +- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath { + CGFloat retVal = 0; + if ([[UIViewControllerA class] instancesRespondToSelector:@selector(tableView:heightForRowAtIndexPath:)]) { + retVal = [super tableView:self.tableView heightForRowAtIndexPath:indexPath]; + } + return retVal + 10.0f; +} + +``` + +As code as the one above is ugly, often it'd be better to design the architecture in a way that delegate methods don't need to be overridden. + +### Multiple Delegation + +Multiple delegation is a very fundamental concept than unfortunately the majority of developers are hardly familiar with and too often NSNotifications are used instead. As you may have noticed, delegation and datasource are inter-object communication pattern involving only 2 objects: 1 delegant and 1 delegate. + +DataSource pattern is forced to be 1 to 1 as the information the sender asks for can be provided by one and only one object. Things are different for the delegate pattern and it would be perfectly reasonable to have many delegate objects waiting for the callbacks. + +There are cases where at least 2 objects are interested in receiving the callbacks from a particular delegant and the latter wants to know all of its delegates. This approach maps better a distributed system and more generically how complex flows of information usually go in wide software. + +Multiple delegation can be achieved in many ways and the reader is dare to find a proper personal implementation. A very neat implementation of multiple delegation using the forward mechanism is given by Luca Bernardi in his [LBDelegateMatrioska](https://github.com/lukabernardi/LBDelegateMatrioska). + +A basic implementation is given here to unfold the concept. Even if in Cocoa there are ways to store weak references in a data structure to avoid retain cycles, here we use a class to hold a weak reference to the delegate object as single delegation does. + +```objective-c +@interface ZOCWeakObject : NSObject + +@property (nonatomic, weak, readonly) id object; + ++ (instancetype)weakObjectWithObject:(id)object; +- (instancetype)initWithObject:(id)object; + +@end +``` + +```objective-c +@interface ZOCWeakObject () +@property (nonatomic, weak) id object; +@end + +@implementation ZOCWeakObject + ++ (instancetype)weakObjectWithObject:(id)object { + return [[[self class] alloc] initWithObject:object]; +} + +- (instancetype)initWithObject:(id)object { + if ((self = [super init])) { + _object = object; + } + return self; +} + +- (BOOL)isEqual:(id)object { + if (self == object) { + return YES; + } + + if (![object isKindOfClass:[object class]]) { + return NO; + } + + return [self isEqualToWeakObject:(ZOCWeakObject *)object]; +} + +- (BOOL)isEqualToWeakObject:(ZOCWeakObject *)object { + if (!object) { + return NO; + } + + BOOL objectsMatch = [self.object isEqual:object.object]; + return objectsMatch; +} + +- (NSUInteger)hash { + return [self.object hash]; +} + +@end +``` + +A simple component using weak objects to achieve multiple delegation: + +```objective-c +@protocol ZOCServiceDelegate +@optional +- (void)generalService:(ZOCGeneralService *)service didRetrieveEntries:(NSArray *)entries; +@end + +@interface ZOCGeneralService : NSObject +- (void)registerDelegate:(id)delegate; +- (void)deregisterDelegate:(id)delegate; +@end + +@interface ZOCGeneralService () +@property (nonatomic, strong) NSMutableSet *delegates; +@end +``` + +```objective-c +@implementation ZOCGeneralService +- (void)registerDelegate:(id)delegate { + if ([delegate conformsToProtocol:@protocol(ZOCServiceDelegate)]) { + [self.delegates addObject:[[ZOCWeakObject alloc] initWithObject:delegate]]; + } +} + +- (void)deregisterDelegate:(id)delegate { + if ([delegate conformsToProtocol:@protocol(ZOCServiceDelegate)]) { + [self.delegates removeObject:[[ZOCWeakObject alloc] initWithObject:delegate]]; + } +} + +- (void)_notifyDelegates { + ... + for (ZOCWeakObject *object in self.delegates) { + if (object.object) { + if ([object.object respondsToSelector:@selector(generalService:didRetrieveEntries:)]) { + [object.object generalService:self didRetrieveEntries:entries]; + } + } + } +} + +@end +``` + +With the `registerDelegate:` and `deregisterDelegate:` methods, it is easy to connect/disconnect cables between components: if at some point in time a delegate object is not interested in receiving the callbacks from a delegant, it has the chance to just 'unsubscribe'. +This can be useful when there are different views waiting for some callback to update the shown info: if a view is temporarily hidden (but still alive) it could make sense for it to just unsubscribe to those callbacks. + + +# Aspect Oriented Programming + +Aspect Oriented Programming (AOP) is something not well-known in the Objective-C community but it should be as the runtime is so powerful that AOP should be one of the first things that comes to the mind. Unfortunately, as there is no standard de facto library, nothing comes ready to use out-of-the-box from Apple and the topic is far from being trivial, developers still don't think of it in nowadays. + +Quoting the [Aspect Oriented Programming](http://en.wikipedia.org/wiki/Aspect-oriented_programming) Wikipedia page: + +> An aspect can alter the behavior of the base code (the non-aspect part of a program) by applying advice (additional behavior) at various join points (points in a program) specified in a quantification or query called a pointcut (that detects whether a given join point matches). + + +In the world of Objective-C this means using the runtime features to add *aspects* to specific methods. The additional behaviors given by the aspect can be either: + +* add code to be performed before a specific method call on a specific class +* add code to be performed after a specific method call on a specific class +* add code to be performed instead of the original implementation of a specific method call on a specific class + +There are many ways to achieve this we are not digging into deep here, basically all of them leverage the power of the runtime. +[Peter Steinberger](twitter.com/steipete) wrote a library, [Aspects](github.com/steipete/Aspects) that fits the AOP approach perfectly. We found it reliable and well-designed and we are going to use it here for sake of simplicity. +As said for all the AOP-ish libraries, the library does some cool magic with the runtime, replacing and adding methods (further tricks over the method swizzling technique). +The API of Aspect are interesting and powerful: + +```objective-c ++ (id)aspect_hookSelector:(SEL)selector + withOptions:(AspectOptions)options + usingBlock:(id)block + error:(NSError **)error; +- (id)aspect_hookSelector:(SEL)selector + withOptions:(AspectOptions)options + usingBlock:(id)block + error:(NSError **)error; +``` + +For instance, the following code will perform the block parameter after the execution of the method `myMethod:` (instance or class method that be) on the class `MyClass`. + +```objective-c +[MyClass aspect_hookSelector:@selector(myMethod:) + withOptions:AspectPositionAfter + usingBlock:^(id aspectInfo) { + ... + } + error:nil]; +``` + +In other words: the code provided in the block parameter will always be executed after each call of the `@selector` parameter on any object of type `MyClass` (or on the class itself if the method is a class method). + +We added an aspect on `MyClass` for the method `myMethod:`. + +Usually AOP is used to implement cross cutting concern. Perfect example to leverage are analytics or logging. + +In the following we will present the use of AOP for analytics. Analytics are a popular "feature" to include in iOS projects, with a huge variety of choices ranging from Google Analytics, Flurry, MixPanel, etc. +Most of them have tutorials describing how to track specific views and events including a few lines of code inside each class. + +On Ray Wenderlich's blog there is a long [article](http://www.raywenderlich.com/53459/google-analytics-ios) with some sample code to include in your view controller in order to track an event with [Google Analytics](https://developers.google.com/analytics/devguides/collection/ios/): + +```objective-c +- (void)logButtonPress:(UIButton *)button { + id tracker = [[GAI sharedInstance] defaultTracker]; + [tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"UX" + action:@"touch" + label:[button.titleLabel text] + value:nil] build]]; +} +``` + +The code above sends an event with context information whenever a button is tapped. Things get worse when you want to track a screen view: + +```objc +- (void)viewDidAppear:(BOOL)animated { + [super viewDidAppear:animated]; + + id tracker = [[GAI sharedInstance] defaultTracker]; + [tracker set:kGAIScreenName value:@"Stopwatch"]; + [tracker send:[[GAIDictionaryBuilder createAppView] build]]; +} +``` + +This should look like a code smell to the most of the experienced iOS developers. We are actually making the view controller dirty adding lines of code that should not belong there as it's not responsibility of the view controller to track events. You could argue that you usually have a specific object responsible for analytics tracking and you inject this object inside the view controller but the problem is still there and no matter where you hide the tracking logic: you eventually end up inserting some lines of code in the `viewDidAppear:`. + +We can use AOP to track screen views on specific `viewDidAppear:` methods, and moreover, we could use the same approach to add event tracking in other methods we are interested in, for instance when the user taps on a button (i.e. trivially calling the corresponding IBAction). + +This approach is clean and unobtrusive: + +* the view controllers will not get dirty with code that does not naturally belongs to them +* it becomes possible to specify a SPOC file (single point of customization) for all the aspects to add to our code +* the SPOC should be used to add the aspects at the very startup of the app +* if the SPOC file is malformed and at least one selector or class is not recognized, the app will crash at startup (which is cool for our purposes) +* the team in the company responsible for managing the analytics usually provides a document with the list of *things* to track; this document could then be easily mapped to a SPOC file +* as the logic for the tracking is now abstracted, it becomes possible to scale with a grater number of analytics providers +* for screen views it is enough to specify in the SPOC file the classes involved (the corresponding aspect will be added to the `viewDidAppear:` method), for events it is necessary to specify the selectors. To send both screen views and events, a tracking label and maybe extra meta data are needed to provide extra information (depending on the analytics provider). + +We may want a SPOC file similar to the following (also a .plist file would perfectly fit as well): + +```objective-c +NSDictionary *analyticsConfiguration() +{ + return @{ + @"trackedScreens" : @[ + @{ + @"class" : @"ZOCMainViewController", + @"label" : @"Main screen" + } + ], + @"trackedEvents" : @[ + @{ + @"class" : @"ZOCMainViewController", + @"selector" : @"loginViewFetchedUserInfo:user:", + @"label" : @"Login with Facebook" + }, + @{ + @"class" : @"ZOCMainViewController", + @"selector" : @"loginViewShowingLoggedOutUser:", + @"label" : @"Logout with Facebook" + }, + @{ + @"class" : @"ZOCMainViewController", + @"selector" : @"loginView:handleError:", + @"label" : @"Login error with Facebook" + }, + @{ + @"class" : @"ZOCMainViewController", + @"selector" : @"shareButtonPressed:", + @"label" : @"Share button" + } + ] + }; +} +``` + +The architecture proposed is hosted on GitHub on the [EF Education First](https://github.com/ef-ctx/JohnnyEnglish/blob/master/CTXUserActivityTrackingManager.m) profile. + +```objective-c +- (void)setupWithConfiguration:(NSDictionary *)configuration +{ + // screen views tracking + for (NSDictionary *trackedScreen in configuration[@"trackedScreens"]) { + Class clazz = NSClassFromString(trackedScreen[@"class"]); + + [clazz aspect_hookSelector:@selector(viewDidAppear:) + withOptions:AspectPositionAfter + usingBlock:^(id aspectInfo) { + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + NSString *viewName = trackedScreen[@"label"]; + [tracker trackScreenHitWithName:viewName]; + }); + }]; + + } + + // events tracking + for (NSDictionary *trackedEvents in configuration[@"trackedEvents"]) { + Class clazz = NSClassFromString(trackedEvents[@"class"]); + SEL selektor = NSSelectorFromString(trackedEvents[@"selector"]); + + [clazz aspect_hookSelector:selektor + withOptions:AspectPositionAfter + usingBlock:^(id aspectInfo) { + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + UserActivityButtonPressedEvent *buttonPressEvent = [UserActivityButtonPressedEvent eventWithLabel:trackedEvents[@"label"]]; + [tracker trackEvent:buttonPressEvent]; + }); + }]; + + } +} +``` + + + +# References + +Here are some of the documents from Apple that informed the style guide: + +* [The Objective-C Programming Language](http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html) +* [Cocoa Fundamentals Guide](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CocoaFundamentals/Introduction/Introduction.html) +* [Coding Guidelines for Cocoa](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CodingGuidelines/CodingGuidelines.html) +* [iOS App Programming Guide](http://developer.apple.com/library/ios/#documentation/iphone/conceptual/iphoneosprogrammingguide/Introduction/Introduction.html) +* [Apple Objective-C conventions](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html): code conventions from Apple; + +Others: + +* [Objcetive-Clean](http://objclean.com): an attempt to write a standard for writing Objective-C code with Xcode integration; +* [Uncrustify](http://uncrustify.sourceforge.net/): source code beutifier. + +### Other Objective-C Style Guides + +Here are some of the documents from Apple that informed the style guide. If something has not been mentioned in this book, it's probably covered in great detail in one of these: + +From Apple: + +* [The Objective-C Programming Language](http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html) +* [Cocoa Fundamentals Guide](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CocoaFundamentals/Introduction/Introduction.html) +* [Coding Guidelines for Cocoa](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CodingGuidelines/CodingGuidelines.html) +* [iOS App Programming Guide](http://developer.apple.com/library/ios/#documentation/iphone/conceptual/iphoneosprogrammingguide/Introduction/Introduction.html) + +From the community: + +* [NYTimes Objective-C Style Guide](https://github.com/NYTimes/objetive-c-style-guide) +* [Google](http://google-styleguide.googlecode.com/svn/trunk/objcguide.xml) +* [GitHub](https://github.com/github/objective-c-conventions) +* [Adium](https://trac.adium.im/wiki/CodingStyle) +* [Sam Soffes](https://gist.github.com/soffes/812796) +* [CocoaDevCentral](http://cocoadevcentral.com/articles/000082.php) +* [Luke Redpath](http://lukeredpath.co.uk/blog/my-objective-c-style-guide.html) +* [Marcus Zarra](http://www.cimgf.com/zds-code-style-guide/) + + + [1]: https://github.com/NYTimes/objective-c-style-guide/issues/6) diff --git a/images/blocks_debugger.png b/images/blocks_debugger.png new file mode 100644 index 0000000000000000000000000000000000000000..860035cd782fde5d2991b6588cf53d03c5811887 GIT binary patch literal 76021 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 literal 0 HcmV?d00001 diff --git a/images/zen-logo-big.png b/images/zen-logo-big.png new file mode 100644 index 0000000000000000000000000000000000000000..d884fb24c62b24996f2ba74a7e0e5fa74e8d6629 GIT binary patch literal 145534 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 z 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

Za8Knp%*WvG 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