New project announcement
I shipped skillcraft.ai - a tool that helps you find the best learning resources tailored to your goals. All you need to do is tell it what you want to learn, and I’ll find the right resources to get you there.
Archived
Published
6 min read

Trevor I. Lasn

Building tools for developers. Currently building skillcraft.ai and blamesteve.lol

Objective-C Is a Total Abomination (opinion)

Objective-C is, without a doubt, one of the ugliest programming languages out there

Objective-C is mainly used for developing software on Apple’s platforms, like macOS and iOS. Its syntax is notoriously difficult, combining elements of C with Smalltalk-style messaging. On paper, that sounds innovative. In reality, it’s a mess.

Concatenate two strings in Objective-C

NSString *string1 = @"Hello";
NSString *string2 = @"World";
NSString *combinedString = [NSString stringWithFormat:@"%@ %@", string1, string2];

This is unnecessarily verbose. Compare it to Swift.

let string1 = "Hello"
let string2 = "World"
let combinedString = "\(string1) \(string2)"

Swift is concise and clear. Objective-C, on the other hand, feels like you’re fighting with the language to do something simple.

Method Calls

Method calls in Objective-C are like reading a ransom note.

[myObject doSomethingWithParam1:param1 param2:param2 param3:param3];

Look at all those brackets and colons. It’s hard to read, and it’s easy to make mistakes. In contrast, Swift is straightforward.

myObject.doSomething(param1: param1, param2: param2, param3: param3)

Notice how much cleaner that looks. Swift’s syntax is modern, clear, and more like what you’d find in other languages. Objective-C feels like it was designed by someone who wanted to be different just for the sake of being different.

Memory Management: A Relic of the Past

Objective-C’s memory management used to be manual. You had to manage memory with retain, release, and autorelease.

MyClass *object = [[MyClass alloc] init];
[object retain];
// Do something with the object
[object release];

It’s clunky and prone to errors. Forgetting to release an object results in memory leaks. Retaining it too much causes crashes. This is a relic of a time before modern memory management.

Thankfully, Automatic Reference Counting (ARC) was introduced. But even with ARC, the language still shows its age. Compare this to Swift, where ARC is integrated seamlessly.

let object = MyClass()
// Use the object without worrying about memory management

Inconsistent Naming Conventions

Objective-C’s naming conventions are all over the place. Method names are long, descriptive, and sometimes too verbose.

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions;

There’s nothing wrong with being descriptive, but Objective-C takes it too far.

The result is code that’s difficult to read and maintain. Swift, by contrast, uses shorter, more consistent naming:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool

Swift’s method names are clear but concise, making the code easier to read.

Lack of Modern Features

Objective-C lacks many of the modern features found in newer languages. For instance, it doesn’t have proper support for:

  • Generics: Handling collections of a specific type is awkward.
  • Optionals: Dealing with null values is painful.
  • Type Inference: You have to declare types everywhere.

Here’s how you’d declare a generic array in Objective-C:

NSArray<NSString *> *array = @[@"Hello", @"World"];

And here’s how you’d do it in Swift.

let array: [String] = ["Hello", "World"]

In Swift, the syntax is cleaner, and you can often omit the type declaration because Swift infers it for you.

Working with Collections: A Tedious Affair

Working with collections in Objective-C is tedious. Let’s say you want to iterate over an array of strings.

NSArray *array = @[@"Hello", @"World"];
for (NSString *str in array) {
NSLog(@"%@", str);
}

It’s not terrible, but it’s not great either. Now, look at the Swift version.

let array = ["Hello", "World"]
for str in array {
print(str)
}

Swift’s version is not only cleaner, but it also benefits from type inference, making the code less verbose. You don’t have to declare the type of str explicitly; Swift figures it out for you.

Working with Blocks: A Confusing Endeavor

Blocks (closures) in Objective-C are another area where the language shows its age. Here’s an example of a block that adds two numbers.

int (^add)(int, int) = ^(int a, int b) {
return a + b;
};
NSLog(@"Sum: %d", add(3, 4));

Compare that to the equivalent Swift closure:

let add = { (a: Int, b: Int) -> Int in
return a + b
}
print("Sum: \(add(3, 4))")

Swift’s closure syntax is more intuitive and less cluttered. The Objective-C version is hard to read, and the syntax feels bolted on rather than integral to the language.

The Ugly Legacy: Header and Implementation Files

Objective-C splits code across header (.h) and implementation (.m) files. This is a relic from C, and it’s an outdated practice that clutters the codebase.

Header File (MyClass.h):

