How To Become A Senior iOS Developer

Written by Reinder de Vries on December 4 2018 in Careers

How To Become A Senior iOS Developer

It’s not easy to get hired as a junior iOS developer1. Most companies would rather hire more experienced, senior developers instead. And they’re not keen to train juniors on-the-job, afraid that they’ll leave the company once trained.

When you look at it from the point of view of these companies, the picture is equally bad. Companies report that it’s easier to raise capital, than it is to find developer talent2. Recruiters make a killing from the shortage of developers, and companies are paying a premium for quality hires3.

This is an opportunity for the developer who knows how to do her work well. The elusive senior developer, with “10+ years of experience.” The problem is that you, and the market, don’t have time to get 10 years worth of software development experience.

So, what we’re going to discuss, is how you can grow to a more senior level in a shorter amount of time. How do you become a senior iOS developer without those “10+ years of experience”?

Let’s get started.

  1. The Problem: Junior-Senior Divide
  2. What’s A Senior Developer?
  3. Senior Developers In Teams
  4. Mistakes, Curiosity And Innovation
  5. Further Reading

The Problem: Junior-Senior Divide

Here’s a shorthand for the level of experience of a software developer:

  • Junior: 2-3 years of experience
  • Senior: 10+ years of experience
  • Medior or “mid-level”: in between junior and senior

This years-of-experience shorthand has a problem. It doesn’t say anything about the quality of software development. How much experience and skill did you gain in those years?

This is why job interviews for developers are so complicated. It’s hard to measure skill, so we’re giving developers tests. These tests rarely represent the work you’ll do at your job, but it’s the best approximation we have.

And to save time, we’ll filter out the segment that probably won’t make it anyway: the juniors. As a result, it’s tough for junior software developers to get hired. Even though companies actually want and need developers!

These are all symptoms of a much bigger problem: there’s no clear path through the “dead zone” between junior and senior. Once you’re not a junior any more, when do you become a senior?

According to Stack Overflow’s 2018 Developer Survey4, 72.1% of developers have 8 years of professional coding experience or less. Over half of respondents have 5 years experience or less, and a full 30% has 2 years experience or less. In other words: a bit more juniors than seniors, with a lot of developers in between.

I suspect that many of the in-between developers are actually working on a level that’s on par with senior developers, or almost equal. Junior and mid-level developers can be trained and mentored to get through the junior-senior divide quicker. As a result, the years a developer needs to become a senior drops on average – so we’ll have more senior developers.

At this point I could say that more senior developers are good for the companies that want to hire them, and good for the marketplace. But to be honest, I don’t care much for these companies.

What I do care about is helping developers do their best work. That includes learning more, gaining skills and experience, and getting better opportunities. So, that’s what we’re going to discuss next.

Some companies also call their senior developers lead developers or team leads, which suggest they’re taking a leadership or management role within the development team. In this article, we’ll consider leadership a competency of a senior developer.

What’s A Senior Developer?

What a senior developer exactly is, is a widely discussed topic5, 6. Some articles give excellent insights into the characteristics of senior developers, whereas others overly generalize and try to put developers on a scale of “good, better, best.”

Software development is creative work. Some consider it an art like poetry or prose, even. You can’t evaluate creative work on a linear scale. What worked best in scenario A, might not work as well in scenario B.

An extensive, broad skillset is a recurring theme. It’s recommended that developers gain experience in skills related to software development, like leadership, communication, product management, and understanding sales, marketing and design.

It’s hard to create a prototypical model of the senior developer. They simply come in all shapes and sizes. But that doesn’t mean you don’t recognize a senior developer when you see one. Based on that, we can establish an idea about what a senior developer is.

A senior developer…

  1. … has one or more concrete software development skills she specializes in
  2. … understands that what works in scenario A, might not work in scenario B
  3. … has an extensive, broad skillset related to software development

No. 2 stands out for me personally: a junior developer typically knows one solution to a problem, and always applies that one solution. A senior developer knows many solutions to a problem. They can decide which one to take, and transparently communicate that to the people involved in the project.

