For the best viewing experience, please download this presentation and view it in Keynote. SlideShare doesn't handle the animations well. Blocks are a powerful language feature. However, they are underused and under-appreciated in Objective-C, especially compared to Ruby. My intent is to make blocks easy to understand and show many practical uses of blocks.

1. Pragmatic Blocks
by Robert Brown
@robby_brown

2. Objectives
Introduce the concepts behind blocks
Touch lightly on Objective-C syntax
Focus on practical applications of blocks

3. Introduction

4. What are blocks?
Pieces of code that can be stored and executed when
needed
Also known as lambdas, closures, anonymous
functions, first-class functions, higher-order functions
Can be passed as a parameter, returned from a
method/function, and stored in data structures
Blocks make adding new features to a language easy

5. What does “closure” mean?
Blocks store all the variables that are in scope when the
block is created
Closure makes it possible to store a block indefinitely,
then restore the context at will
Objective-C objects are automatically retained/released
C objects must be manually retained/released

6. Block Syntax
Declaration Syntax:
returnType (^blockName) (Arguments)
Definition Syntax:
^ returnType (Arguments) { code; }
The return type and arguments are optional.

7. Block Syntax
Example:
returnType (^block)(args) = ^(args) { ... };
Block types are ugly, use typedef:
typedef returnType (^MyBlock)(args);
MyBlock block = ^(args) { ... };

8. Gotchas
Retain loops
Xcode profiler will warn you of block retain loops
Unlike regular Objective-C objects, blocks are created
on the stack
Be sure to call -copy if you need it to live beyond the
current stack frame
Make sure to de-stackify blocks before storing them
in a data structure

9. Application

10. What are blocks good for?
Completion callbacks
Continuations
Multithreading
Delegate replacement
Other design pattern modifications

11. Callbacks
Most uses of blocks are some form of callback
Since blocks have closure, they can restore the caller’s
context without any effort on our part

12. Completion Blocks
Most common use of blocks in Objective-C
A callback that happens only after some task has
finished
Some operations, such as network requests take an
unknown amount of time
Core Animation also uses many completion blocks

13. Completion Blocks
Object Object
A B
Block
Object B finishes executing and calls
Object A calls Object B and
passescompletion block.
the a completion block.

14. Completion Blocks
Object Object
A B
Block
Object B finishes executing and calls
Object A calls Object B and
passescompletion block.
the a completion block.

15. Completion Blocks
Object Object
A B
Block
Object B finishes executing and calls
Object A calls Object B and
passescompletion block.
the a completion block.

16. Continuations
Think of it like a completion block wrapped in a
completion block wrapped in a completion block...
Essentially building your own runtime stack.

17. Continuations
Object Object Object
A B C
Block
Object C BAthen calls Objectand to
Object finisheswraps Object A’s
Object A calls Object needwith
So, Object B Object B B and calls
Object and executing C
block theacompletion C finishes.
knownew completion block.
passes new completion block.
theinwhen Object block.
a completion block.

18. Continuations
Object Object Object
A B C
Block
Object C BAthen calls Objectand to
Object finisheswraps Object A’s
Object A calls Object needwith
So, Object B Object B B and calls
Object and executing C
block theacompletion C finishes.
knownew completion block.
passes new completion block.
theinwhen Object block.
a completion block.

19. Continuations
Object Object Object
A B C
Block
Object C BAthen calls Objectand to
Object finisheswraps Object A’s
Object A calls Object needwith
So, Object B Object B B and calls
Object and executing C
block theacompletion C finishes.
knownew completion block.
passes new completion block.
theinwhen Object block.
a completion block.

20. Continuations
Object Object Object
A B C
Block
Object C BAthen calls Objectand to
Object finisheswraps Object A’s
Object A calls Object needwith
So, Object B Object B B and calls
Object and executing C
block theacompletion C finishes.
knownew completion block.
passes new completion block.
theinwhen Object block.
a completion block.

21. Continuations
Object Object Object
A B C
Block
Object C BAthen calls Objectand to
Object finisheswraps Object A’s
Object A calls Object needwith
So, Object B Object B B and calls
Object and executing C
block theacompletion C finishes.
knownew completion block.
passes new completion block.
theinwhen Object block.
a completion block.

