Chris Eidhof

Deckset

Fri, 27 Dec 2013 21:54:37 +0100

One of the things I love is Markdown. Recently, I’ve also been giving a lot more presentations. Working in Keynote can be really nice, and is very powerful. But most of the time, I don’t need that power.

Therefore, Florian, me and our awesome friends at A Color Bright have spent the last months building an app that changes the way you write your presentations. You write a markdown file, separate your slides with dashes, and you get a beautiful presentation out of it. Update your markdown file, and your presentation updates automatically.

Over the last weeks, we’ve given multiple presentations with the app, and it’s awesome. For me, it’s great that I can just write. Rearranging text is so much easier than rearranging slides. The default themes we have are beautiful by default, and it’s really hard to mess it up. Changing to a different theme is immediate: you can do this minutes before the presentation, if you feel like it.

We are not building a replacement for Keynote or Powerpoint, but a different way of creating presentations. In some use cases, traditional tools are the way to go. But for many of the presentations, we think Deckset is much easier.

Currently, we’re putting the finishing touches on our app, and are getting it ready for private beta. We are planning to launch early 2014. If this sounds interesting to you, go ahead and sign up for the mailing list at decksetapp.com, and we’ll keep you posted.

Have a great start of the year!

2013

Sat, 07 Dec 2013 17:47:19 +0100

It’s the time of the year to write a recap about the things I’ve done this year. 2013 has been a really awesome year, maybe my best year so far. I learned tons, worked with really awesome people, made many new friends and travelled a lot.

Client work

This year, I worked for three big clients (and some smaller ones). The smallest of three was an old employer who wanted a prototype of a new idea (in Ruby on Rails). This prototype evolved into a bigger website, and things got a bit more serious. Because I am not a real Rails developer, and because there was a base level of trust missing, I decided to not continue working on this project. I had written behavior tests using Cucumber for the entire project: this was awesome once I decided to transfer it, because the other developer was able to quickly take it over.

My other two big clients were Aprendo and Zeta. For Aprendo, we built an in-house app for development of elite athletes. I worked together with Florian on this, and our collaboration was so nice we decided to make more things together (more on that later). For Zeta, I can’t yet tell what I built, but keep an eye on them. It’ll be awesome.

I really liked having few bigger clients (rather than a more smaller clients). I’m currently still wide open in 2014 for client projects, if you have a bigger project that needs a serious developer (or a team): get in touch.

Conferences and Events

This year was the year of the conferences for me. Almost exactly one year ago, I realized that there’s no English iOS conference in Berlin, and with all the awesome talent in the city we definitely needed one. So I teamed up with Peter, Matt and Max, and we decided to organize UIKonf. This was a lot of hard work, a lot of things learned, and went way better than expected. One of my first lessons in how working in a team can make you achieve that much more. In fact, it was so awesome we decided to do it again, tickets for 2014 are now on sale.

Because the awesome NSHipster was in town, we decided to put on an event together with Mattt, and put on an NSHipster night, which turned out to be a great succes.

Also, after UIKonf, Stijn Oomes approached me with the idea of doing a 3D programming workshop. This went well, we even had two days of workshops. We went over the basics of 3D programming, and took different approaches in getting 3D scenes on the screen, from high-level with SceneKit to low-level-everything-in-OpenGL.

Finally, a while ago Apple announced Tech Talks in Berlin. After learning that I didn’t get a ticket, I decided to put my frustration to good use and started organizing Alt Tech Talks, a free event for everyone who did or did not get a ticket. On Wednesday night I asked on Twitter, on Thursday I had the first 4 speakers confirmed and on Friday I rented a movie theater. The rest isn’t history yet, because they’ll happen in a few days from now.

Talks

Because of starting objc.io (more about this later), Florian, Daniel and me gained a bit of visibility in the iOS and Mac community. And that lead to conferences asking us if we’d be interested in speaking. I like speaking, so off we went.

First, there was NSSpain, which was an English-speaking conference in Logroño. We were quite impressed: it was well organized, great weather, and lots of nice food and wine. I spoke about Lighter View Controllers.

Then, the talk I was most afraid of this year: an hour-long presentation in German (!) at Macoun. Fortunately, my German is finally at a level where people don’t have problems understanding me, and with enough preparation, I think my talk came across well. The subject (Schlanke View Controller) was the the same as in Spain, and it seems to be very relevant for all iOS developers.

About a month later, I spoke at pragma mark, an iOS/OS X conference in Milan, Italy. Here, I spoke about async programming, which went okay. It is quite a hard topic to talk about, but luckily, writing the article for objc.io forced me to dive deep into the topic, and giving me plenty of raw material for the talk.

The hardest talk format this year was at Ignite Berlin; every presentation is 20 slides, and every slide auto-advances every 15 seconds. I prepared this the other way around: normally, I write an outline for a talk, expand that a couple of times and finally make slides. This time, however, I recorded myself telling the story I wanted to tell, and made some slides that loosely reinforced what I wanted to tell.

I also talked at CocoaHeads Dresden and twice at the Berlin Compiler Meetup.

Other

In the beginning of the year, I joined KANT, a studio full of great people. I spent a couple of months working there, but after being on-site with my client a lot, and having other commitments that didn’t allow me to be there a lot, I decided to cancel my desk there. Being among them, I learned to appreciate coffee even more.

I started lots of small new projects, some succesful, most failed. I often spend a day or two building something (sometimes more). It’s a lot of fun, and in doing so I learned a lot. I hope that I can use some of those ideas in future projects.

Continuing from last year, we try to meet regularly for our German course. With my fellow Dutchies Alper and IKSI we take lessons from @fraulea. I will probably spend the next 10 years improving my German while never getting close to being near-native. But that’s okay, it’s a lot of fun and a beautiful language to discover. For the German speakers that read this: if you ever hear me make mistakes, please correct me.