A few other traits also come up:

  • Leadership: Senior developers are often asked to take up a leadership role, either directly in managing a team or as a “beacon” for product design and management. As a lead, they don’t directly manage developers, but they do have a say in product development, and help their peers along. A lead developer is someone who says: this is where we’re going.
  • Personal Leadership and Productivity: Senior developers aren’t more productive than junior developers, but they’re often more skilled in prioritizing work. They are communicative, and conduct themselves in such a way that the right information gets to the right person at the right time.
  • Making Mistakes: Perhaps that’s the biggest mistake of a junior developer: trying to avoid making mistakes. Many real mistakes were made doing that, so the senior developer has learned to make mistakes, adjust course, and continue onwards.
  • Not Dealing In Absolutes: Senior developers don’t throw Model-View-Controller overboard for being sluggish, and they don’t complain that “OOP is not functional enough.” Instead, they adapt tools to their needs, and clearly see their advantages and drawbacks. (The hypocrisy does not escape me. Some senior developers need to loosen up and innovate.)
  • Always Be Testing: A senior developer does not have a fixed mindset. Instead, she’s always testing assumptions and beliefs. The plans she has might not work, and she’s the first to admit that. She’ll try anyway, testing what works, and discarding what doesn’t.
  • Learning And Education: When you don’t learn, you stagnate. Senior developers are always learning, trying to find new ways to apply what they know to new situations. Junior developers are often big learners too, but the difference is that a senior developer doesn’t stop once they’ve mastered something. Most senior developers know more than one programming language well.
  • Must-Haves: You just can’t get around them. App architecture, Git and gitflow, unit testing, code review, agile, documentation, mentoring, side projects, community contributions, emotional maturity, professionalism. They don’t make a senior developer, but they’re often expected skills. It’s OK to strike a good balance here.

You can use these ideas to find out how you want to grow, as an aspiring senior developer. Let’s highlight some of them, to shape a path forward.

On software engineering: Software development vs. software engineering is a bit of a controversy. My idea about it is simple: we’re calling it software development, but if you’re not using engineering practices to do your work, you’re probably going to learn a lot…

Senior Developers In Teams

Code review and mentoring come up often, when discussing the skills of a senior developer. It appears that a senior developer has a distinct, clear role within a software development team.

Software development is an odd skill in this regard. Writing code is almost always done in solitude, but building software is most often done in a team. How does a senior software developer fit in that picture?

A particular idea about junior developers often comes up: “Junior developers need constant oversight.” I think that’s too blunt. A junior developer might need more supervision than a senior, but every developer needs to check their work with peers to see if it’s OK. If anything, a senior developer touches base more often.

I once joined a project where many people were developing an e-learning app. We had a UI/UX designer, a graphic designer, people with subject-matter expertise who developed content, a project manager, an operations manager, and a few others. The development team consisted of a front-end developer, a back-end developer, and me.

What made us successful wasn’t excellent code, but excellent communication. The app worked OK, was extensible, and code was tracked, reviewed and refactored. Architecture was discussed, and needs and requirements were mapped and designed. We missed a deadline, but managed to get back on track. This was made possible, in part, because I kept the people involved up-to-date with concise, relevant and timely information.

Something similar happened when I developed a prototype app on my own, for a single client. No one other than us two were involved in the project, except for live testing after the protoype was done. Again, communication was crucial to the success of the project. The client didn’t have the funds to build an extensive app, so we had to make sure that the app was minimal and viable.

Did code quality and technical design not matter? Of course they did! The big difference between junior and senior developer, in these scenarios, was the role of communication. A junior software developer can write excellent code, but still needs to learn to communicate effectively. A senior developer excels at coding and effective communication.

And there’s more:

  • Code review, and discussing how to architect a software development project, is a task often given to the (most) senior developer on a team. When there’s no dedicated project manager involved, this senior developer is often the so-called team lead.
  • Senior developers are often asked to mentor juniors. This implies a status role, in which the senior teaches a junior. From what I’ve seen, it’s more effective when the junior and senior developers teach each other. You can achieve more in a weekly 2-hour workshop than in countless informal 1-on-1’s.
  • Some topics are often skipped by juniors, and inherently attributed to senior developers. Architecture, Git and gitflow, unit testing, TDD, and tooling. These topics and skills are so rich, because they touch on many deeper principles that are worth learning. Unfortunately, they’re skipped because they’re difficult to master.

