Category Archives: Objective-c

KirKos: App Development under 24h


κίρκος :  circle, mostly in form κρίκος (q.v.): hence, ring, IG11 (2).161B49 (Delos, iii B.C.): poet. for Prose κρίκος acc. to Poll.1.94:—neut. pl. κίρκα ἢ καταδέσματα PMag.Lond.121.299.

 I want to be able to add a blur effect around a picture (with a circle shape), and then save it or share it.

The idea/concept came from Rui Barroca. So, after an initial assessment at a Nando’s restaurant, we reached the following:

  • There were no applications doing this, or doing it how we wanted it to be (on a Business PoV).
  • Blur is a design trend that iOS 7 brought with it, so doing some work on that area is interesting (on a Dev & Designer PoV).
  • Doing so in less than 24hours, was a challenge that I happily embrace.

The concept, design, development and submission, started on a Thursday, 17/10 @ 21:00 and was finished on Monday, 21/10 @ 00:05. It took around 23 hours.


Must Have

  • Take Picture from camera.
  • Pick a photo from the gallery.
  • After selecting/taking the picture, be able to add a blur, with a circle shape, around a picture.
  • Be able to define the blur’s radius.
  • Save the picture with the blur effect on the Phone’s Gallery.

Could Have

  • Share the picture on the most common social networks.
  • Be able to use Instagram’s URL scheme and open the picture on Instagram, so it can be edited. 

Nice to Have

  • About Screen.
  • Pan Gesture, to resize the circle.
  • One finger gesture, to change the circle’s center. 

As you might expect, the “Nice to Have” section is out from the first version of the app. In our opinion, it will make sense, if we have enough people using it.  The “Must Have” was kept: even though we don’t bring a lot of features with KirKos, we wanted to make sure that what it does, does well, so we made sure the core functionality was there, from day one. Because we still had some time, the “Share the picture on the most common social networks.” is an integral part of the first version.  In the end, adding and removing features is hard, but you should focus on what’s the purpose of your application and that it delivers it seamlessly.


This is the Design version 1.0. With the Selection of the photo on the left, and the edition on the right:

1.0_KirKos_CaptureScreenv_v0.1                             1.1_KirKos_EditShareScreenv_v0.1

This is version 2.0:

1.0_KirKos_CaptureScreen_v0.2                             1.1_KirKos_EditShareScreen_v0.2

On a first look, the difference is not that big. But  take into consideration that  version 1, just doesn’t work  with 3.5′ iPhone, due to the menu where you have the flash &  switch front/rear camera, you couldn’t accomodate that in 3.5′. So on version 2.0, we pushed the flash and “switch front/back camera” to the camera area.  This gave us a bit more room for the 4′ version, and decent UI for the 3.5′. We also decided to separate the “Share Button” and the “Save Button”. The initial purpose was to be able to save the image on the phone, but sharing it, on the long run, is more important, so we keep the Share button on the mid. You are also able to save it on your gallery by pressing the “Share Button”, but for the time being we will keep as it is.


The first question that popped into my mind was how could I create the Blur? Fortunately, in that matter, we have quite a lot to choose from. The initial design of the app, was to allow the user to apply the filter while the camera was on, this is very important to decide which 3rd party lib you are going to use. After knowing that FXBlurView wouldn’t work as I wanted, I gave GPUImage  a try. Not sure why, I wasn’t able to put it to work on my first try, so I decided to use the same workflow as Instagram:

Pick/Take Photo -> Apply Filter -> Share 

On the long run, this brings a couple of advantages:

  • Better performance for older devices. I am confident that live camera + effect, would translate into low fps.
  • A single place for editing the picture. With this I have more space to show editing controls, and remove the ones used for taking the picture

Since Business side was ok with this change, we move forward with it.  For this kind of flow, FXBlurView proved to be more than enough.  Some facts about the development and the code:

  • One of the places where I lost  a lot of time (and wasn’t really expecting to), was trying to put a UIImagePickerController's root UIView as a subview of my UIViewController's root UIView and keep the Status Bar visible.
  • The total amount of line of codes is  around 650. The biggest class is 298 lines.
  • I am using two nibs, one for 4′ and another 3.5′, with Auto Layout. This approach revealed to be more practical to maintain.
  • The size of the project is 4.3mb.
  • I made one question on stackoverflow regarding the creation of the app,  which I answered myself.
  • Used three 3rd party libs: FXBlurView, UIImage+Orientation, UIColor+Hex. The last two, are classes I created but with other people’s code.


Having two persons, in this case me and Rui, wanting the same thing, really paid of. The fact of being able to ask him an asset, or an approach on something, and being able to receive feedback immediately proved to work (even while working remotely). Without this, it would be impossible to finish it in such a short period of time. I have to say this was a very fun experience and I will definitely repeat it. Finally, the application can be downloaded here.

Note: The source code is available here: If you like it, please Star it.


Tagged , , , , , , , , , ,

Architecting with Blocks part 2

(Note: This is part 2 of a series of posts about Architecting an application using blocks in objective-c. By no means I am an expert on using blocks, and also it’s not the intention of this series to teach you how to use blocks. You can check this for that. To finalise, I am sure there are better ways to use blocks while architecting an app: use this at your own risk. :))