After having spent most of the year freelancing, I’ve been working on a product together with Florian and A Color Bright. We’re not quite ready to tell you what it is, but are getting close to release a private beta towards the end of this year. And hopefully can submit to the store early January. It’s going to be a native Mac app (our first) and it’s going to be very beautiful. Building your own products is lots of fun, I hope to do a lot more of that in 2014.

objc.io

The last work-related topic: objc.io. On the morning after UIKonf, on the hackday, I sat outside in the sun, together with Florian, Daniel and Peter. Instead of hacking, we were talking and drinking coffee, and I felt a bit guilty about that. Florian, Daniel and me decided that we should write a blog with the three of us. A few days later, I tried to convince them that we should instead make a magazine: one topic each month, and in-depth articles. We asked IKSI to make a beautiful design, and asked Natalye to do the copy-editing. We started writing and tried to put a lot of effort into the first issue. Ricki wrote an article too, as our first guest-writer. After a few weeks, Florian and me sat outside on my balcony, and pressed publish. We posted the link on Twitter, waited a bit, and saw a huge stream of compliments coming in.

Each month, each of us spends a few days researching and writing my article, as well as coordinating the other things. It’s a lot of work, especially because we really have to investigate each topic very deeply, as we don’t want to spread the wrong ideas. But it’s oh so rewarding. The writing and researching in itself make me a lot more knowledgeable. Before writing, I sometimes don’t know too much about a topic, and having the article and its deadline force me to learn. It’s just great. And of course, getting all the positive reactions from our readers is very flattering.

Leisure

This year, I visited Spain three times: once for running, once for a conference and the third time to spend some time by myself (I’m writing this article from Seville). I learned how to do exercises at the gym, which was so much fun: I never expected that lifting heavy stuff could be fun, but it’s great. I ran a new PB on the 10K: 37:03. I ran my first marathon: the Oslo Forest Marathon. It was way too hilly for me to run fast, and while the first 27K went great, the last 15 were very hard. I visited friends and family in The Netherlands, but not as much as I wanted. I ran up the Brocken a couple of times. Together with Frank, I walked Hadrian’s wall, and spend the week after that running up mountains in the Lake District. I went sailing and camping in Sweden.

One of my disappointments was not being able to run the Berlin Marathon. I trained for months, aiming to run a fast first road-marathon. However, during the last week of tapering, I got quite sick, and had to stay in bed for a few days. I might have caught a bug, or maybe I trained too hard. It took me a while to recover, and I still haven’t gotten back to running 5 times a week.

Recap

It was awesome. I had a blast. I did work too much, and want to change that next year.

Lightweight Key-Value Observing

Thu, 10 Oct 2013 00:12:14 +0200

In this article, I’d like to implement a simple class I use for key-value observing. I think KVO is great, however, for most of what I do, there are two problems:

I don’t like the dispatching in observeValueForKeyPath:ofObject:change:context:. I think it gets messy and confusing if you observe more than one object.
You have to balance each add observer with a remove observer, it would be nice if this can be done automatically.

So, off we go. The trick we will use is one I first saw in THObserversAndBinders, and this post is basically a description of what they did, but in the most minimalistic way.

First, we’ll define the interface for our object:

@interface Observer : NSObject
+ (instancetype)observerWithObject:(id)object
                           keyPath:(NSString*)keyPath
                            target:(id)target
                          selector:(SEL)selector;
@end

The observer takes four parameters, which are hopefully self-explanatory. I chose to use the target/action pattern: an alternative would have been blocks, but then you would have to do the weakSelf/strongSelf dance, and it’s often nice to have a separate method anyway.

What we will do is set up the KVO inside the initializer, and remove it in the dealloc method. What this means is that as long as the Observer object is retained, we will have an observer. The way I typically use this, for example, in a view controller:

self.usernameObserver = [Observer observerWithObject:self.user
                                             keyPath:@"name"
                                              target:self
                                            selector:@selector(usernameChanged)];

By putting it in a property, we are making sure it gets retained. As soon as our view controller deallocates, it’ll set the property to nil and the observer will stop observing.

In the implementation, it’s important that we keep a weak reference to both the observed object and the target. If one of the two gets nil, we want to stop sending messages:

@interface Observer ()
@property (nonatomic, weak) id target;
@property (nonatomic) SEL selector;
@property (nonatomic, weak) id observedObject;
@property (nonatomic, copy) NSString* keyPath;
@end

The initializer sets up the KVO notifications. It uses self as the context. This is necessary if we would ever have a subclass that adds a similar observer:

- (id)initWithObject:(id)object keyPath:(NSString*)keyPath target:(id)target selector:(SEL)selector
{
  if (self) {
    self.target = target;
    self.selector = selector;
    self.observedObject = object;
    self.keyPath = keyPath;
    [object addObserver:self forKeyPath:keyPath options:0 context:self];
  }
  return self;
}

When a change happens, we just notify our target, if it still exists:

- (void)observeValueForKeyPath:(NSString*)keyPath ofObject:(id)object change:(NSDictionary*)change context:(void*)context
{
  if (context == self) {
    id strongTarget = self.target;
    if ([strongTarget respondsToSelector:self.selector]) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
      [strongTarget performSelector:self.selector];
#pragma clang diagnostic pop
    }
  }
}

And finally, in the dealloc we remove the observer:

- (void)dealloc
{
    id strongObservedObject = self.observedObject;
    if (strongObservedObject) {
        [strongObservedObject removeObserver:self forKeyPath:self.keyPath];
    }
}

That’s all there is to it. There are a lot of ways this could be extended: add blocks support, or my favorite trick: another convenience constructor that call the action directly the first time. However, I wanted to show the core of the technique, adjust it to your needs.

By using this technique you don’t have to remember too much when doing KVO. Just retain the observers, and set them to nil when you’re done. The rest will happen automatically.

Status Update

Mon, 10 Jun 2013 10:51:21 +0200

Lots of stuff happened over the last months, so here’s a partial list:

I finished my project with Aprendo. We’ve been working on an in-house iPad app for almost a year. At this point, I can’t demo anything publicly, but I’d be happy to talk about it in private.
I organized UIKonf together with Peter and Matt. I think it’s safe to say that the conference was a resounding success. We learned a lot of things that we can do better next year, but all in all, we’re very happy.
I started objc.io, a new online periodical about best practices and techniques in Objective-C. The response so far has been very good, and matches the amount of work we’ve put in.
I started work on a small app to track your food intake, based on the Diet Quality Score system.
I started planning to build independent apps together with Florian.
The running is going well, too, I improved my PB on the 10K in bad circumstances to 37:03, and will run my first marathon this weekend (although I have a slight injury, so depending on how that feels I might pull out at the last minute).

Depending on the contracting work I might have more time to blog. I have a lot of topics in my head, some might appear here and some on objc.io.

DONE

Mon, 25 Feb 2013 21:01:45 +0100

In case you haven’t noticed yet, I’m organizing an English-speaking iOS Conference in Berlin called UIKonf, together with my fellow organizers Matt and Peter. If you are in or around Berlin on May 2nd, get on the mailing list and come join us!

Organizing this conference is really awesome. It started with a question: why doesn’t this conference exist? Then I realized that the only way to make it happen is do it yourself. Starting something like this feels really empowering: we can definitely have an impact on our direct environment by just doing stuff. I asked some people that are more awesome and experienced than myself, then we executed.

While UIKonf is still a few months away, I am getting better at shipping, and I can recommend you to do the same. Instead of reading this, write an article. Package up some software or libraries you have lying around. Organize a meetup. You’ll see that it’ll make you happy!

A good recommendation from my friend Alper is the Cult of Done manifesto. Take a minute or two to read it, and then get back at building stuff and shipping things!

How to keep your classes small and clean

Sun, 24 Feb 2013 22:40:00 +0100

I’m a little obsessed with trying to write maintainable, clean code. I’m not yet really good at it, but try to become better every day. It started to become more of an obsession than usual when I realized that a lot of the projects I work on will someday be taken over by other people, and I don’t want to be embarassed.

This explains my recent interest in testing (some interesting blogs on that).

Although I’m not yet very good at testing everything, I have two other heuristics that I use to keep my code maintainable: I try to keep my .m files under a hundred lines (this is hard), and try to keep the number of imports small.

Here are two scripts that I use to achieve this. The first one shows the .m files in your project with their line counts, and sorts them by line count. The bottom of the list (largest files) are top candidates for refactoring:

find . -path './Pods' -prune -o -name "*.m" -exec wc -l "{}" \; | sort -n

The other script I wrote generates a .dot file from your imports, and you can open it with an app like GraphViz to get a quick overview of how your imports are. (I tried to keep it under 140 characters so it’s tweetable).