22. Continuations
Object Object Object
A B C
Block
Object C BAthen calls Objectand to
Object finisheswraps Object A’s
Object A calls Object needwith
So, Object B Object B B and calls
Object and executing C
block theacompletion C finishes.
knownew completion block.
passes new completion block.
theinwhen Object block.
a completion block.

23. Multithreading: GCD
Grand Central Dispatch (GCD) makes heavy use of
blocks
Blocks are not tied to a thread until they are executed
Blocks can be queued up without blocking threads
Threads can spend more time running and less time
waiting

24. Multithreading: GCD
Code can be made asynchronous simply by
surrounding it with dispatch_async(queue, ^{ ... });

25. Multithreading: GCD
Thread Pool Concurrent Queue
Block
Thread C
D
B
A
3
2-Core Processor
Thread
2
Thread
1

26. Multithreading: GCD
Thread Pool Concurrent Queue
Block
Thread C
D
3
2-Core Processor
Thread
2 Block
B
Thread Block
1 A

27. Multithreading: GCD
Thread Pool Concurrent Queue
Block
C
D
2-Core Processor
Thread Thread Block
3 1 A
Thread Block
2 B

28. Multithreading: GCD
Thread Pool Concurrent Queue
Block
C
D
2-Core Processor
Thread Block
1 A
Thread Thread Block
3 2 B

29. Multithreading: GCD
Thread Pool Concurrent Queue
2-Core Processor
Thread Block
1 A Block
D
Thread Thread Block Block
3 2 B C

30. Multithreading: GCD
Thread Pool Concurrent Queue
2-Core Processor
Thread Thread Block
2 1 A Block
D
Thread Block Block
3 B C

31. Multithreading: GCD
Thread Pool Concurrent Queue
2-Core Processor
Thread Block
1 A
Thread Thread Block
Block
2 3 C
B D

32. Multithreading: GCD
Thread Pool Concurrent Queue
2-Core Processor
Thread Block
1 A
Thread Thread Block
Block
2 3 C
B D

33. Multithreading: GCD
Thread Pool Concurrent Queue
2-Core Processor
Thread Block
2 A
D
Thread Thread Block
1 3 C
B

34. Multithreading: GCD
Thread Pool Concurrent Queue
2-Core Processor
Thread Thread Block
3 2 A
D
Thread Block
1 C
B

35. Multithreading: GCD
Thread Pool Concurrent Queue
Thread
2
2-Core Processor
Thread Block
3 A
D
Thread Block
1 C
B

36. Block Delegation
Delegates are essentially protocols that specify a list of
method callbacks
These method callbacks can be easily replaced with
block callbacks
Rule of thumb: 3 or less delegate callbacks should be
handled using blocks.

37. Block Delegation
Advantages:
No additional protocols
No need to conform to a protocol
Easy to change block callbacks dynamically

38. Block Delegation
Disadvantages:
May not be appropriate when more than 3 callbacks
are needed

39. Other Design Patterns

40. Template Method
Sometimes algorithms differ by only a few lines
Those few lines can be replaced by a virtual method
Subclasses define the virtual method

41. Template Method
Let’s use blocks instead!
Advantages:
No need for subclassing
May not need a new class at all
Template can be changed dynamically

42. Template Method
- (void)doSomethingUsingBlock:(dispatch_block_t)block {
// Do something
block();
// Do some more stuff
}

43. Example Templates

44. Debug Mode
+ (void)whileInDebug:(MyBlock)block {
#if defined(DEBUG)
NSParameterAssert(block);
block();
#endif
}

45. Lock Handling
// Python convenient lock handler
with myLock:
// Do something
// Can’t forget to lock/unlock

46. Lock Handling
+ (void)withLock:(NSLock)lock executeBlock:(MyBlock)block {
NSParameterAssert(lock && block);
[lock lock];
block();
[lock unlock];
}

47. Builder Pattern
Some objects have complex structures that vary widely
between uses
Examples: Database tables, UITableView
A block can define the construction of an object

