In this article, I'll go over what I believe it takes to become an iOS developer in 2021.
I'm aiming this squarely at two groups of people, absolute Swift beginners – people who have never built anything for iOS before – and so-called false beginners – people who have tried to learn Swift before but never really achieved their goal of getting a full-time job.
Regardless of your current level, the goal here is the same. To put you in a position to apply for a junior iOS developer role at a company.
We'll look at the skills you should be learning, the courses you can take, how to get connected to the community, common mistakes people make, and more.
Best of all, everything I'll discuss will be completely free, so you won't have to pay a dime to follow along.
Seriously, far too many people believe that spending a lot of money will put them on the fast track to their dream job, when the most important factors are determination and willpower.
Here's a hint: if you're already thinking about skipping ahead in this article, you should probably work on your willpower!
This article is divided into seven sections:
- Core skills that you must have in order to get a job.
- Extension skills that are nice to have – the ones that will set you apart from the crowd if you put in the effort to learn them
- Common blunders people make when attempting to learn.
- The many free resources available to help you learn Swift.
- How to get in touch with the iOS development community.
- An estimate of how long it will take to achieve your goal.
- You're getting ready to apply for your first job.
The fundamental skills required to become an iOS developer
What is the absolute bare minimum of skills required to land a job in iOS development?
I believe there are five in total:
- Working with data
- Version management
That list is intentionally kept short for a variety of reasons:
The more you learn, the more you realise there is to learn, so it's easy to spend so much time studying and practising that you lose sight of the main goal.
You want to work as an iOS developer, not just sit around learning new things!
It's almost certain that you'll be joining a team that already has an app they want you to help develop, so unless you get extremely lucky, they'll need to teach you a whole bunch of stuff regardless.
If you try to cram a whole bunch of extra topics in beforehand, you're probably wasting your time.
Two of those five things are huge and complicated, and you could spend months just trying to wrap your head around them without venturing anywhere else.
Most importantly, if you get those five things right, you can create a wide variety of apps. Sure, your code won't be perfect, but that's okay because the only way to write great code is to first write a lot of bad code.
Let me break the five items down into smaller chunks.
Swift is first on the list. This is Apple's core programming language. It has no concept of displaying information on an iPhone's screen or downloading data from the internet.
Swift is only a few years old, so it makes use of almost every cutting-edge language feature available.
On the one hand, this means that you can avoid all of the crusty old behaviours that are common in older languages like C++ and Java. It also means that it has a slew of more advanced features that may blow your mind at first.
And that's fine. Many parts of Swift are relatively simple, while others will take you longer to fully grasp, so just take your time and persevere – you'll get there!
The second core skill I mentioned is SwiftUI, which is an Apple framework that allows us to use Swift to create apps for iOS, macOS, tvOS, and even watchOS.
So, while Swift is the programming language, SwiftUI provides the tools for developers to create apps, such as how to display images, text, buttons, text boxes, data tables, and more.
To be clear, SwiftUI isn't a replacement for Swift – it's a framework built on top of Swift that allows us to create apps. You'll need to know both Swift and SwiftUI to succeed.
If you thought Swift was new, you haven't seen nothing yet!
As far as I can tell, SwiftUI is only two years old! Despite its youth, the iOS community has embraced it wholeheartedly because it's so easy to use.
Apple also has an older framework for building iOS apps called UIKit, and if you ask a bunch of people whether you should learn SwiftUI or UIKit first, you'll get a variety of answers.
I think you should learn SwiftUI.
So, in case you're wondering, here's why I believe you should prioritise SwiftUI as a core skill.
It is significantly easier than UIKit, and I mean significantly – it takes perhaps a quarter of the code to achieve the same results as UIKit, and there are fewer things to learn along the way.
This means you gain a lot of momentum because you can build things faster, see results faster, and iterate on those results faster, which is extremely motivating while learning.
Created for Swift
SwiftUI was created for Swift, utilising language features to assist you in avoiding problems and achieving maximum performance.
For example, if you change some data on one screen of an app, SwiftUI will automatically ensure that the new data is updated anywhere else in your app that uses it – you don't have to write code to keep it all in sync yourself, which is surprisingly complex.
UIKit, on the other hand, was written for Apple's older language, Objective-C, and as a result has all sorts of quirks that resulted from its age.
SwiftUI is compatible with all of Apple's platforms, so you can use what you learned on iOS to create a macOS or watchOS app with nearly identical code.
Sure, some features, such as the Digital Crown, are exclusive to a single device, but the vast majority of what you learn will work on any device.
But, most importantly, SwiftUI is the direction in which things are heading.
If you were applying for a job right now, you'd probably need to know UIKit, but the fact that you're reading this means you're much further along in the process.
Yes, UIKit is more popular now, but SwiftUI will be the dominant UI framework by the time you finish learning it in 6, 9, or even 12 months.
Seriously, the world's largest companies, including Apple, are choosing SwiftUI.
When Apple recently launched widgets in iOS 14, they made it a requirement that you use SwiftUI.
Networking and data manipulation
The third and fourth skills I mentioned were networking and data manipulation. When compared to Swift and SwiftUI, these are a piece of cake, or at least at the level required to get a junior iOS developer job.
Networking is the practice of retrieving data from the internet or sending data from a local device to a remote server.
There are numerous methods for accomplishing this, but the most important thing to understand is how to retrieve JSON from a server.
And this is where the other essential skill comes into play, working with data.
Again, there are numerous ways to load and save data, but the absolute minimum you must be able to do is convert the data you received from a server using your network code into information that your app can display.
So, the third and fourth core skills are inextricably linked. Fetch some data from a server, then convert it into information that can be displayed in your app. Some developers joke that writing this type of code is half the job of an iOS developer, and it's certainly true that we rely heavily on it.
The final skill isn't coding at all, its version control, such as Git. Again, you don't need much here, but it's important that you're able to publish your code somewhere public, such as GitHub, so recruiters can see your work.
Nobody in the world truly understands how Git works, but that's okay – you just need to know enough of the basics to store your data safely and collaborate with others.
So, when those five are added together, there are two massive ones – Swift and SwiftUI – as well as three minor but important ones.
If you can just focus on those five things without getting distracted, you'll be well on your way to your first iOS developer job.
That's it: those are the five essential skills I believe you need to be an iOS developer.
There are thousands of people who only have those skills and can build and ship fantastic apps on the App Store.
What comes after the fundamentals?
Once you've mastered the five core skills, you'll be able to ship your own apps and work as an indie developer, as well as apply for junior iOS development positions and work for a company if that's what you want to do.
There are no other special qualifications required – just nail those core skills and you'll be fine.
However, if you've mastered those skills and want to advance, there are five more skills I recommend you learn. These are the skills that will propel you from a good to a fantastic position – you'll become even more employable, and the range of apps you'll be able to build will expand even further.
The abilities are as follows:
- Core Data
- Software architecture
As before, I'd like to go over each of these in greater detail so you understand why I think they're important – and why I think of them as extension skills rather than core skills.
First, there's UIKit. This is Apple's older user interface framework, which has been used for app development since 2008 – it's 13 years old as I write this, which is old in software terms. But that doesn't mean UIKit is bad. In fact, as you get used to how it works, you'll be surprised at how elegant it can be.
There are numerous reasons why UIKit is worthwhile to learn, including:
Hundreds of thousands of apps have already been written in UIKit, so if you join a company that has a large, well-established app, you will almost certainly be required to write UIKit code to maintain that app.
UIKit is far more powerful than SwiftUI – there are many things you can do in UIKit that are not currently possible in SwiftUI.
Using Auto Layout technology, you can create extremely precise layouts.
If you run into issues with your code, UIKit has more solutions than SwiftUI simply because it has been around for a much longer time.
All of this makes UIKit sound fantastic, so why did I make it an extension skill rather than a core skill?
Because UIKit has issues as well:
Almost everything is more difficult to do in UIKit than in SwiftUI, with some tasks requiring a hundred times, if not more, code.
SwiftUI was designed specifically for modern iOS development, so it does a lot of the heavy lifting for you.
Because UIKit was not written in Swift, it has many features that SwiftUI does not have – many implicitly unwrapped optionals, marking code with a special @objc attribute to make it available to UIKit's Objective-C underbelly, and the need to use protocols and delegates to display simple data.
Nothing about Auto Layout is "automatic" – in fact, if you ever try to build a complex layout, you may have nightmares about Auto Layout. It's extremely clever, but it's also extremely difficult in places.
And this is why I consider UIKit to be an extension skill: it takes significantly more time and effort to learn than SwiftUI, which means it requires a lot more determination – you have to really want to learn it, or else you'll get confused, bored, angry, or potentially all three.
Sure, SwiftUI doesn't have all of the features of UIKit, but it allows you to make quick progress and gain momentum before moving on to UIKit.
Managing Core Data
Core Data, Apple's framework for working with application data, is the second extension skill I mentioned.
I mentioned networking and working with data in the core skills section, and it's true. With those skills in place, you can fetch whatever you want from a server and display it in your app.
Core Data takes it a step further by allowing you to manipulate that data once you've obtained it, such as searching for specific values, sorting the results, and more, all very efficiently.
It can also easily connect to iCloud, ensuring that your users' data is synchronised across all of their devices.
Core Data has a slew of drawbacks, the most serious of which is that it isn't always pleasant to work with. Core Data is nearly as old as UIKit, and while it worked well in Objective-C, it does not feel as natural in Swift.
It integrates well with SwiftUI, which makes it feel less strange, but it's still a surprisingly complex topic.
So, why did I include it as an extension skill? Because, like UIKit, Core Data is extremely popular – hundreds of thousands of apps have been built with it, and it is used in many large and small businesses.
Core Data, like UIKit, is extremely powerful, and while you could recreate the most important parts of it in your own code, why would you?
Testing your code
The third skill on my list of extensions is testing. Writing special code to ensure that your main app code works as expected.
Tests allow us to ensure that our code works correctly, and more importantly, that it continues to work correctly even after we've made significant changes to it.
For example, if you change 500 lines of code to implement a new feature and all of your tests pass, you're good to go.
As a result, testing is critical and will assist you in writing higher-quality software.
So, why is it considered an extension skill rather than a core skill?
There are three reasons for this:
The iOS community as a whole is terrible at testing, for whatever historical reasons. I mean, really bad – many large apps have no tests at all, and I've lost count of the number of senior iOS developers I've met who are almost proud they never write tests.
When you consider all of the amazing things you can create with Apple's tools and frameworks, writing tests doesn't seem like much fun in comparison.
Personally, I enjoy writing tests in the same way that I enjoy flossing my teeth, but I know that many people do not, especially when working on personal projects.
When applying for a job, knowing Swift and Apple's major frameworks will always be more useful than knowing how to write tests.
Companies would prefer that you know how to use SwiftUI, UIKit, or one of the other big hitters, because testing is a much smaller topic – there aren't nearly as many things to learn.
So, testing is important, testing matters, and I'd love to teach you how to write great tests. But only after you've mastered the fundamentals of app development – after you've had some success, felt the rush of having your app live on the App Store, and mastered testing.
The fourth extension skill I'd like to discuss is software architecture, which is really about how we write code.
You're going to write some terrible code when you're first starting out – code so bad that it probably violates the Geneva convention.
That's okay because that's how you learn. You don't start good – you get good by being bad for a long time, just like LeBron James wasn't born a champion basketball player.
The point is that you stick with your bad code until you figure out how to do better. That's where software architecture comes in. Looking at tried-and-true techniques for structuring your code to make it easier to read, use, modify, and maintain in the long run.
These techniques sometimes rely on the way Swift works – language features that can be used to write better code.
However, there are numerous other techniques that work in any programming language and are commonly referred to as design patterns.
One important aspect of this skill that you should begin to learn is how to break up your code.
For example, if you're creating a single screen in your app, it could include a login button, an image gallery, and a list of friends.
However, you should ideally separate each of those parts – a login button component, an image gallery component, and a friends list component – so that you can reuse any of those components in other parts of your app.
Software architecture is far more subjective than the other skills I've discussed thus far. For the others, such as SwiftUI, you can reason, "Well, I know how to do X, Y, and Z, so I'm confident I'm a good SwiftUI developer."
Software architecture is a very broad topic, and there is often no obvious "right" way to solve a problem, so I believe the best benchmark for it is this: do you look back on your code from six months ago, a year ago and so on.
Again, writing bad code is acceptable as long as it gets you closer to writing better code.
I certainly grimace in places when I look back on code I wrote five years ago, because I know more now than I did then – and that's a good thing.
The final extension skill I'd like to discuss is multithreading, which is the practise of making your code do more than one thing at a time.
Multithreading can be a real pain in the neck because it's difficult for our brains to comprehend. When your code does one thing at a time, we can think it through linearly, but when two or three things happen at the same time, potentially overlapping, it can really bend your brain.
So, while multithreading is a great skill to have as an extension skill, you should be cautious. Your goal should be to understand just enough of the concepts and code to make it work well without going too far.
To be honest, many developers believe that multithreading will instantly make their code run three or four times faster.
While this is true in some cases, in many other cases, your code will actually run slower, and you will now have to deal with all of the additional code complexity.
If you don't believe me, consider this David Smith quote – He is a member of Apple's Swift team and has previously spent years working on the very core of Apple's frameworks:
“My specific recommendation is that you avoid writing async/concurrent code as much as possible. This may seem strange in 2018, but the cost in complexity and performance is high.
So, learn a little bit about how multithreading works in Swift to demonstrate that you understand the concepts and implementation, but don't go overboard!”
Common mistakes new iOS developers make
At this point, I've listed all of the core and extension skills I believe you'll need to work as a full-time iOS developer.
But I also want to discuss some of the most common mistakes people make while learning, because I see them all the time and know how they set people back.
There are seven major issues that people face, and I'd like to go over them in order.
They are as follows:
- Remembering everything
- Syndrome of the shiny object
- Lone wolf learning
- Making use of beta software
- Depending on Apple's documentation
- Getting bogged down in Objective-C
- Aiming at other languages
Let's go over each of them one by one.
Stop attempting to remember everything
The first, and by far the most common, issue people encounter is trying to memorise everything – reading through a tutorial and believing they must remember everything in it by heart.
Please, please, please don't do that. It's a recipe for disaster and will sap all of your willpower to the point where you'll never want to programme again.
Nobody remembers everything. Nobody comes close to remembering everything. Even if you only consider the APIs published by Apple, which are the pieces of code we can use to build our apps, there must be well over a hundred thousand available.
Even if you limit it to the core components of app development, you're still looking at several hundred – all working in a very precise way that requires a lot of learning to use.
Instead, you learn how to do something new and then promptly forget how to do it again.
So, you look it up, use it again, and then promptly forget about it. So, you look it up a third time and use it, and this time you mostly forget it – some parts stay with you.
This cycle continues indefinitely, with you having to refer to a tutorial or some other reference guide each time, until the fundamentals are ingrained in your mind to the point where you can do it without consulting anyone else.
If you didn't already know, forgetting is an important part of learning.
Every time you forget something and relearn it, it sinks deeper and more thoroughly into your brain. When you relearn something, your brain makes new connections with other things you've learned, which helps you understand more about the context of what you're attempting to do.
And each time you relearn, you're signalling to your brain that this particular topic is important enough to store in its long-term memory.
But if you set out to memorise everything, you're going to struggle.
Instead, don't be concerned about forgetting things. Knowing where to look them up is far more important than memorising specific Swift code to accomplish something.
When you forget something and have to relearn it, consider it a good thing – that information will sink in deeper the second, third, and tenth time you learn it, so you're helping your brain.
Avoid shiny object syndrome
The second most common issue I see people encounter is what I call "shiny object syndrome," in which they find a tutorial series that works well for them and begin making progress, but after a week or two, they notice another tutorial series that they want to follow and jump ship to that instead.
I've had people email me saying they've tried four, five, or even six different series and aren't learning anything for some strange reason.
The issue here is that many aspects of learning anything are uninteresting. That isn't necessarily the fault of the teacher.
It's just a fact of learning to code – some things give you great results with little effort, while others take a lot more time to understand, don't produce fancy results, or are only one part of a larger concept.
When you hit these steep learning curves, shiny object syndrome kicks in – with so many free tutorials available, you can jump ship to any one of them and restart, and you'll be back in the shallow end of the pool, covering easier parts you've already learned.
But, unless the original course chose an unusual topic to cover, you're probably going to have to learn it eventually, and you're just postponing the inevitable.
So, I'm not asking you to always resist shiny object syndrome because I understand how difficult it is. Instead, at the very least be aware of it: when you encounter a problem, try asking someone else for assistance and persevering rather than switching.
Don't go it alone
Speaking of asking someone else, the third issue I see people run into is when they go all lone wolf with their learning – they believe they are fully capable of learning to build iOS apps using Swift all by themselves and do not require the assistance of others.
This method works for a very small number of people, typically those with extensive experience with other programming languages or platforms.
However, for the vast majority of people, learning in this manner is a terrible experience – every mistake or misunderstanding takes five times as long to resolve, it's extremely easy to lose motivation, and you're missing out on a lot of inspiration from watching others succeed.
If you're a natural "lone wolf" learner, I encourage you to change your ways.
Share what you're learning, connect with others who are learning, and develop the habit of asking questions.
Not only will you discover a fantastic community of learners who will support and encourage you, but you will also be inspired by their work and, in turn, inspire them with yours. Trust me, I've seen this hundreds of times, and it's completely transformative.
Don’t use beta versions
The fourth major issue I see is when people insist on using beta versions of Apple's development tools.
I understand: every year, Apple releases a new iOS, a new macOS, and other products, always delivering exciting new things for us to try. It's natural for people to want to learn the latest and greatest, especially if they know Swift has a long history of change.
However, when people try to learn with beta software, they run into a slew of issues:
Because tutorials haven't been updated for the beta version, following their instructions won't always be possible or will fail.
Bugs are common in betas, especially those released for major iOS updates.
Apple's beta frameworks take time to stabilise, which means that code that worked in beta 1 may not work in beta 3.
So, while it's exciting to learn new things, and you may believe you're getting ahead of the game with new features, trust me: it's not worth it.
Always use the most recent public releases of Apple's developer tools until you're comfortable with them.
Relying on official documentation
The fifth major issue that people face when attempting to learn is relying on Apple's documentation.
Apple's developer publications team works hard to document as much as possible from the company's vast array of frameworks, but their main job is to write reference material – things you read when you're trying to use a specific piece of their tools – rather than creating a structured course to help you learn to build iOS apps.
I've lost count of the number of times people have asked me, "How can I learn Swift?" only to be told, "Read Apple's Swift reference guide."
This approach does work for some people, and I know because it worked for me when Swift was first announced – I read it cover to cover.
However, for most people, it's similar to trying to learn a human language by reading a dictionary. It's intended to cover everything in the language rather than teach you the most important parts and how to apply them.
So, if you have extensive experience with other languages, reading Apple's reference guides may be useful, but if you're just starting out, you might want to revisit them after a few months.
Getting bogged down in Objective-C
The sixth major issue that people face is attempting to learn Objective-C. This was Apple's primary development language prior to the introduction of Swift, and while there are remnants in some old codebases, the vast majority of existing code is now Swift, and almost all new code is also Swift.
I spent years writing Objective-C before Swift and really grew to love it, but it has an extremely steep learning curve and lacks most of Swift's important features.
I remember when Apple first announced the iPhone SDK and being horrified by Objective-C because it was unlike anything else I had seen so far.
Objective-C and Swift have almost nothing in common for a beginner.
Yes, they share the same Apple frameworks, but unless you plan to work at Apple – the only company in the world still producing large amounts of Objective-C – you should leave Objective-C alone and concentrate entirely on Swift.
Ignoring other languages
The final major mistake I see people make when learning Swift is dismissing other languages as inferior to Swift.
iOS development resources and courses
Now for the part that most people are interested in: what are the actual resources I believe you should use to learn Swift, SwiftUI, and more – in order to achieve your goal of becoming an iOS developer?
There are many out there, and I appreciate the fact that the Swift community has such a diverse group of people sharing their knowledge.
However, in this article, I'm going to focus on free resources – places where you can learn to build fantastic apps without spending a dime.
This is due to two factors:
- Some people believe that the higher the price of a Swift course, the better it must be, so they end up paying exorbitant prices without receiving adequate benefit.
- Many sites, such as Udemy, rely on selling a large number of low-cost courses, confident that if you don't like one, you'll just buy another. They also have a business model similar to Steam's in that there are constant sales, encouraging people to accumulate a large number of courses to study "one day."
So, I'm only listing free resources here because I don't want you to fall into those traps – don't spend a hundred dollars or more on your first course, and don't buy a dozen cheap courses thinking that will make you a developer.
To begin, Apple has two major resources that can assist you. The first is its Teaching Code website, which contains student and teacher resources for learning Swift from the ground up, all the way up to professional certifications.
Their curriculum is extensive, so it may take some time to find the best entry point for you, but once there, you'll find plenty to explore.
Second, Apple has a series of SwiftUI tutorials that walk you through the process of creating real-world apps. These, however, do not teach Swift, so you must first complete their Swift-focused curriculum.
As I previously stated, Apple also publishes a guide specifically for the Swift programming language, but there's a good chance it won't work for you – it's intended as a reference rather than a structured tutorial, so it's quite dense reading.
What Apple's tutorials don't do is attempt to provide a structured method of learning.
YouTube and other sites
There are some excellent YouTube videos that walk you through the fundamentals of SwiftUI, such as:, in which he walks you through the process of creating a slots game from the ground up. explains five SwiftUI concepts that everyone should learn when they begin programming. that features both Swift and SwiftUI while taking audience questions.
There are other sites with high-quality Swift and SwiftUI tutorials, including BLCKBIRDS, Ray Wenderlich, Donny Wals, Antoine van der Lee, and more – I really encourage people to visit a variety of resources and find what works for them.
If you prefer to learn through apps, I recommend two that are both completely free. The first is Apple's Swift Playgrounds app, which allows you to learn Swift directly from your iPad or Mac.
There are many interactive lessons aimed at children, but there are also some more advanced lessons that will help you advance your skills.
The other app is called Unwrap, and it was created by me. Unwrap is compatible with all iPhones and iPads and allows you to learn, review, and practise Swift fundamentals through videos, tests, and other tools. It covers all of the fundamentals of Swift and complements the 100 Days of SwiftUI curriculum perfectly.
Finally, you'll need to learn how to find answers online. This could mean going to Stack Overflow, but I'm hoping not because it's not a particularly pleasant place.
Instead, ask questions on the Hacking with Swift forums, your favourite Slack group, the iOS Dev Happy Hour sessions, Twitter, and elsewhere – we are a genuinely warm, welcoming community with many people eager to assist you in reaching your goals.
Getting involved in the community
Speaking of our community, I'd like to discuss a really important topic that will help you meet people in similar positions to you, learn more effectively, and find job openings – it's a win-win situation all around.
The subject is connecting with the iOS development community. This includes knowing where to look for news and interesting ideas, where to go to meet people and share tips, and where to go to ask questions.
Who should I follow on Twitter?
Let's start with the simplest, which is to use Twitter. Twitter is a fantastic way to follow things that interest you, and there are a few people I would highly recommend in the case of iOS development.
Yes, these people tweet about their own work, but I think they're great to follow because they also tweet a lot about other people's work – they'll help you see a variety of perspectives on a particular topic, and they share all kinds of interesting ideas and things to try.
Here are 9 people I recommend you follow on Twitter:
Sean Allen spends a lot of time on YouTube making Swift and iOS development videos, but he also works really hard to spread the word about other people's work – he really does a great job of helping everyone discover something new every week.
Novall Khan works for Apple, but that doesn't stop her from posting videos on a regular basis about what she's working on, what she's learning, what she's having trouble with, and more – she's really inspiring.
Steve Troughton-Smith is well-known for his earlier work tinkering with iOS, but you should really follow him for the fantastic array of links he shares to impressive work. I like how he shares the development progress of his own apps, so you can see them grow from beginning to end.
Kaya Thomas is one of our community's most well-known indie developers, and she's been featured by Apple more times than I can count. She tweets frequently about her own work and presentations, but she also shares links to books she's reading, articles she's read, and other resources.
Majid Jabrayilov not only writes a fantastic Swift and SwiftUI blog, but he's also a tireless promoter of others – if you follow him on Twitter, you'll get idea after idea sent your way from a wide variety of sources.
Donny Wals writes a Swift blog and, more recently, books on Combine and Core Data, but he also encourages people to share what they are working on on Twitter. Even just reading that thread once a week will inspire you to try new things, so you should definitely follow Donny.
Sommer Panage works on Apple's accessibility team, so while she is somewhat limited in what she can say, she does tweet out a lot of first-rate tips from herself and others that everyone can use to build better apps.
Natascha Fadeeva writes a blog about Swift and iOS development, including articles on Core Data, interview questions, and other topics, but she also tweets about things she finds elsewhere.
Newsletters and more
Of course, Twitter isn't the only place to stay in touch with the community; there are also newsletters, Slack groups, Zoom meetups, forums, conferences, and other venues. I don't want to bore you too much, so I'll just list one of each here:
You can't go wrong with iOS Dev Weekly for newsletters. As I write this, it has just passed 500 issues, one every week, which I believe tells you everything you need to know about how important it is.
If you want to post on a web forum, https://www.hackingwithswift.com/forums is pretty good. There are many categories to choose from, and anyone, regardless of experience level, is welcome to participate. You are more than welcome to post your beginner questions here, believe me!
Every month, the iOS Dev Happy Hour is held on a Zoom group call with over 300 people, but the real fun is in the breakout rooms, where you can chat with groups of 6 to 8 people at a time. It's a lot of fun, and you'll meet new people.
Attending conferences has been difficult due to the coronavirus pandemic, but Apple's WWDC was a huge success last year, and it was accompanied by a slew of community events. A group of friends and I created a GitHub repository to help keep track of all the other events, articles, and other things that happened – take a look!
Finally, if you prefer to chat on Slack where you can get answers faster, you can join the free Hacking with Swift Slack group and join one of the Swift, SwiftUI and other channels.
How much time does it take to learn iOS?
This is a frequently asked question of mine: how long does it take to progress from knowing nothing about Swift to being able to obtain an entry-level iOS developer position?
The obvious answer is "it depends," but that would be a cop out in this case, so let me address it in a few different ways.
The golden rule is to not rush
First and foremost, you cannot take multiple courses at the same time. Remember what I said about the "shiny object syndrome"? Yes, many people believe they can take two courses at the same time, then cram for four, five, or even more hours every day and still have a high-quality understanding of the topics they covered.
To be clear, I've seen people try this so many times and it always fails. Every time – it never works, and I hear people say it's because the tutorials were bad, or because Swift was too difficult, or for literally any other reason other than trying to rush through something complex.
I literally just got an email saying, "Hi Paul! How quickly can I finish Swift if I study for four or five hours a day?" And that is simply not how learning works – whether it is learning Swift, learning to play the piano, learning to ice skate, or anything else.
Learning Swift can be difficult at times, and learning to build apps requires a lot of trial and error, making mistakes, and taking wrong turns. And that's fine – it's better than fine, it's fantastic!
Because every time you try something, make a mistake, or take a wrong turn, you learn something along the way, and when you finally arrive at the solution, you'll understand it much better.
So, the TL;DR here is don't rush – take your time, don't be afraid to explore tangents that arise, don't be afraid to experiment with your projects, and don't be afraid to go back to something you previously learned and relearn it as needed.
What is your educational background?
Second, you should consider your background prior to coming to Swift. You see, learning to build apps requires a wide range of skills, and if you come to the table with a wealth of prior knowledge such as version control, data structures, algorithms, and more, you'll have a significant advantage over those who are new to computer science in general, as well as Swift and other Apple frameworks.
So, here are a few possibilities for where you might be right now:
If you have a computer science degree, you will already be familiar with many of the CS fundamentals needed to get started with Swift. Variables, arrays, loops, arrays, sets, functions, OOP, and other concepts will be useful in Swift, as will all of your work with data structures and algorithms. This could save you 4-6 months of study time depending on the subjects you studied, and it will also give you an advantage when applying for jobs at many companies.
If you don't have a CS degree but have attended a coding bootcamp, you'll have many of the fundamentals you'll need to get started with Swift. This won't give you the same advantage when applying for jobs at those companies because they often expect a degree just to check a box on their list of arbitrary requirements, but it will still save you three or four months.
If you don't have a CS degree and didn't attend a bootcamp, but you've been coding in your spare time, you'll save some time – probably two months or so, depending on the language or frameworks you were using.
What if you don't have a CS degree, haven't attended a bootcamp, and have no prior coding experience? Then I'd estimate 9 to 12 months to go from nothing to an entry-level job. Yes, that could be a full year of work on top of whatever your current full-time job is, and that's just to get your first job as an iOS developer.
Is it always the same year? No. If you have prior experience, you can cut that time down to 1 to 6 months, as I previously stated. If you take the best numbers on both sides – 9 months from nothing to an entry-level job, plus 6 months for having a CS degree – that means you could be hirable in just 3 months, which is incredible.
You may believe that finding your first job in three months is impossible, but it isn't. Heck, I met someone who was taking my 100 Days of Swift course and got a job before day 50 – they had already learned enough about app development in less than two months because they put in the effort to make every day count.
So, you don't need a CS degree or a bootcamp, but you do need to be willing to work hard.
Allow yourself some leeway
The third point I'd like to make before we move on is that "it takes as long as it takes." I love a lyric by John Lennon that goes, "Life is what happens when you're busy making other plans."
It's fantastic if you have big plans for learning and big dreams for the job you want, but sometimes you're tired, sometimes you're stressed out, sometimes your roof leaks or your dog needs to go to the vet or your kids need extra help with their homework, or whatever, and that's just life.
So, don't be too hard on yourself if you fall behind with your learning schedule, or if you find yourself missing a few days or even a few weeks, and so on – as long as you're resilient, you'll get there.
That's fantastic if you work really hard and get a job after 50 days – well done! If it takes you 500 days, that's fantastic as well, and you should be just as proud of yourself. Heck, if it takes you five years, I'm sure it's not what you wanted, but the end result is the same, and that's all that matters.
Getting ready to apply
Last but not least, if you're a little further along in your iOS learning journey and thinking about landing your first entry-level job, I'd like to point you to a massive collection of resources I put together to assist you.
I'd recommend Sean Allen's Swift interview tips videos – he has a whole playlist for them where you can work through individual discussions such as classes vs structs, functional programming, error handling, and more. None of the videos are particularly long, but they are all designed to provide you with the skills you need to perform well in an interview situation.
Okay, so I've gone over the core and extension skills you'll need, common learning mistakes, courses you can take, how to connect with the iOS community, and how to prepare for your job interview – that's a lot to cover, and I hope it's been helpful.
Furthermore, I hope I've demonstrated how much information is available for free.
Yes, the temptation to spend a hundred dollars or more on a course is strong, but relax – get moving first, find some momentum, and also find someone who teaches Swift in a way that works for you. When you're in a good place and feel ready, go ahead and spend some money if you want.
Best wishes on your journey!
Please leave a useful comment with your thoughts, then share this on your Facebook group(s) who would find this useful and let's reap the benefits together. Thank you for sharing and being nice!
Disclosure: This page may contain links to external sites for products which we love and wholeheartedly recommend. If you buy products we suggest, we may earn a referral fee. Such fees do not influence our recommendations and we do not accept payments for positive reviews.