Objective-C still underpins huge iOS codebases. These questions check whether a candidate understands its memory model and dynamic runtime, not just the syntax.
Hiring a Objective-C developer is easy. Telling a real one from a convincing résumé is the hard part — and it’s most of what we do. These are grouped by level, because the same question that stretches a junior is a warm-up for a senior.
Junior Objective-C interview questions
0–2 years
Fundamentals.
How does message passing work in Objective-C?
You send messages to objects with bracket syntax; dispatch is dynamic at runtime, and messaging nil is safe (returns nil/zero).
Assumes calling a method on nil crashes.
What is the difference between a class and an instance method?
Class methods (+) operate on the class; instance methods (-) operate on an object.
Confuses the +/- prefixes.
What are properties and @synthesize?
Declared storage with accessors; modern compilers auto-synthesize the backing ivar and getters/setters.
Hand-writes accessors unnecessarily.
What is the difference between strong, weak and copy property attributes?
strong retains, weak doesn’t and nils out when freed, copy stores an independent copy (used for mutable-backed types like NSString).
Uses strong for a delegate and creates a retain cycle.
What is a protocol?
A declared set of methods a class can conform to, used heavily for delegation and interfaces.
Cannot explain delegation.
What is the difference between NSString and NSMutableString?
Immutable vs mutable string; assigning a mutable to a copy property protects against external mutation.
Stores a mutable string in a strong property and it changes underneath.
What is nil vs NULL vs NSNull?
nil is a null object pointer, NULL a null C pointer, and NSNull a placeholder object for collections that can’t hold nil.
Tries to add nil to an array and crashes.
What are categories?
A way to add methods to existing classes without subclassing, useful for extending framework classes.
Subclasses where a category would suffice.
Mid-level Objective-C interview questions
2–5 years
Memory and patterns.
How does ARC work?
Automatic Reference Counting inserts retain/release at compile time based on ownership, freeing objects when their count hits zero.
Thinks there’s a garbage collector.
What is a retain cycle and how do you break it?
Two objects strongly referencing each other never deallocate; use weak references (e.g. for delegates) to break the cycle.
Makes a delegate strong and leaks.
What is the delegate pattern?
An object delegates behaviour/notifications to another conforming to a protocol, a core Cocoa pattern; delegates are weakly referenced.
Retains the delegate strongly.
How do blocks capture variables and what’s the risk?
Blocks capture referenced variables strongly by default, so capturing self can create retain cycles; use a weak reference.
Captures self strongly in a stored block and leaks.
What is the difference between copy and retain/strong?
retain/strong shares the same object; copy stores an independent snapshot, important for mutable types.
Uses strong for an NSString property that gets mutated externally.
What is KVC and KVO?
Key-Value Coding accesses properties by string keys; Key-Value Observing notifies observers of property changes.
No idea how observation works.
How does the dynamic runtime enable features?
Runtime method resolution, introspection and swizzling; powerful but easy to abuse and hard to debug.
Swizzles methods casually and creates fragile behaviour.
How do you handle nullability and interop with Swift?
Nullability annotations (nullable/nonnull) so Swift sees proper optionals across the bridge.
Leaves APIs unannotated and Swift sees implicitly-unwrapped optionals.
Senior Objective-C interview questions
5+ years
Architecture and maintenance.
How do you maintain and modernise a large Objective-C codebase?
Incremental Swift interop, nullability annotations, tests, and refactoring toward clear architecture rather than a rewrite.
Proposes a risky full rewrite to Swift.
How does Objective-C interoperate with Swift?
Via a bridging header and generated interfaces; annotations and lightweight generics improve the Swift-side experience.
Cannot get the two languages to work together cleanly.
How do you diagnose memory issues?
Instruments (Leaks, Allocations) to find retain cycles and abandoned memory, plus zombie detection for over-release.
Guesses at leaks without profiling.
What are the risks of method swizzling?
It changes behaviour globally at runtime, causing fragile, hard-to-debug interactions, especially across libraries.
Swizzles framework methods in production casually.
How do you architect a large iOS app in Objective-C?
Clear patterns (MVC/MVVM), delegation, dependency injection, and separation of concerns to tame massive view controllers.
Massive view controllers doing everything.
How do you ensure thread safety?
Confine UI work to the main thread, use GCD queues to serialise access, and avoid shared mutable state without synchronisation.
Updates UI off the main thread and races on shared state.
How do you test legacy Objective-C code?
Introduce seams via protocols and dependency injection, add characterisation tests, and refactor incrementally.
Considers the code untestable and changes it blindly.
When would you keep Objective-C rather than rewrite in Swift?
When the code is stable, large and low-churn; incremental interop usually beats a risky rewrite for business value.
Rewrites working code purely for language preference.
Build and score a full interview with our free interview scorecard tool, browse the full question hub, or see how we interview engineers.