48. Builder Pattern
// Ruby on Rails database table construction
create_table :person do |t|
t.string :name, null: false
t.integer :age, null: false
t.float :weight
end

49. Builder Pattern
// Contrived example, but very feasible.
// Creating a custom table view form.
[RBTableView tableViewUsingBlock:^(RBTableView * t) {
[t addStringField:@“name” required:YES];
[t addIntegerField:@“age” required:YES];
[t addFloatField:@“weight” required:NO];
}];

50. Lockless Exclusion
Accessor
Thread-sensitive code is called critical code
GCD allows for lockless-exclusion
Lockless code is faster than lock code

51. Lockless Exclusion
Accessor
Multi-threading challenges:
Multi-threaded code must be properly synchronized
It’s easy to forget to add thread-safety code

52. Lockless Exclusion
Accessor
Solution:
Have another object handle thread-safety
Put critical code in a block
Give the block to the thread-safety handler

53. Lockless Exclusion
Accessor
- (void)accessSharedDataAsync:(void(^)(id sharedData))block {
NSParameterAssert(block);
// myQueue must be a serial queue!
dispatch_async(myQueue, ^{
block([self sharedData]);
});
}

54. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
Block
LEA
C
B
A

55. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
Block
C
LEA
Block
B
Block
A

56. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
LEA
Block Block
A C
Block
B

57. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
LEA
Block Block
A C
Block
B

58. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
LEA
Block
A
B
Block
C

59. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
LEA
Block
A
B
Block
C

60. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
LEA
Block
C
A
B

61. Lockless Exclusion
Accessor
Shared Data Serial
Shared
Data
Manager Queue
LEA
Block
C
A
B

62. Read/Write LEA
Code that only reads from shared memory doesn’t
need exclusive access
Code that writes to shared memory needs exclusive
access
GCD barrier blocks and concurrent queues are a
perfect solution

63. Read/Write LEA
// Read-only LEA
- (void)accessSharedDataReadOnlyAsync:(void(^)(id sharedData))block {
NSParameterAssert(block);
// myQueue must be a concurrent queue!
dispatch_async([self myQueue], ^{
block([self sharedData]);
});
}

64. Read/Write LEA
// Read/write LEA
- (void)accessSharedDataReadWriteAsync:(void(^)(id sharedData))block {
NSParameterAssert(block);
// myQueue must be a concurrent queue!
dispatch_barrier_async([self myQueue], ^{
block([self sharedData]);
});
}

65. Read/Write LEA
// All-in-one R/W-LEA
- (void)accessSharedDataAsyncReadOnly:(BOOL)readOnly withBlock:(void(^)(id
sharedData))block {
if (readOnly)
dispatch_async([self myQueue], ^{ block([self sharedData]); });
else
dispatch_barrier_async([self myQueue], ^{ block([self sharedData]); });
}

66. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
R/W-LEA
Read
Write
Block

67. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
Write
R/W-LEA
Block
Read
Block
Read
Block
Read
Block

68. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
R/W-LEA
Read
Block
Read Read
Block Block
Write
Block

69. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
Read
R/W-LEA
Block
Read Read Read
Block Block Block
Write
Block

70. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
Read
R/W-LEA
Block
Read Read Read
Block Block Block
Write
Block

71. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
Read
R/W-LEA
Block
Read Read Read
Block Block Block
Write
Block

72. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
R/W-LEA
Write
Read Read Read
Block Block Block
Read
Block

73. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
R/W-LEA
Write
Read Read Read
Block Block Block
Read
Block

74. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
R/W-LEA
Write
Read Read
Block Block

75. Read/Write LEA
Shared Data Concurrent
Shared
Data
Manager Queue
R/W-LEA
Write
Read Read
Block Block

76. Homework
I have only touched the surface of what blocks can do
Explore and find other design patterns you can convert
to use blocks

77. Want to Learn More?
Blocks are best learned by playing with them
Learn Ruby
“The Pickaxe”
Learn Racket
10 Uses for Blocks
My Blog

78. Questions?