If you search for an iOS developer on LinkedIn, you will see job titles prefixed with the word "senior". What does it mean to be a "senior developer" and, more precisely what does it mean to be a "senior iOS developer"?

Interviewing other people and talking with them during meetups, I have found out that there are many different opinions on this topic. Furthermore, every company has its own scale for this, but very few have a written agreement about this.

We can all agree there is an unclear border between junior, mid and senior developer in IT industry, especially in the iOS industry.

In this blog post, I will give my opinion on what does it mean to be a senior iOS developer.

Architecture

If you have applied for an interview, one of the unavoidable questions is about architecture. As a senior iOS developer, you should know about MVC, VIPER and MVVM architecture patterns. You should know their pros and cons and use them appropriately, depending on the project's needs.

Design patterns

If you want to write a beautiful, maintainable and readable code you have to use design patterns. You should know what they are and use them appropriately.

In iOS these are "must knows":

Singleton

Observer

Delegate

Strategy

Factory

Iterator

Builder

Multicast delegate pattern

Facade pattern

Composite pattern

Memento pattern

Additionally, you should be familiar with the SOLID principle and use it appropriately.

Objective-C vs. Swift

Today, many new iOS developers learn only Swift. I agree that Swift is the main iOS programming language, but to become a senior iOS developer deep knowledge about Objective-C is required.

Everything in iOS SDK has been built in Objective-C and works best with the Objective-C programming model in mind. Many third party libraries are still written in Objective-C. However, the most important reason to know it, you might have to work on an older project that is written in Objective-C and you will be expected to know how to work with it. Additionally, having an idea how to migrate from Objective-C to Swift depending on project needs is also required.

Knowing Swift pros and cons is for mid developers so I will not talk about them.

Data Persistence

There are various ways to persist data on iOS devices. You should be familiar with these:

UserDefaults

Core Data

Sqlite Database

Keychain

Realm database

NSKeyedArchiver and NSKeyedUnarchive

Saving files directly on the file system

Plist

You should know when to use each of these methods having in mind: security, speed, less code, better syntax, reusability, support, complexity of data models and frequency of the model change.

Networking

First, you must know formats like json, xml, html.

Then you should know how to make network requests, parse json data, chain asynchronous requests, make authentication and use tokens.

You should be familiar with these:

You should also have an idea how to cache network requests.

Concurrency

You should be familiar with Grand central dispatch and Operation and when to use one over another.

In summary:

GCD vs. Operation

serial queues vs. parallel queues

async task vs. sync task

main thread vs. background thread

Security

It is very important to keep the application secure and without vulnerabilities. Having that in mind, you should be familiar with these concepts:

symmetric and asymmetric cryptography

public and private key

SSL Pinning

SSL protocol

Keychain

MASVS — Mobile Application Security Verification Standard

GDPR — General Data Protection Regulation

User interface

Building great UI is very important in the iOS world. There are several things I would like to point out here:

You should know how to build a user interface from interface builder and from a code. You should know the pros and cons of both and when to use one over another.

You should have deep knowledge about auto layout and know when to use it and when not.

You should know how to build an interface for different device sizes.

You should know about the UI calculation on non-main thread. Knowing Texture library that does that, or any other is a bonus.

Animations

Great UI comes with an animation. I will repeat again, great UI is very important in the iOS world. Sometimes it seems like the most important thing. To keep up, these are the required things to know:

Basic animations on UIView

Core animations

Custom transitions between two screens (push, pop, present, dismiss)

Furthermore, I would not say it is required, but knowing things like Lottie and Paint code is very much welcome.

Dependencies

There is a big number of hight quality third party libraries and frameworks that you would want to include in your project. There are basically three things that you should know:

integrate third party code into your project by hand

use CocoaPods as your dependency manager

use Carthage as your dependency manager

You should also know that there is a Swift Package Manager, but it is not an option right now because it doesn’t support the iOS platform.

You should have heard for this third party libraries: Alamofire, AFNetworking, Texture, SnapKit, Reactive cocoa, RxSwfit, MagicalRecord, Realm, Kingfisher, SDWebImage, Specta, Expecta, Fabric/Crashlytics, Firebase.

Reactive programming

Nowadays reactive programming is very popular. Many IT agencies uses it as a programming standard. It is an ok setup, but, as with everything in the world, there are ups and downs when using this pattern and you should know them.

However, knowledge about reactive programming is unavoidable. In iOS there are a few libraries that I would like to point up:

Code integration

Git is a version control system. We cannot imagine a programer’s life without this tool, so good skills are required.

You should be familiar with CI (Continuous integration) as well as with CD (Continuous Delivery). Also, you should have an idea on how to set it up.

QA

I know that there are dedicated testers in IT companies, but I think a programmer should be responsible for a software quality. As a senior developer you should produce a high quality product. First, you should be familiar with these concepts and use them:

unit testing and FIRST principle of Unit testing

integration testing

UI testing

end to end testing

manual testing

You should also be able to set a QA process that best suits project needs and take responsibility for a software quality.

Education

Every day something new comes in the iOS industry and we can all agree that nobody can know everything. To keep up with all the new stuff, constant education is very important. That is why you should read books, blogs, watch videos, follow newsletters, attend meet-ups and conferences, generally speaking, be active in the iOS community.

Furthermore, writing blogs/books, speaking at conferences or developing your own library is a big bonus and is recommended for a senior developer.

Soft skills

Very often job description for a senior developer lack soft skills. I believe that they are as much valuable as technical skill. Here are a few that are very important:

Communicating with team members, clients and other people

Finding solutions with teammates / being able to come to an agreement

Having skills like being able to estimate thing correctly, delivering on time and taking responsibility for your work

Appropriately approaching the problem

Time management

Leading junior developers

Conclusion

Even though you might be familiar with all the things I have mentioned, I you may or may not call yourself a senior iOS developer. The point is, this is my opinion and you are more than welcome give your thoughts on the subject.

I would also like to point out that 10.000 hours rule is also a good guidance. I know that you can have a really good knowledge in less hours, but trust me, once you reach that number you will see the difference.

It is like a driving a car. In one year you might be a really good driver. You might be skilled in curves, driving backwards, parking, but I’m sure that you won't experience all the things such as driving an automatic/a manual/a big/ a small car, driving in the snow or mud, what to do when you have a flat tire or what to do when a certain safety light is on. In five years, if you drive often, you will probably experience all this.

Where to go from here

If you are not familiar with all the concepts I have mentioned here is the list of sources I would recommend:

Architecture

Design patterns:

Reactive programming

Data Persistence

Security:

Animations

Networking