This is the final post from a 2 parts series that I start a long ago. In this case I won’t show any snippet of code, I will give away an entire sample. My approach about this matter, change in the meantime, nonetheless hope you enjoy it. You can find it here .

Tagged , , , , , , ,

Item 3, Prefer Literal Syntax over the Equivalent Methods

Note: This post is part 3 of a series of posts I will do about the new book of Matt Galloway.

Prefer Literal Syntax over the Equivalent Methods

Literals have been around objective-c since a long time:

NSString *aString = @"Hello World";

With the latest versions of Clang, this sugar syntax has been extended to NSNumbers, NSArrays & NSDictionaries. Since we deal with this kind of objects every day, this new feature is well appreciated. In a nutshell this allow us to:

  • Reduce the boilerplate
  • Cleaner code
  • Faster typing

While using NSNumbers, you can use literals in the following way:

  • @15 => [NSNumber numberWithInt:15]
  • @15.6 =>[NSNumber numberWithFloat:15.6]
  • @15.123123 => [NSNumber numberWithDouble:15.123123]
  • @YES => [NSNumber numberWithBool:YES]

As you can see, in this case, the amount of extra code is reduced in more than 75%.

You can also use literals in collections with subscripting. With NSArray you can do the following:

  • @[@"One", @"Two"] => [NSArray arrayWithObjects:@"One",@"Two"];
  • By Array subscripting: myArray[1] => [myArray objectAtIndex:1];

And finally with a NSDictionary:

  • @{@"key1":@"object1", @"key2":@"object2"} => [NSDictionary dictionaryWithObjectsAndKeys:@"object1",@"key1",@"object2",@"key2" nil];
  • myDictionary[@"key1"] = @"newObject1"; => [dic setObject:@"newObject1" forKey:@"key1"];

And if you want a mutable object:

  • [@[@"1",@"2" ] mutableCopy];
  • [@{@"key1":@"object1"}mutableCopy];

Although with collections the end result seems the same, if an object is nil, it won’t. While using the common operations adding a nil wouldn’t crash anything, with literals it will:

  • [NSArray arrayWithObjects:@"object1",nil, @"object2", nil] => It’s “ok”.
  • @[@"object1",nil, @"object2"] => It will raise an exception.

In theory it would be better if the first option would crash, because it doesn’t make much sense to have a nil in the middle of an array and work with it in that state. Most of the time, you would prefer that would crash, so you could see immediately where the problem is.

Literals are an awesome addition in a very verbose language like objective-c. Knowing how to use them and their caveats is a must have for every programmer.


Tagged , , , , , , , , ,

Item 2, Minimize Importing Headers in Headers

Note: This post is part 2 of a series of posts I will do about the new book of Matt Galloway.

Minimize Importing Headers in Headers

The second item, unfortunately a short one, talks about importing classes: the where and the how. One should be careful when importing things he doesn’t need on the .h file. Most of the time, specifying @class (forward declaration) instead of an #import is  the best choice. Importing creates dependences between classes that should be avoided (when possible). So what does this @class actually means?

“The @class directive minimizes the amount of code seen by the compiler and linker, and is therefore the simplest way to give a forward declaration of a class name. Being simple, it avoids potential problems that may come with importing files that import still other files. For example, if one class declares a statically typed instance variable of another class, and their two interface files import each other, neither class may compile correctly.” – Abizern,