#import <Foundation/Foundation.h>
@interface MyClass : NSObject
@property (nonatomic, strong) NSString *name;
- (void)printName;
@end

Implementation File (MyClass.m):

#import "MyClass.h"
@implementation MyClass
- (void)printName {
NSLog(@"%@", self.name);
}
@end

In Swift, this would be combined into a single file:

class MyClass {
var name: String
init(name: String) {
self.name = name
}
func printName() {
print(name)
}
}

Swift reduces boilerplate and keeps everything in one place, making your code easier to navigate and maintain.

Here’s a classic Objective-C class that illustrates the verbosity and complexity of Objective-C syntax, especially when compared to modern languages like Swift.

Person.h (Header File)

#import <Foundation/Foundation.h>
@interface Person : NSObject
@property (nonatomic, strong) NSString *firstName;
@property (nonatomic, strong) NSString *lastName;
@property (nonatomic, assign) NSInteger age;
- (instancetype)initWithFirstName:(NSString *)firstName lastName:(NSString *)lastName age:(NSInteger)age;
- (void)displayPersonDetails;
@end

Person.m (Implementation File)

#import "Person.h"
@implementation Person
- (instancetype)initWithFirstName:(NSString *)firstName lastName:(NSString *)lastName age:(NSInteger)age {
self = [super init];
if (self) {
_firstName = firstName;
_lastName = lastName;
_age = age;
}
return self;
}
- (void)displayPersonDetails {
NSLog(@"Person Details: %@ %@, Age: %ld", self.firstName, self.lastName, (long)self.age);
}
@end

Contrast with Swift

In Swift, the same functionality can be achieved with much less code, in a single file, and with a clearer, more modern syntax.

class Person {
var firstName: String
var lastName: String
var age: Int
init(firstName: String, lastName: String, age: Int) {
self.firstName = firstName
self.lastName = lastName
self.age = age
}
func displayPersonDetails() {
print("Person Details: \(firstName) \(lastName), Age: \(age)")
}
}

Why We Should Move On

Objective-C was revolutionary in its time. It brought object-oriented programming to Apple’s platforms and powered apps for decades. But today, it’s an abomination. It’s ugly, clunky, and difficult to work with.

Swift is the future. It’s modern, clean, and designed with today’s developer in mind. It’s time to leave Objective-C in the past where it belongs.

If you’re still using Objective-C, consider switching to Swift. Your eyes and your sanity will thank you.


Found this article helpful? You might enjoy my free newsletter. I share dev tips and insights to help you grow your coding skills and advance your tech career.


Check out these related articles that might be useful for you. They cover similar topics and provide additional insights.

Tech
10 min read

Amazon's Rise to Tech Titan: A Story of Relentless Innovation

How Jeff Bezos' 'Day 1' philosophy turned an online bookstore into a global powerhouse

Sep 30, 2024
Read article
Tech
5 min read

Can OSSPledge Fix Open Source Sustainability?

The Open Source Pledge aims to address open source sustainability challenges by encouraging companies to pay $2,000 per developer per year

Nov 17, 2024
Read article
Tech
2 min read

Google's AI distribution advantage

While everyone debates models and features, Google owns the distribution channels that make AI stick

Jul 25, 2025
Read article
Tech
3 min read

Honey Quietly Hijacked Creator Revenue Through Affiliate Link Switching

Honey's controversial affiliate link practices and what it teaches us about Silicon Valley's ethics

Jan 4, 2025
Read article
Tech
5 min read

VoidZero: Threat or Catalyst for Open Source JavaScript Tooling?

When Evan You announced VoidZero, I'll admit - I got excited. And a little nervous.

Oct 15, 2024
Read article
Tech
2 min read

courses.reviews gets a facelift + now AI-powered

Find the perfect coding course with natural + language search and smart recommendations

Aug 24, 2025
Read article
Tech
5 min read

Cloudflare Study: 39% of Companies Losing Control of Their IT and Security Environment

New research reveals a shocking loss of control in corporate IT environments

Oct 3, 2024
Read article
Tech
5 min read

Recursion Explained In Simple Terms

Understanding recursion through real examples - why functions call themselves and when to use them

Nov 22, 2024
Read article
Tech
8 min read

Apple's Secret Sauce: The Untold Stories Behind Its Success

Diving deep into the lesser-known factors that propelled Apple from a garage startup to a tech titan

Sep 30, 2024
Read article

This article was originally published on https://www.trevorlasn.com/blog/objective-c-is-the-ugliest-programming-language-and-a-total-abomination. It was written by a human and polished using grammar tools for clarity.