echo "digraph G {";grep "import \"" **/*.m|sed "s/.m:#import \"/ /;s/.*\///;s/+/_/g;s/.h\"//"|awk "{print \$2,\"-> \"\$1\";\"}";echo "}"

Put the above line in a file or in a shell alias, run it and pipe the output to a file that you can open with GraphViz. I’m pretty sure this can be done even more effectively using just awk, but I’m not an expert yet. Bonus points for the shortest solution!

New Things

Thu, 31 Jan 2013 17:11:45 +0100

Over Christmas, I read Antifragile by Taleb. The book has had quite an impact on me, and I decided to change some things. Long story short: I want to be open to positive black swans. A positive black swan is an event that will happen with a low probability, but if it does happen, it has a big impact.

Taleb’s strategy for investing is to invest mostly in very safe things, and make small bets with a limited downside, but an unlimited upside. He calls this the dumbbell strategy. Applied to my own business as a freelance software developer, this means that I will be continuing and expanding my freelancing business for most of the time. But I am also spending time on projects that have a limited cost, but an unlimited upside. I’m not expecting that most of these projects will be a wild success, but you only have to win big once…

One of these projects is organizing a conference. This will definitely not have an unlimited financial upside (best case, we might make a little bit of money, but it would be way more effective to spend that time freelancing). However, I do think that very nice things will happen because of this: meet more people, get known a bit better in the tech scene, and work together with really interesting people.

Also, I have a renewed focus on building and maintaining my own apps. I’m working on an update for TrackMe (I know it needs a better website and UI). I have some other interesting ideas for new apps too, hopefully I can move some of these projects forward so they can be released publicly.

On a personal level, I am planning to go to more parties. This is directly copied from Taleb. At parties, you have a chance of meeting very interesting people. Probably at most parties you’ll have a good time, but won’t meet anybody new who’s interesting. However, when you do, all the other parties will have been worth it.

Also, I want to work together with more people. One of the ways this will happen is having an office instead of working from home. Another way will be by hiring more people. If you’re interested in learning iOS Development, or if you’re a copywriter, get in touch.

I wonder how this strategy will work. I see it as something long-term, the payoff might only come in a decade. Let’s see.

Lighter UIViewControllers

Mon, 17 Dec 2012 11:45:47 +0100

Recently, I’ve been a bit obsessed with writing simpler code. It happened because I passed on some projects to other programmers. I would like to feel minimally embarrassed when doing so.

In the projects I’ve taken over from other people, one of the most common problems is that view controller code is big and complicated. In this article, we’ll look at some ways to make the view controller smaller and thus simpler. In a project I’m working on currently, we have about 150 classes, and almost none of them is larger than 100 lines. The ones that are larger than that are on the top of my refactoring list.

Separate out UITableViewDataSource and UITableViewDelegate

One of the first things I often do is create a separate class for the tableView’s data source and delegate. Just create a new class, take all the methods that start with tableView: and put them in there. The compiler will then show you which things are missing in that class (e.g. instance variables), and you pass them on. Then you can remove them from the view controller.

Don’t do domain logic

Most of my apps are backed by a Core Data stack (but this is true for any kind of data store). I Try to do as little domain logic as possible. For Core Data, my favorite trick is to add a category to the generated models where I put my logic. For example, instead of doing this in your view controller:

- (Department*)getRootDepartment:(Department*)department {
  if(department.parent == nil) return department;
  return [self getRootDepartment:department.parent];
}

Do this in Department+Extensions.m:

- (Department*)rootDepartment {
  if(self.parent == nil) return self;
  return [self rootDepartment];
}

Even for small methods like this, it helps a lot to keep your view controllers small. You also have the added benefit that it’s much easier to reuse this code.

Don’t do webservice logic

Don’t call and parse a webservice request in your view controller.

I always create a separate set of classes that do the dealing with webservices. It depends how complicated your webservice / persistency is, but I mostly have a class called Webservice that gives you high-level methods to call the webservice. Either the methods accept callbacks or I use KVO (more about that later). It uses the “fire and forget” approach: you tell the webservice that you want something and then forget, assume it will get back to you at some point.

The webservice class calls the API and turns the API results into domain objects. This functionality is often achieved by multiple classes that are used by the webservice, but that’s a topic for a later post.

Don’t create complicated view hierarchies

Don’t set up complicated view hierarchies in your view controller. Personally, I’m a big fan of designing my views in a nib/xib/storyboard. But even if you don’t, I think it’s better to compose several views into a new view. For example, if you want a date slider, it’s better to create the view hierarchy for that (the labels at the axes, a label representing the current date and the UISlider) in a separate class.

Create child view controllers

Since iOS 5, it’s very easy to create child view controllers. Use this functionality. It makes your life easier. This is mostly useful for iPad apps, but might be useful for iPhone apps as well. A classical example of this is the split view, but in any screen where you have components that are almost independent it might be useful.

Use KVO

Key value observing can make your life a lot easier. It’s also a bit tricky sometimes, so you do need to spend some time to learn it, and you will probably make some mistakes (I still get tripped up every now and then).

One example where KVO really shines is the NSFetchedResultsController. It listens to changes in core data objects and can be used to implement a UITableViewDataSource or UICollectionViewDataSource.

For example, suppose you have a list of Departments. Then you want to refresh that list from the API. In your view controller, you fire a off a request like [webservice reloadDepartments] and then forget. Once the webservice updates the Core Data managed objects, magic happens: Because you implemented your UITableViewDataSource using an NSFetchedResultsController, it gets refreshed automatically.

KVO by itself can be a bit hairy sometimes, and there are small libraries like THObserversAndBinders that make things easier.

Other ideas?

This is just a list of things that I could come up with and common refactorings I use. I’m sure there are a lot of things I forgot, let me know your tips and I’ll add them to the article.

Implementing Value Objects in Objective C

Sun, 16 Dec 2012 16:22:00 +0100

Value Objects are objects that hold simple data. This article is about creating such value objects. I use them a lot in my code, because they are robust and keep the code simple. Note that it’s not about NSValue, but about simple objects with simple data.

Implementing value objects should be easy, but there are some slightly tricky bits. So let’s look at the requirements:

We want to create value objects quickly (i.e. an initWith:)
The created objects should be immutable
The created objects should be equal when they have equal values

Suppose we want to create Person objects with properties name and birthDate, then our interface looks like this:

@interface Person : NSObject
- (id)initWithName:(NSString*)name birthDate:(NSDate*)birthDate;
@property (nonatomic, copy, readonly) NSString* name;
@property (nonatomic, strong, readonly) NSDate* birthDate;
@end

The important thing to notice here is that the properties are readonly. However, the modern runtime still generates instance variables for us, that are prefixed by a _. Our implementation looks like this:

@implementation Person

- (id)initWithName:(NSString*)name birthDate:(NSDate*)birthDate {
  self = [super init];
  if(self) {
    _name = [name copy];
    _birthDate = birthDate;
  }
  return self;
}
@end

In the modern runtime, you don’t have to use synthesize. If you do, then your instance variables get different names (without the underscore).

Now for the equality, we implement the method isEqual:. There is an excellent article by Mike Ash, however, there is a mistake in there. Following his advice, our first (incorrect) implementation looks like this:

- (BOOL)isEqual:(id)obj {
  if(![obj isKindOfClass:[Person class]]) return NO;

  Person* other = (Person*)obj;
  BOOL nameIsEqual = [_name isEqual:other->_name];
  BOOL dateIsEqual = [_date isEqual:other->_date];
  return nameIsEqual && dateIsEqual;
}

There is a problem here: if one of the two properties is nil, then isEqual: will return NO. This is because methods sent to nil always return NO, 0 or nil. Even [nil isEqual:nil] returns NO.

Therefore, our second, correct implementation looks like this:

- (BOOL)isEqual:(id)obj {
  if(![obj isKindOfClass:[Person class]]) return NO;

  Person* other = (Person*)obj;
  BOOL nameIsEqual = _name == _other->_name || [_name isEqual:other->_name];
  BOOL dateIsEqual = _date == _other->_date || [_date isEqual:other->_date];
  return nameIsEqual && dateIsEqual;
}

To implement the hashing function, I would like to recommend following Mike’s advice.

Bonus

Finally, as a bonus, let’s also implement NSCoding, so we can serialize our objects. First change the interface of Person to this:

@interface Person : NSObject <NSCoding>

The implementation is now very simple:

- (id)initWithCoder:(NSCoder*)aDecoder {
  self = [super init];
  if(self) {
    _name = [aDecoder decodeObjectForKey:kName]; 
    _date = [aDecoder decodeObjectForKey:kDate]; 
  }
  return self;
}

- (void)encodeWithCoder:(NSCoder*)aCoder {
  [aCoder encodeObject:_name forKey:kName];
  [aCoder encodeObject:_date forKey:kDate];
}

The two constants kName and kDate are declared in the implementation file, above the @implementation directive:

static NSString* const kName = @"name";
static NSString* const kDate = @"date";

Voila, now we can create objects, read their properties, serialize them to disk and read them back in. Some catches: when you add a new property, you have to make sure to update the code in lots of places:

Add the property to the interface file
Add the parameter to initWith:, and also update the callers of that method
Add a comparison to isEqual:
Update the hash function
Add the method to both initWithCoder: and encodeWithCoder:

It helps to have some tests in place that check this for you.

The full code of the examples (without the hash function) is on github.

Update: changed the name attribute to be copy instead of strong, thanks to Christian Kienle

How to add a new Unit Test target and OCMock to an existing XCode project

Mon, 03 Dec 2012 21:09:00 +0100

I had some trouble today trying to add Unit Tests to an existing project that uses CocoaPods. So I decided to do a quick writeup of how I got it working:

Create a new project called ‘BetterTodoList’
Create a new Podfile with the following contents

platform :ios, 6.0
pod 'AFNetworking'

Close BetterTodoList in XCode, and open the workspace (as instructed by CocoaPods)
Run, and see that everything still works
Write some legacy code
Realize you need Unit Tests:
- File -> New -> Target
- Choose Other -> Cocoa Touch Unit Test Bundle
- Name it “BetterTodoListTests”
Press Cmd+U. If nothing happens, check if Product > Test is grayed out in the menu. In that case, press Cmd+<, select Test and add the test using the + button.
Add the following lines to your Podfile, and re-run “pod install”

target 'BetterTodoListTests', :exclusive => true do
    pod 'OCMock' 
  end

Import OCMock.h in one of your files and see that it’s working.
?
Profit

Addendum: If you still have problems because the test target cannot access the compiled objects (e.g. “Symbol Not Found” errors), select the project in the organizer, then select the Test target, go to “Bundle Loader” and add the following values for both Debug and Release: $(BUILT_PRODUCTS_DIR)/BetterTodoList.app/BetterTodoList

My presentation at the Berlin HUG

Fri, 02 Nov 2012 11:28:06 +0100

Last week I gave a short presentation about lenses and fclabels at the Berlin Haskell Users Group. The source for the slides and some accompanying literate Haskell files are now in a github repo.

Adding push notifications to an app

Thu, 01 Nov 2012 16:20:26 +0100

Last week, I’ve built an app that’s quite simple: there are categories, and in the categories are messages. People can subscribe to a category and get a push notification when there’s a new message in the category, or when a significant change was made to the message. The badge icon should update appropriately, showing the number of unread messages. There are lots of tricky things when implementing this, and the point of this article is to explore them.

In a naive approach, you can start by implement the application delegate’s application:didReceiveRemoteNotification. This method is called when you receive a push notification. However, it is only called when your application is running. When your application is not running, this method doesn’t get called. You also need to implement application:didFinishLaunchingWithOptions:, and check if there is a push notification in the options (this dictionary gets set when you open the app by clicking on the notification).

The problem, however, is that not all push notifications arrive. For example, if you get 5 push notifications, but open the app via the home screen, you will not get any notification in the options dictionary, and you won’t get a didReceiveRemoteNotification either.

To do push notifications correctly, you will need to keep a list on the server, and on application startup your app needs to synchronise with the server. That way, you can mark the right and also tell the server that you have seen the push notification.

Now, when you exit the app you can set the badge count based on the number of unread push notification. However, the server needs to know this number as well, so that it can correctly set the badge number in the next push notification that is sent. When you read a message that was marked by the push notification, you need to tell the server as well. (Edge-case: when you read the message in offline mode, you will need to tell the server once you’re back online).

In order to do push notifications right, the client and server need to communicate a lot. Hopefully, in your next project, you can read this article so you don’t have to find these things out while you are programming.

In a next article, I will sketch the application architecture I used for the app above.

More Interface Builder

Sun, 23 Sep 2012 21:07:00 +0200

When I started iPhone programming, I built most of my interfaces in code. It was much easier: full control over your interface. Sometimes I would start in Interface Builder, but once I stumbled upon limitations I would rewrite the whole thing in code.

After learning some more things about Interface Builder, I started using it more and more. These days, I try to do almost every UI in Interface Builder. Apple has made it a lot easier for us, too: designing your table view cells in Interface Builder was quite easy already, but is even easier with Storyboards.

Here’s one example where I used to revert to code, but now use nibs. One of the projects I worked on required a horizontally paging scrollview. Each page was for answering a question, and contained a description and a slider. If you want to play with the example, please download the project from github. Let’s see how to do this using mostly IB:

Start by creating a view controller and adding a scroll view to it. Create an outlet scrollView on the view controller. Then, create a new empty XIB. We add a single UIView to the XIB with nested subviews (the text label and the slider). Then, in the view controller, add a method to setup the pages and call it from viewDidLoad. Note that the method is a bit long, normally you would probably factor it into components:

- (void)setupPages {
    pages = [NSMutableArray arrayWithCapacity:NUM_PAGES];

    CGFloat pageWidth = self.scrollView.bounds.size.width;
    CGRect pageFrame = self.scrollView.bounds;

    self.scrollView.contentSize = CGSizeMake(pageWidth*NUM_PAGES, self.scrollView.bounds.size.height);

    for(int i = 0; i < NUM_PAGES; i++) {
        NSArray* topLevelObjects = [[NSBundle mainBundle] loadNibNamed:pageNibName owner:nil options:nil];
        UIView* pageView = [topLevelObjects lastObject];
        pageFrame.origin.x = pageWidth * i;
        pageView.frame = pageFrame;
        [self.scrollView addSubview:pageView];
        [pages addObject:pageView];
    }
}

For this code to work, it’s important that there is only one view at the top-level of the xib. The above code creates the pages and adds them to the subviews. However, the separate pages don’t have a way to access the label and slider. A crude way to do this is give both of them a tag, and use something like [pageView viewWithTag:LABEL_TAG]. Indeed, for small views this can work, but it gets messy and hard to maintain quickly.

A better way is to add a new subclass of UIView, named CEPageView and change the root-element of PageView.xib to that UIView subclass in the Identity Inspector. If you open the Assistant Editor, you can create outlets on that newly created class and connect them to the XIB. Note that normally, you would drag from a view to the File’s Owner, now you drag to the root element in the Top Level Objects. Change the body of the for-loop to this:

    NSArray* topLevelObjects = [[NSBundle mainBundle] loadNibNamed:pageNibName owner:nil options:nil];
    CEPageView* pageView = [topLevelObjects lastObject]; // change
    pageFrame.origin.x = pageWidth * i;
    pageView.frame = pageFrame;
    [self.scrollView addSubview:pageView];
    [pages addObject:pageView];
    // Add these lines:
    pageView.title.text = [NSString stringWithFormat:@"Page %d", i+1];
    pageView.slider.value = i / 3.0;

You can also override the layoutSubviews of the UIView if you want some programmatic control over the layout.

I hope that this technique will make you more productive. I’m no expert on Interface Builder, so if you have any tips let me know!

Update: Ole Begemann recommends using UINib instead of loadNibNamed:owner, it should be faster when loading a nib multiple times. I haven’t tested it yet, but will check it out. See also: NSBundle vs. UINib performance

Traveling alone

Thu, 26 Jul 2012 09:30:47 +0200

I like traveling alone. Here are some things I found out when traveling alone:

Eating alone in restaurants is fine. I used to really dislike it, because I felt stared at. It got on my nerves. Once I went for mexican food in a Denver restaurant on the tech campus, and on Saturday night the restaurant was filled with families. I was seated in the middle of the room, and had a really big table just for me. This was quite uncomfortable, but I’ve gotten used to it now, and it’s very refreshing. As a personal rule, I try not to use my phone when having dinner (either with friends or alone). If I do want to do something while waiting for my meal, I’ll read a book or write in a notebook.

The freedom of traveling alone is great. Especially when you’re backpacking: once you hit the road you can go wherever you want to go. Many songs have been sung about this feeling, and many books have been written. If you’ve never experienced it: do it!

For some reason, I used to feel the pressure to socialize. However, it’s fine not to do that. Most of the time, I like to meet people and talk to them. However, I also like spending a day sipping café con leche and eating tapas without really talking to somebody. It clears my mind.

The way you travel and the places you stay can also have an important effect on socializing: I prefer to use public transport. In a rental car, you can be pretty sure to not meet anybody. Likewise, in a hostel it’s much easier to meet new people than in a hotel. And joining organized activities is a sure way to meet new people: even if you’re really picky, if you meet enough people you’re bound to meet somebody you really like. I made some great friends over the years by joining walking tours or pub crawls.

There is the obligatory quote: “happiness is only real when shared”, which is very true. Traveling with friends is just as awesome. However, you’ll meet people along the way with who you will share the moments. For me, it’s easier to meet people when I’m traveling alone than when I’m traveling with friends: with friends, I tend to isolate a bit more, and don’t make many new friends.

Safe travels!

Finding My Most Influential Twitter Followers

Tue, 29 May 2012 12:03:00 +0200

I spent an afternoon trying to find out who of my Twitter followers is the most influential. I wrote the script to fetch the data in Ruby, and stored the data in MongoDB.

Setup

First, we’ll need to set up some things. Make sure you have a recent version of Ruby installed, and install the following gems:

gem install twitter mongo bson_ext

Although the bson_ext isn’t really necessary, it will make things a bit faster.

Also install mongodb. One of the easier ways to do this is using homebrew:

brew install mongodb

Make sure to fire up mongodb, and we’re all set on the client.

The last step is to get an API key at Twitter. Go to https://dev.twitter.com/ and create a new application. Don’t worry about the details too much.

Fetching a list of Twitter follower IDs

First, we will write a file called twitter-config.rb:

Twitter.configure do |config|
  config.consumer_key = 'CONSUMER_KEY'
  config.consumer_secret = 'CONSUMER_SECRET'
  config.oauth_token = 'OAUTH_TOKEN'
  config.oauth_token_secret = 'O_AUTH_TOKEN_SECRET'
end

Make sure to replace the right-hand sides by the appropriate values (they should match the twitter application you just created).

The script for fetching your Twitter follower ids is now extremely simple:

require 'rubygems'
require 'twitter'
require 'twitter-config.rb'

follower_ids = Twitter.follower_ids
File.open("followers", 'w') { |f| 
  f.write(follower_ids.collection.join("\n")) 
}

We are just using the Twitter API to fetch the follower ids and store them in a file. The last part is essential when working with APIs and larger datasets: make sure you store intermediate results. Often, computations can take a long time, and by storing intermediate results you can resume where you’ve left off.

Write the script to fetch the data

Again, this script is very simple. We iterate over the list of followers, and make the corresponding Twitter API call. One thing to note here is that you will hit the rate limit if you have more than 350 followers. Therefore, the script checks if you already have fetched the data for a follower, and skips fetching the data. If you hit the rate limit, simply wait some minutes and run the script again. Eventually, it will finish.

require 'rubygems'
require 'twitter'
require 'database-config.rb'
require 'twitter-config.rb'

File.open("followers").each_line {|follower_id_s| 
  follower_id = follower_id_s.to_i

  if COLL.find("id" => follower_id).count > 0 then
    puts "Already have data for #{follower_id}"
  else
    puts "Fetching data for #{follower_id}"
    follower_hash = Twitter.user(follower_id).attrs
    COLL.insert follower_hash
  end
}

The database-config.rb file looks like this:

require 'mongo'

connection = Mongo::Connection.new
db = Mongo::Connection.new.db("twitterinsight")
COLL = db.collection("followers")

It sets up a global variable COLL that you can use in the scripts for analyzing and populating the database.

Analyze the data

Once you have filled your database with data, you can analyze it by running queries on it. The reason I wrote this code is because I wanted to know who my most influential followers were:

require 'rubygems'
require 'database-config.rb'

COLL.find().
  sort(['followers_count', :desc]).
  limit(50).
  to_a.map { |x| 
  ratio = (100 * (x['friends_count'].to_f / 
                x['followers_count'].to_f)).to_i
  statuses = x['statuses_count']
  puts "#{x['screen_name']} - " +
       "#{x['followers_count']} / #{x['friends_count']}" +
       ", #{ratio} [#{statuses}] @ #{x['location']}" 
}

As you can see, this script prints the screen name, number of followers, number of friends, the friends/followers ratio, the amount they tweet and the location. Here’s some example output:

copumpkin - 22397 / 368, 1 [3597] @ Boston, MA
DotSauce - 15641 / 12400, 79 [7377] @ NC, USA
dominiek - 14487 / 1085, 7 [5342] @ AMS, SFO, TYO
TivoliUtrecht - 10935 / 442, 4 [3950] @ Utrecht, The Netherlands
theSeanCook - 10006 / 1137, 11 [2345] @ San Francisco
Duetschpire - 8194 / 584, 7 [2112] @ Australia
Polledemaagt - 7518 / 2563, 34 [37721] @ Gent, London, Amsterdam
NetBlueWeb - 6651 / 5520, 82 [9] @ British Columbia
andreisavu - 6648 / 6497, 97 [11496] @ Bucharest, Romania
StackMob - 5571 / 1835, 32 [1015] @ SF

The major takeaway for this post is to cache all intermediate data. First make sure you have all the data you wanted to analyze in one place on your computer (or your cluster). Optionally massage it into a format you want, and then run the analysis without hitting external servers all the time.

Changing Tech Education

Wed, 16 May 2012 10:28:42 +0200

Sometimes I talk to my friends about why I want to become rich. It’s to solve the money problem, and once it’s solved, I hope to have the time, connections and status to work on bigger problems. I already know exactly what I want to try once I’m there: change tech education.

When I did my bachelor’s degree in computer science, I was quite bored most of the time. Officially, you were supposed to work on it at least 40 hours per week, but for me and most of my friends it was closer to 10 hours. The other time we would spend working, or having a hangover.

One of the causes why I didn’t have to work so hard at university is the different levels of experience. When I started, I already had a few years of building websites under my belt. For example: I worked as the main developer at one of biggest soccer sites, and at the same time I had to take a course on the basics of HTML. Obviously, this disconnect was a problem for me, and for a lot of other motivated students around me. I want to solve this problem.

My solution is a program similar to a bachelor’s degree in length, but a lot more intense. In order to enter this program, you have to show your aptitude at programming. The program will have teachers from both academia and industry, because I think both theory and practice are very important. Only the best students and teachers can participate. Students have to study theory, but will also spent a lot of time doing internships and real projects. They will learn standard theory, but also topics such as node.js, statistics for big data analysis, native mobile programming, HTML5, git internals, et cetera. For each batch of students, I want to get financing from big companies who then get access to the talent.

To pull this off will be a huge and hard job, but I look forward to it. I’m still in the exploratory phase, and not sure whether I will actually do it, but at this moment in time I’m talking with people in both industry and academia to see whether it’s feasible. Instead of a bachelor’s program, a very good first step might be to organize a Hacker’s Summer School: 6 weeks of learning and hacking together with other talented hackers and awesome teachers.

Part of me thinks I’m too young, inexperienced and not connected enough to do this. But I still think I should at least explore whether it’s possible and should try. I have no idea in which form exactly. I don’t know what the topics are going to be, who the teachers are or even what the team should look like. I’ll keep you posted!

Radical Friendship

Tue, 15 May 2012 14:23:48 +0200

A few months ago I wrote about radical honesty. I tried being more honest, but in practice it’s quite awkward. Our society isn’t really used to being completely honest and open. For example, if a friend wears something I really dislike, I won’t tell him. It’s just my opinion, and by expressing it I don’t think I’ll help anybody.

In How To Win Friends and Influence People, Dale Carnegie says things like “ "Don’t criticize, condemn or complain”, “The only way to get the best of an argument is to avoid it” and “Show respect for the other person’s opinions. Never say, ‘You’re wrong.’”. In a way, you could interpret these statements as: don’t be honest when you disagree with somebody.

Recently, I was reading How Proust Can Change Your Life by my favorite modern philosopher Alain de Botton. He writes that Proust deliberately tried to avoid truth in friendship, lavishing his friends with compliments, sincere or not. This is pretty much the exact opposite of radical honesty, and equally exciting for me. A very interesting approach, although I don’t think I’ll use it.

Starting new projects

Fri, 27 Apr 2012 12:06:52 +0200

One of the most exciting things for me is starting new projects. Each time I start to build a new app, I get way too excited and see rainbows and ponies everywhere. “This time it’s going to beautiful, easy, quick to finish and lots of fun”. There is a blank slate and in my mind everything fits together perfectly.

However, in reality, after I’ve spent some time on a project, I start to see the design mistakes I made. Sometimes I even realize that the product/project itself isn’t a good idea. The longer I work on something, the harder it is to finish it. It definitely helps to work with a team, as you can pull each other through the hard times. When working with clients, it’s a lot easier to push yourself to finish something.

I might have found a way to utilize the starting of new projects in order to be more productive. In an earlier post, I wrote about how I create lots of test projects. I still do this, and sometimes when I am not looking forward to implementing some new feature, I instead start implementing it in a blank slate test project. As an additional advantage, the new code will probably be nicely isolated and loosely coupled.

Anyway, to get back to starting new projects: I think I will struggle with this throughout the rest of my life. It will always be more attractive to start something new than to finish something. However, realizing this problem is the first step in combatting it. And by using tricks like the one above I think it could even be bent to an advantage.

Berlin Tech Meetups

Mon, 26 Mar 2012 12:07:29 +0200

I’m trying to come up with a list of tech-related meetups in Berlin. This list is far from complete: please help me to add more meetups, and improve the descriptions. Just send me an email with corrections and/or suggestions. A next step would be to create a Google Calendar just like Peter Robinett did for Dutch Tech Meetups.

For people who don’t speak German: Germans are very friendly and speak English, especially the techies. Sometimes the announcements, webpages or conversations are in German, but Germans are very polite and quickly switch to English when necessary.

Here’s the preliminary list I’ve come up with:

Berlin Google Technology User Group

We meet regularly every 6 - 8 weeks to talk about recent developments in Google technologies or to spread practical knowledge through presentations. Next meeting: March 26th.

Berlin HTML5 User Group

This group was created to gather the HTML5 community in Berlin. Meetups/Webinars will be organized every month once moment we will have a certain number of people. All HTML5, CSS or Javascript enthusiasts (Developers, designers, webmasters…) are welcome to join.

The Berlin Semantic Web Meetup Group

Meet local people interested in standardized and future (Semantic Web) Internet technologies aimed at turning the Web into a huge repository of cross-referenced, machine-understandable data and executable artifacts, processes and services.

CouchDB User Group

We talk about everything couchdb, its future, our future, related technology and (our) projects connected to it.

Berlin DevOps

The group aims to bring Berlin’s system administrators, system engineers, system developers, web operators, software developers, test engineers, software architects and alike together and create a media for information and knowledge exchange.

Scrumtisch Berlin

Talking about everything scrum and agile.

Java User Group Berlin Brandenburg

Talk about Java.

CocoaHeads Berlin

CocoaHeads is a group devoted to discussion of Apple Computer’s Cocoa Framework for programming on MacOS X (including the iPhone).

Erlang Berlin

Talk about everything Erlang.

Clojure User Group Berlin

The Clojure User Group Berlin is a get together of people interested in Clojure–a Lisp dialect for the JVM. Come and discuss what you’re working on, have questions, and meet other like-minded people.

Django User Group Berlin

Wir sind eine Gruppe von 10 bis 20 Personen, die sich regelmäßig monatlich zusammenfinden, um über Django und die Welt zu philosophieren. Wir freuen uns über jeden, der Spaß an Django hat oder sich dafür interessiert!

FSFE Berlin

Wir sind eine aktive Gruppe von Fellows der Free Software Foundation Europe und Freie-Software-Interessierte. Wir machen auf die gesellschaftlichen Aspekte Freier Software aufmerksam.

Berlin.js

Berlin.JS is a usergroup focused on Javascript and related topics. We meet regularly on the 3rd Thursday each month at 7p.m. at co.up Offices, Adalbertstraße 7-8 in Berlin-Kreuzberg.

Berlin Tech Meetup

Every month we will have 4-10 companies do a short (3-5 min.) demo of something cool to Berlin’s tech community (geeks, investors, entrepreneurs, hackers, etc). We’ve seen it in New York and want to bring it to Berlin.

Silicon Allee Breakfast Meetup

German tech news in English - Berlin-based Community of Entrepreneurs. Not just tech, but all kinds of people involved in the startup scene.

Scala Meetup

Talk, Demo, Hack, Breathe, and just about anything else - Scala. In and around Berlin.

Credits: I’ve added the meetups that Isabel wrote about a few months ago: Berlin Tech Meetups.

Entitled

Mon, 27 Feb 2012 09:55:18 +0100

This post is inspired by Marco’s excellent piece: Right versus pragmatic.

I grew up in a small village. When I was 13, I didn’t really have money to buy music, but I still saved up and went to the record store so I could buy Americana. When I was 15, I got my first computer-job (as a php programmer). One month, I even made 1000 guilders (which was a lot for me). On Saturdays, I would cycle to Germany with my brother to buy CD’s at the big electronics store just across the border. For about two years, I bought a couple of CD’s per week.

However, around that time, my musical taste started developing to slightly more unknown bands, and the easiest way for me to get the music was by downloading it (I vividly remember using Kazaa and Napster, those were the days). The nearest record store where they had a decent selection of music was a 2 hour bike ride, which was not really an option.

For movies, it was the same. Once bandwidth started increasing, it just became easier to download movies. At the movie rental, they did not have the kind of movies I wanted to watch. I would buy them sometimes, but more often than not I decided that I wanted to see a movie after dinner, and downloading it enabled me to watch it the same night, rather than the next day (or even a few days later, if I had to order it online). TV shows generally lagged behind a whole season, if they would even broadcast them at all.

Pirating music, movies and also software became second nature. I didn’t think twice about it. Money was never the reason, it’s just that it’s so much easier to download something off of the Pirate Bay than order it online. However, after doing this throughout my student time, money did start to matter. Once you’re really accustomed to getting something for free, you start to feel entitled to getting it for free. And of course, virtually all my peers did it.

After graduating, I hardly ever used any pirated software, except for a certain graphics editing application. I still pirated music and movies (by the way, in The Netherlands you are allowed to download music and movies).

Recently, I had some hardware problems with my hard drive. For the first time in ever, I did a clean install. I copied back my old files, but not the pirated music, movies or software. My laptop is 100% free of pirated content. It feels good. My mindset has changed too: I realized I am not entitled to download it for free.

I think there are lots of opportunities for entrepreneurs because of this problem, especially in Europe. Spotify is one example, but we Europeans want to watch movies and the latest TV shows too. At this moment, I will refrain from watching movies that are not in the cinema or available in local stores.

An affordable graphics editor is definitely an opportunity too. Or maybe some subscription-based business models: there are some expensive applications that I would like to use for half an hour each month. For example, about once a year a client’s designer sends me a Fireworks file. The only thing I want to do with it is slice it up and produce some png’s. Instead of asking the designer to do it for me, I would rather rent an hour of Fireworks: it saves time and energy for both me and the designer, and Adobe would make more money. Everybody would win.