So in a nutshell (from Mr. PeyloW,

  • Only #import the super class, and adopted protocols, in header files.
  • #import all classes, and protocols, you send messages to in implementation.
  • Forward declarations for everything else.

And a quick example:

“The reasoning behind forward declarations in header files is that it avoids unnecessary dependencies. i.e. Imagine B.h forward declares A and B.m imports A.h. Then imagine C.m, D.m, E.m and F.m import B.h. After all this is done, A.h changes. Since A is only forward declared in B.h, only B.m needs to rebuild. Without forward declarations, C.m, D.m, E.m and F.m would all need to be rebuild if A changes” – Jacob Relkin,

Hope you enjoyed this quick reference to how to import in objective-c.

Tagged , , , , , , , ,

Item 1, Familiarize Yourself with Objective-C’s Roots

Note: This post is part 1 of a series of posts I will do about the new book of Matt Galloway.

Familiarize Yourself with Objective-C’s Roots

Dynamic language

In this item, the author starts by delving into how Objective-c send messages as opposed of function calling (in this case comparing to C++)  and when one should be used instead of the other (you can still use function calling in objective-c).  The dynamic nature of objective-c, binds the messaging to the corresponding piece of code that will be called, at runtime; as opposed to C++ (for example) that is done at compile time.

Memory Management

One should understand how related objective-c is to c (it’s a superset) and how/where the allocations are made:

NSString *aString = @"BlahBlah";

In this case “aString” is a pointer to a piece of memory allocated on the heap. Although this is mostly true for allocating objects in objective-c, blocks for example are allocated on the stack, but can be  passed to the heap (block_copy()).  An excellent post by Mike Ashe explains this as well.  Plus when you alloc, new, retain or copy an object, you are responsible for them.  It’s important as well to know how the memory is managed in objective-c:

 ” (..) that any single object can have multiple “owners”, and the system won’t allow the object to be destroyed until all owners have relinquished ownership.” – Mike Ashe,  Stack and Heap Objects in Objective-C

In one hand with manual memory management, you are responsible for cleaning the house, with ARC the cleanup is being made for you. Do remember, that ARC is not a Garbage collector, so you should need to understand when you have to do something (circular references for example) and when you don’t.

You will find plenty of variables that will be create on the stack, for example:

CGPoint point = CGPointMake(12.0f,10.0f);

CGPoint is a structure and it’s defined like this on CGGeometry.h from CoreGraphycs.framework:

struct CGPoint {

CGFloat x;

CGFloat y;

typedef struct CGPoint CGPoint;

It’s important to measure if you are going to use objects (vars that point to something that has being allocated on the heap) and, in this case, structures (vars that might be using stack space), or non-objects int,float, char, etc. Allocating objects  can incur on an unnecessary overhead, so chose the right tool for the job in hand.

The first item, is a very well written intro into how objective-c works internally versus other languages, and how you can take advantage of the C language . As it is build upon it, some time should be taken to understand it.

Tagged , , , , , , ,

Effective Objective-c 2.0, by Matt Galloway

Over the next weeks, I will be making a small comment about the new book of Mr. Matt Galloway. This comments will be about each chapter’s item, so we are talking about 52 small posts. I prefer to do so, instead of dissecting 7 chapters. So godspeed!

The goal here is not to, in no way, transcript the book, but to be a guide for me, to study and retain what the book is trying to transmit.

Tagged , , , , , ,


Created a few days ago a category that allows you to know what calls are you making (the url more precisely). This is extremely helpful because you don’t have to keep track of every place where you use NSURLConnection.

It will also output the stack trace, which can as well be very useful to understand from where the call is coming. You can find it here. Since it uses method swizzling, I don’t recommend the use of it on production (aka release).

Kiwi’s Basic Unit Testing

If you want to make just some basic tests, with Kiwi, in your UIViewController‘s IBOutlets and IBActions, you can do something like this:

 __block MyViewController *viewController = nil;
 beforeAll(^{ // Occurs once
 afterAll(^{ // Occurs once
   viewController = [[MyViewController alloc] initWithNibName:@"MyViewController" bundle:nil];
   // Lazy loading of the UIView's
   __unused UIView *aView = viewController.view;
   viewController = nil;
 it(@"should not be nil", ^{
   [viewController shouldNotBeNil];
 it(@"should have the IBOutlets not nilled", ^{                            
   // The description's Label IBOutlet
   UILabel *descriptionLabel = (UILabel *)[viewController objectForPropertyName:@"descriptionLabel"];
   [descriptionLabel shouldNotBeNil];

 it(@"should respond to the IBActions", ^{
   // This Button should have an action
   NSNumber *actionMethod = @([viewController respondsToSelector:@selector(anAction:)]);
   [[actionMethod should] beTrue];

Don’t forget that with this you are only able to see that the IBAction exist and the UIViewController responds to it… Not that the your Xib’s element is connect to it.

Tagged , ,

iOS Testing

I started a new project recently, and wanted to make sure that the Testing part would be covered, yes some of my projects have been lacking that. So in my demand to find a proper way of doing this, I found Kiwi. I already had used the default framework for testing in iOS (SenTestingKit), but I have to say that it doesn’t really feel right. The whole mindset in TDD, and the way you start to actually doing things that way is hard. Plus, implementing SenTestingKit on top of that, just starts to touch the boundaries of masochism. So, below you can find a list of resources I gathered last night, and that will serve as reference to you (and to me):

In the end I choose Kiwi, mainly because of the clarity you write the tests, and also for easily allowing the test of blocks.

Tagged , , , , , ,

Pointer to a Pointer

I came to a point (the irony…) where I needed the following:

// Declare the queue
dispatch_queue_t workingQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSError *parsingError = nil;

if (condition == YES)
    [self doSomethingLongWithError:&parsingError];
    [self doSomethingElseLongWithError:&parsingError];

dispatch_async(dispatch_get_main_queue(), ^{

// Check if we got an error

if (parsingError)

So what’s happening?

– I have one working thread doing some heavy stuff (in this case parsing)
– Once that work is done I want to update my UIViewController, by executing the block success() or the block error(parsingError).

The idea here is to be able to actually do something heavy, not expecting a return, and also be able to know if something went wrong.

As you might imagine the signature of the methods is:

- (void)doSomethingLongWithError:(NSError **)error;
- (void)doSomethingElseLongWithError:(NSError **)error;

If you notice, I am passing an &parsingError in both methods. Why? Well that’s where it becomes interesting the use of pointers to pointers. The powerful aspect of it is that I am able to declare the parsingError on the scope of the working thread, pass it’s pointer to a different scope (in this case of the methods) and once that working thread is done I can rely on the value of the parsingError on the main thread to take the appropriate action.

Tagged , , , , , , ,