I have been doing a lot of interviewing as I am helping Earnin build out a Vancouver office. I have had as many as three interviews on the busiest of days.
This has forced me to structure my evaluation and ranking of developers. I ask a number of cultural questions that are company and context specific. However, the technical topics are portable enough to make sense at most software companies.
I made myself a checklist of five main topics:
- Programming Languages
- Data Structures & Algorithms
Let’s expand on each bullet in the above list.
The best developers have an excellent understanding of Swift, Objective-C, and C.
They have an understanding all the way from high-level language design to compiler implementation. They understand the basic syntax, control flow, and types. They also understand scope, memory model, and concurrency.
A senior developer can compare and contrast these languages at a superficial syntax level. And they can also describe these differences in terms of static vs dynamic, type theory, compilation, and runtime.
- Basic syntax and semantics
- Control flow
- Functions and closures
- Enumerations, structures, and classes
- Memory model and lifecycle
- Optionals and error cases
- Classes and objects
- Methods and messages
- Protocols and delegates
- Memory and reference counting
- Types, operators, and expressions
- Control flow
- Pointers and arrays
- Header files
The senior developer has a broad understanding of many of the frameworks that are used day-to-day. But they can also compare and contrast them with 3rd party frameworks and frameworks from other languages and operating systems.
I am looking for understanding. But I am also looking for nuanced opinions on pros and cons.
- Auto Layout
- Core Data
- Core Animation
Data Structures and Algorithms
This section will be controversial.
My belief is that you can be a productive member of a team as a junior or intermediate software developer without a deep understanding of computer science.
However, a senior developer must have a strong foundation of computing science theory, and even more importantly, be able to implement this in software.
That may involve implementing a cache, fixing concurrency errors, creating memory pools for optimization, or low-level integration with systems software.
This theory must also be engineered in a well-designed, well-tested manner.
- Associative Data Structures
- Protocols: HTTP, TCP/IP, TLS, etc
- Design Patterns
- Unit Testing
At least half of mobile development is interfacing software with the operator of that software.
I try to understand if the developers can critique and implement good design vs bad design. Do they have an interest and an understanding?
Do they think about the customer of the software when writing code? Do they think through business implications?
Software is a team sport. Senior developers are able to take large feature requests and break them down into small TODO items that can be iteratively shipped.
They interact with product, design, QA to get this done.
They know how to use tools to effectively communicate.
- Source Code Control: git, Github, branching/merging, PRs
- Bug tracking: JIRA, etc
- Working with Design: Sketch, Zeplin, feedback
- Working with Product: User stories, Job-To-Be-Done