A surprisingly quick approach to learn these things as a junior developer is to contribute to open source software. You can learn a lot about the inner workings of a project by contributing a Pull Request on GitHub. You’ll also need to communicate with other stakeholders, and adjust your work accordingly.

Another approach is to simply write as you’re learning. Plenty of iOS developers do this, and they learn a lot by teaching others. The same goes for helping out on Quora, Reddit and other welcoming communities.

The bare minimum is reading open source code, and immersing yourself in your favorite GitHub repository. Perhaps you don’t feel ready to contribute code, but that doesn’t mean you should sideline yourself as a mere code consumer. You can get yourself up to speed with the codebase and help out with questions from other developers.

Let’s move on.

Mistakes, Curiosity And Innovation

To me, software development is innovation. As developers we’re constantly coming up with new solutions to problems. Sometimes, that means choosing the right database platform to do data entry and automation a bit better. At other times, it means finding and building a new implementation of some new technology like AI. At best, your tool brings people closer together.

Ever wondered what the word “app” means? Most of us know it’s short for “application”. Why do we call those little square icons on our smartphones applications? It’s because they apply a given workflow or algorithm to a problem we have, and give us access and control with a user interface.

Building something new inevitably means you’re going to make mistakes. It’s simply never been done before, so you don’t know everything beforehand. Reflecting on your work and improving your ideas leads to innovation. Here’s one way to look at it:

At the root of innovation lies the curiosity to find out how things work, without expectation or judgement. Innovation leads to mistakes, mistakes provide insight, and these insights fuel your curiosity once again.

The hallmark of a senior software developer is curiosity. Curiosity is a tool that gets better the more you use it, and that’s exactly what we’re looking for in an excellent software developer. A creator who doesn’t merely provide what we already have, but who can lead us to where we always wanted to go.

I know that these big words are a bit cryptic, and that’s intentional. It’s up to you to shape what you look like as a senior software developer. I can’t tell you how to be excellent, but I can give you a true north.

Here’s some ideas that can help you along the way:

  • Never stop learning. Pick up a course, a book, an online degree, and use it to enrich the ideas you already have, and to get new ideas.
  • Enroll other people in what you do. No one is an island, and ideas can’t form in a vacuum. Show us what you’re working on.
  • Focus on the fundamentals. Make sure you understand how they work, so you can use it as the basis for your work.
  • Don’t tell us your ideas, show us your projects. Ideas are overrated anyway. When your ideas are used and spread, we can see how they work.
  • Strike a balance between new and established ideas. Don’t stay a beginner forever, but don’t blindly accept ideas about what you “should” know.
  • Show up. We desperately need you to lead us. Teams are lost without your ideas on how to move forward.
  • Don’t just make it work. Make it extensible! Never blindly copy-and-paste solutions, and code in such a way that your future self thanks you for it.

Everything starts with curiosity. If you’re not curious, you might as well quit.

Further Reading

I have to admit, I don’t always take my own advice. Some of my code can’t be unit tested. Other code is so inelegant, verbose or rotten that it’ll make your skin crawl. Plenty of code clearly violates some architectural rule or design pattern. It’s definitely more than I’d like to admit!

At least I know. It’s an opportunity to do better, and I’ve learned to recognize them. Being a senior developer isn’t something you are, it’s something you get a chance to be again and again and again.

Thank you for reading this far! I’d love to hear your thoughts. Feel free to get in touch.

References:

  1. https://medium.com/@melissamcewen/who-killed-the-junior-developer-33e9da2dc58c
  2. https://stripe.com/reports/developer-coefficient-2018
  3. https://hackernoon.com/2018s-software-engineering-talent-shortage-its-quality-not-just-quantity-6bdfa366b899
  4. https://insights.stackoverflow.com/survey/2018/#experience
  5. https://jvns.ca/blog/senior-engineer/
  6. https://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer/

Become a professional  iOS developer

Get started with iOS 12 and Swift 5

Sign up for our iOS development course Zero to App Store to learn iOS development with Swift 5, and start with your professional iOS career.

Reinder de Vries

Reinder de Vries

Reinder de Vries is a professional iOS developer. He teaches app developers how to build their own apps at LearnAppMaking.com. Since 2009 he has developed a few dozen apps for iOS, worked for global brands and lead development at several startups. When he’s not coding, he enjoys strong espresso and traveling.