Objective-C Explained: The Language That Built the iPhone Era

Introduction: Before Swift, every iPhone app was written in Objective-C. Created in the 1980s by adding Smalltalk-style messaging to C, it became Apple's language through NeXT, macOS, and the first decade of iOS, and it still underpins much of Apple's older code. Its syntax looks strange at first, with square brackets and colons where other languages use dots, but that strangeness is its central idea: objects do not call methods, they send messages, and the runtime decides what happens next.

Messages, the runtime, and Cocoa: Message syntax: instead of object.method(argument), you write [object method:argument], and a method with several parts reads like a sentence, with each argument labelled. A dynamic runtime: messages are resolved at run time, so objects can forward messages, add methods, or respond in ways the compiler never saw, which powers much of Cocoa's flexibility. C underneath: Objective-C is a strict superset of C, so C code, pointers, and libraries work unchanged inside an Objective-C program. Cocoa frameworks: AppKit on macOS and UIKit on iOS, built on Objective-C, gave developers the windows, views, and controls that defined Apple software for decades.

Code (Objective-C):

#import <Foundation/Foundation.h>
@interface Greeter : NSObject
- (void)greet:(NSString *)name;
@end
@implementation Greeter
- (void)greet:(NSString *)name {
  NSLog(@"Hello, %@!", name);
}
@end
int main(int argc, const char * argv[]) {
  @autoreleasepool {
    Greeter *greeter = [[Greeter alloc] init];
    [greeter greet:@"Ayesha"];
  }
  return 0;
}

Explanation: @interface declares the class, @implementation defines it, NSLog prints with %@ for an object, and [greeter greet:@"Ayesha"] sends the greet message with its labelled argument. The brackets are the language.

The honest trade: Objective-C's trade is modernity and hiring: Swift is now Apple's preferred language, new projects rarely start in Objective-C, and its syntax and manual memory history (now mostly handled by ARC) feel dated to newcomers. When to reach for it: when maintaining or extending existing Apple codebases, where it is still essential; Swift for any new Apple project, where the tooling and community have moved.

The brackets that built an era: Objective-C is the language that built the iPhone era: C with Smalltalk messaging, a dynamic runtime, and Cocoa, in syntax that reads like sentences in square brackets. It trades modern tooling for history and depth, and for the codebases it still powers, that history is unavoidable.

Comments

Post a Comment

Popular posts from this blog

Swift Explained: Apple's Language for iPhone, Mac, and More

Introduction Swift is Apple's language for its platforms: iPhone, iPad, Mac, Apple Watch, and Apple TV. Introduced in 2014 to replace the older Objective-C, it was designed to be safe, fast, and, unusually for a systems language, genuinely pleasant to read and write. Even if you never ship an app, Swift teaches one idea every developer should understand: optionals. Optionals: saying "this might be missing" Most bugs in app development come from one cause: code assuming a value exists when it does not. Swift makes that assumption impossible to hide. A value that might be missing is wrapped in an Optional, and you must unwrap it before use. var nickname: String? = nil nickname = "Waqas" if let name = nickname { print("Hello, \(name)!") } else { print("No nickname set.") } String? means "a String, or nothing". The if let unwraps it safely: inside the block, name is guaranteed to exist. There is no way to accidentally use ...
Read more

Neovim Explained: Vim Rebuilt for the Modern Era

Introduction Vim is a legendary editor and, by modern standards, a hard one to extend: its Vimscript configuration language and single-threaded design show their age. Neovim, forked from Vim in 2014, keeps Vim's modal editing and keybindings while rebuilding the internals for the modern era: Lua configuration, a built-in language server client, async plugins, and a first-class terminal. It is why a generation of Vim users moved, same muscle memory, modern capabilities. What Neovim changes, and what it keeps Neovim keeps everything Vim users rely on: modes, motions, the dw / ci" grammar, and upgrades the parts around it: Lua configuration, init.lua replaces Vimscript for most users: a real programming language for config, with a huge plugin ecosystem built on it. Built-in LSP client, language servers (the same protocol VS Code uses) plug in natively, giving autocomplete, go-to-definition, and diagnostics without a plugin framework. Treesitter, incremental parsing gives...
Read more

Rust Explained: Memory Safety Without a Garbage Collector

Introduction Rust promises something that sounds impossible: the speed of C and C++, without their most famous class of bugs, crashes and security holes caused by bad memory handling, and without a garbage collector pausing your program to clean up. The trick is not magic. It is a set of rules, checked by the compiler before your program ever runs, called ownership. Ownership: every value has one owner In Rust, every value has exactly one owner: the variable that holds it. When the owner goes out of scope, the value is cleaned up automatically. Move the value to another variable, and the first one can no longer use it. fn main() { let s1 = String::from("hello"); let s2 = s1; // s1 is moved, not copied // println!("{}", s1); // Error: s1 no longer owns the value println!("{}", s2); // Works } This looks annoying at first, and it is, briefly. But it eliminates an entire category of bugs: no two parts of a program can accidentally free the same memory, ...
Read more