Mobile development basics: how to start with iOS development?

Author Iris Veronika Ćelić
Category Development
Date Jan 12, 2021
9 min read

I’ll share with you a step by step guide with a list of sources and tools that will allow you to gain the basic knowledge of iOS development. By sharing my own experience, I’ll sum up what you need to focus on in order to make your iOS start as streamlined as possible.

Interested in joining our iOS development team?
Take a look at our open positions:


As a senior iOS developer at Bornfight, one of my responsibilities is to support the growth of the iOS team. Because of that, I meet with various people who share the values and vision of our company, as well as the vision of the iOS team. During these meetups with potential employees, I noticed that I often get asked a few similar questions — “could you please share with me any resources for learning iOS you might think are valuable” or “what’s the most important thing to learn if I want to become an iOS developer”.

As a wise man once said, beginnings are always difficult. But in the hopes of making your iOS beginning just a bit easier, I wanted to sum up some of my experiences and share with you my answer to the question — “how to get started with iOS development? (… and become a great iOS engineer)”.

Start with the programming basics

If you recall the story of the three little pigs, you probably remember that each of the little pigs decided to build a house with different materials. The first two built their houses pretty quickly, from straw and sticks… and then got eaten by the hungry wolf. The third little pig decided to work hard and invest time in building a strong foundation for the house — he built his house with bricks and the hungry wolf couldn’t blow it away. So, what’s the moral of the story? The moral is that you should think of general programming basics as those bricks.

And this is especially important for everyone who didn’t study computer science or engineering in high school and college!

Here are some of the bricks you should definitely add to your foundation before starting with iOS development.

Basics of programming (study as language agnostic or C, C++)
  • Understand data structures (arrays, lists, stacks, queues, dictionaries…) — this is an alphabet for writing good code
  • Understand decisions and loops (if, elsif, switch, do-while, for-loop, while…), be able to write concise and avoid redundant code
  • Study memory allocation and management — how does it work under the hood and how does a computer handle memory
  • Understand pass by value vs. pass by reference
  • Understand compile-time vs. run-time
  • Think using operators (not, or, and, xor, %)
  • Learn and practice algorithms (sorts, searches, recursion, hashing…)
  • Invest time in studying design patterns

Basics of object oriented programming (study with any OO language: Java, Python, Swift, Objective-C etc…)
  • What is the difference between class vs. object vs. instance — try to explain it to a rubber duck as that will help you check if you fully understand it
  • What is the difference between class and instance variables or functions?
  • Study encapsulation and access control — why do we need it and how do we achieve it?
  • Understand the idea of interfaces and polymorphism
  • Understand the why and how of inheritance and composition — what does composition over inheritance mean?
  • Read about the separation of concerns — practice the concept by reading the code
  • Learn about the most common design patterns and don’t forget the anti-patterns
  • What is a singleton and why should we avoid using it?
  • Learn about dependency injection — when and why should we use it?
  • What is a so-called god object?

Books to read
  • Clean Code — a super-useful book with many examples for getting familiar with what clean code actually means
  • Design Patterns — in order to write more clever and powerful code, you should be familiar with these 23 patterns
  • Cracking the coding interview — learn what Google or Facebook would ask you in an interview
  • Code complete — this is widely considered one of the best practical guides to programming

Get familiar with the iOS world

Now that you understand the basics of programming, you can proceed with diving into the iOS world. I assume that you might be familiar with the iOS platform and possibly using Apple devices, but if that’s not the case, you should definitely start moving in that direction.

Do I need to buy a Mac?

Keep in mind that starting with iOS development is relatively expensive. This is due to the fact that iOS apps can be developed only in the macOS environment and we all know that Apple machines are pretty expensive. This is likely the reason why there are more Android than iOS developers in the market.

If you do not own a MacBook or an iMac and are not willing to spend a fortune on a machine, there are a few cheaper solutions you could consider:

  • Buying a used, older Macbook (that’s what I did when I started)
  • Buying a Mac mini (remember that you’ll need a monitor, keyboard and a mouse to use it)
  • Setting up a virtual macOS environment on Windows (did not try this on my own, but AFAIK it is pretty slow and unreliable — regardless, it can be a temporary solution before you buy a Mac)
  • Try Swift on Windows
Do I need an iOS device?

Technically not. Instead of running your app on the device, you can use the iOS simulator which is available within Xcode.

But, in order to get familiar with the iOS environment, I would strongly advise you to buy an iPhone. Even better, use it as your personal phone on a daily basis — get to know its features and get the feel of the Apple UI and UX. To build great apps you should be an iOS enthusiast.

Which tools do I need?

Actually, the only tool you need to begin is Xcode. Xcode is Apple’s IDE for creating apps for Mac, iPhone, iPad, Apple Watch and Apple TV. It’s free and available on the App Store. Download the latest version (do not use the beta version).

Xcode is a very powerful and complex tool, and getting familiar with all the features will help you build apps more easily. Explore debugging options: breakpoints, debugging the view hierarchy, printing variables in the debugger… This is very important in the beginning, since you will be mostly debugging your own code. Know the difference between targets and schemes, groups and folder references, build number and build version, .xcodeproj and .xcworkspace… Explore the main build settings and build phases.

Some other tools that I use are:

  • iTerm — good replacement for Mac’s Terminal
  • SourceTree — git GUI I would recommend to everyone who is starting with git
  • Proxyman — very useful tool for debugging HTTPS requests
  • Sublime — a multipurpose text editor

