Today I thought about migrating Apricum to Swift as I did remember the WWDC announcement saying it’s about 50% faster than Objective-C.

Click for the stackoverflow post regarding swift’s performance

I rewrote the necessary parts (just 3 classes) of the Apricum patch programming core in Swift and tested a simple add patch with 1000 different input values (two random numbers for input a and b).
The Objective-C version (which uses the Apricum Core framework) took 0.0087s and the Swift version (not nearly as big as the Apricum framework) took 0.0211s.
I’m not saying that this is a good test as both versions are quite different so I made two similar versions and compared them.

// Objective-C
@interface SimpleAdd : NSObject
-(NSUInteger)add:(NSUInteger)a and:(NSUInteger)b;

@implementation SimpleAdd

-(NSUInteger)add:(NSUInteger)a and:(NSUInteger)b {
	return a+b;


int main(int argc, const char * argv[]) {
	@autoreleasepool {
		SimpleAdd *add = [[SimpleAdd alloc] init];
		NSDate *start = [NSDate date];
		for (NSUInteger i = 0; i < 100000000; i++) {
			NSUInteger a = arc4random()%(UINT32_MAX/100);
			NSUInteger b = arc4random()%(UINT32_MAX/100);
			NSUInteger res = [add add:a and:b];
		NSDate *end = [NSDate date];
		printf("Duration %f\n",[end timeIntervalSinceDate:start]);

    return 0;
// Swift
class SimpleAdd {
	func add(a: UInt32, b: UInt32) -> UInt32 {
		return a + b;

let add = SimpleAdd();

let start = NSDate();

for _ in 0...100000000 {
	let numA = arc4random() % (UINT32_MAX/100);
	let numB = arc4random() % (UINT32_MAX/100);
	let res = add.add(numA, b: numB);

let end = NSDate();

let dif = end.timeIntervalSinceDate(start);

print("Duration: \(dif)");

Now Objective-C took 4.1378s and Swift 4.3653s, which doesn’t seem like a big difference. But Swift doesn’t have dynamic method calls (well it supports the target/actions, but only by using Objective-C) unlike Objective-C where every call to a NSObject is a dynamic method call.

I personally will continue to use Objective-C over Swift, not because Objective-C is in one arbitrary test 0.2275s faster than Swift. It’s mainly because I’m not the biggest fan of the Swift programming language. It’s easier to read if you know Java/JavaScript already, which is a big advantage if you want to get into iOS Development and already know one of them, but I’m missing the features I love about Objective-C.
Additionally the freedom to choose whether you check objects for nil or just call a method is far, far better than those nested ‘if let’ checks you see all over Swift code. Most of the time the code I’ve read ends up using var xyz: ExampleType! which is even worse, as it’ll end up crashing your app if xyz isn’t set somehow, which although it should not happen, might happen.

Another part I really dislike is the lack of backward compatibility in Swift. While programming Objective-C, it happened once, that a change has been made that needed code changes. That was the migration to ARC, where you can still (to this day) mix ARC code with non-ARC code.
The complete opposite is Swift, where changes are frequent and mandatory. I was working on a project and over night Xcode updated to version 7.0 with a slightly different Swift syntax, making it necessary to change small parts all over the project (Fortunately one team member already did change most parts to the new syntax). This incident drove me away from using Swift for big projects, as I can compile more than 5 year old Objective-C code, but can’t compile Swift code I wrote a few months ago.

Although it probably sounds like it, I don’t hate Swift. Every programming language has pros and cons and you have to pick the one that matches your requirements and personal preferences. Swift is quite simple (I’d put it somewhere in the middle between JavaScript and Java) yet quite efficient, which actually isn’t that important anymore. Whether you wait 1ms or 2ms for your app to load doesn’t make any difference and if there are some parts that need to be faster you can still write them in C (and therefore also directly in assembler) to speed them up.