Dive into Swift

First of all, read the whole Swift Language Guide. Read it in detail (several times if needed) and try out different examples in the Xcode playground. Consider this guide a Bible for iOS developers. For more demanding or complex sections, use other resources to study the subject more deeply.

Try to contrast Swift with other programming languages you may be familiar with to evaluate the differences. Get to know Swift’s strengths and weaknesses.

In addition to learning the Swift syntax, try to remember the correct naming of Swift concepts like forced unwrapping, optional chaining, convenience initializer… Using the correct terms makes you sound more professional, helps with debugging and generally improves your communication with other developers.

iOS development concepts

Now that you have a good background in programming and are familiar with Swift, the next step is to learn different concepts you’ll need to build modern and maintainable iOS apps. I’ll try to sum up the list of different layers of the app — you can use that as a guide or a checklist while exploring and learning.

App Architecture

You will probably start learning iOS with the MVC architecture. Try to learn at least one more architecture — MVVM, MVVM-C, VIPER, Clean Swift…


Study the application’s lifecycle. What’s the difference between AppDelegate and SceneDelegate? Study View Controller’s lifecycle. What should we add in viewDidLoad and what goes in viewWillAppear?

Dependency manager

How do you organize dependencies of the app? How do you install third party libraries? Explore CocoaPods and/or Swift Package manager.


How can you make a simple HTTP request? Get familiar with the REST API. How do you write the whole networking layer of the app? Get to know one of the modern networking libraries like Alamofire. Moreover, many apps have the login option. Get familiar with eg. OAuth and handling tokens.

Data persistence

How can we persist data in iOS apps (like user’s email, password, data from the server side…)? Explore NSUserDefaults, iOS keychain, file management, databases (eg. Realm). This topic is very complex and important, so please take your time to investigate all of the options and when should you use each of them.

Communication patterns

There are many many ways how we can implement communication between 2 objects in iOS. In Bornfight, we mostly use RxSwift and Combine. Reactive programming is very powerful and widely used in iOS development, although it might be a bit of an overkill for junior developers. If you are not familiar with reactive programming, start with the good old delegate pattern, completion handlers and notifications.

User interface

There is always a lot of discussion about what’s the best way to implement UI in iOS.
Here are some options you can explore:

  • Storyboards
  • Xibs
  • Programmatically
  • SwiftUI
  • Combination of two

Don’t forget that your UI should be responsive and adaptable on all iOS devices. Auto layout is your friend.

If you are using storyboards, please don’t put all of your screens into one storyboard — it will get too messy. Try to use one storyboard for each screen.

Also, keep in mind that getting familiar only with SwiftUI probably won’t be enough at the moment since many legacy apps still don’t use SwiftUI.

Hierarchy and navigation

View hierarchy and navigation between screens can be a bit confusing in the beginnings. Understand the difference between pushing and presenting a view controller. You should be familiar with container view controllers. Navigating between screens with the coordinator pattern is pretty simple and clean, so I would strongly advise you to look into it instead of using seagues!


What is multithreading? When and why do we use it? How do you switch between the main and the background thread? What about the UI and multithreading?

Write a simple app

Covering the topics listed above should make you good to go and write a simple iOS app. Try to use all the concepts that you’ve learned along the way!

Choose one of the public APIs and build a simple app that includes: a navigation bar, tab bar, list of items, searching and filtering and a detail screen for the item. You can also add a home screen with an Apple sign in and a settings page with a sign out option. If you don’t have a design, you can copy the design from the AppStore app and use the iOS SF symbols.

Remember, the idea is not just to develop the app that works, but to write a clean and organized code.

Try to think of the app as a big drawer in your house. If we just throw all of the things into the drawer and close the door, the house will look clean and the guests won’t notice anything suspicious. Sounds great, but what will happen after a few weeks? If things in your drawer are not organized, you won’t be able to find things you need… and adding other things might make everything collapse on your face and you’ll probably end up hoarding a lot of trash. The same applies to software development — writing clean code makes apps maintainable (adding new features, changing the existing ones fixing bugs).

Good to know

In addition to the things specifically related to iOS, there are a few other things I would advise you to look into:

  • Version control with Git is a standard nowadays — get familiar with pulling, pushing, committing and stashing. Pull requests and code review are also widely used in the industry!
  • Design tools like Zeplin, Figma, InVision…
  • Task management tools like JIRA, Trello, Confluence…

Where to go next?

As I mentioned in the beginning, all of this is just a guide to help you start with iOS development. If you are completely new to mobile development, there are other more advanced topics you should discover and study later on… I did not include them in this starter pack.

Some suggestions from the top of my head would be: writing tests, concurrency, animations, push notifications, CI/CD, iPadOS, popular frameworks (Firebase, Crashlytics, SwiftLint…), provisioning profiles and certificates… Don’t forget about estimations, planning and soft skills which are also a significant part of being a good iOS developer. Subscribe to popular iOS newsletters, follow some interesting iOS blogs and do not miss the one and only WWDC.

Last but not least, always remember this — being a good developer means always learning new stuff. I hope you have a great journey in iOS development and feel free to apply to one of our open iOS positions.

Subscribe to our newsletter

Subscribe now and get our top news once a month.

100% development, design & strategy.

100% spam-free.

    You're now a part of our club!

    We got your e-mail address and you'll get our next newsletter!