The main thing when you start learning any programming language is to have a great resource from where you can start and spend quality time. The whole learning process is much easier when you have some great guide, at least to know what are the most valuable docs and tutorials.
The usual way to start learning is through video lessons. Ups, wrong!
The way that is much better is to go with the documentation first.
If you want to be an iOS dev, you need to have one of the Apple products (laptop or desktop) and an iPhone is desirable but you can find simulators in Xcode so it can replace the iPhone.
Xcode is the main IDE for making an iOS application. It provides everything you need for programming, including simulators for every device that Apple supports. You can find the built-in documentation inside the Xcode, you can debug your code, track the performance of the application, and much more. In one sentence – All in one.
Swift road and where to start
Let’s take a closer look at the swift road that I am trying to follow.
It is the learning curve for beginners and also some advanced info. Let me unclutter some things in the beginning. Basic stuff can be swift as a programming language, Xcode, and playground part of the Xcode where you can check and test small codes and play in swift in general. Common or next step should be to get to know about Human Interface Guidelines.
In the deep, it can be app structure and design pattern as oop and package manager, testing tools, and deployment.
Main and side documentation and resources
The main documentation that you can inform of everything is
My way of the learning process is to go first with swift documentation:
You can find everything useful in getting to know a language. In the end, it is just reading with concentration.
After that, you can visit https://www.hackingwithswift.com which is a little more organized with lessons and of course, the main thing that you can find in lessons or blog form is https://www.raywenderlich.com
The most helpful information you can get from the books:
In those books, you can learn through the examples of mini-projects.
The most important thing to me is to get knowledge of some inevitable stuff in programming. You can find this part of the blog everywhere in the programming world.
So in the meanwhile, you should pay attention to the design patterns and architecture, also you need to pay attention to the project structure.
Which design pattern you need to apply depends on the type of application.
You can pick MVC or MVVM design implementation in your project and clean architecture. The difference is mostly in whether you want to use UIKit or SwiftUI. Once again this is the most popular design pattern.
Patterns and framework explanation
This is the one way of programming that you can divide on MVC or clean architecture. This is the traditional way of programming with storyboards which requires mostly applying MVC pattern and you can use UIKit with clean architecture implementation which looks like dry coding without storyboards (visual representation of pages in the device). This way of programming is better (in my opinion) because you can better understand what is going on in the code when you merge in git or resolve conflicts. The only thing that is a little odd is because you need to build your project to see changes.
The other similar way that I have already mentioned above is SwiftUI which combines these two options. You can write only code without storyboards, but you can check changes (visually) in the preview window in the Xcode.
Model-View-Controller is one of the building blocks of Cocoa packages.
The three roles are:
Model – The objects that hold your application data and define how to manipulate it.
View – The objects that are in charge of the visual representation of the Model and the controls that user can interact with.
Controller – is the mediator that coordinates all the work.
The project structure with MVC in use.
Model-View-ViewModel is a structural design pattern that separates objects into three distinct groups:
Models – hold the application data. They are usually structs or simple classes.
View – display visual elements and controls on the screen.
View models – transform model info into values that can be displayed on the view. They are usually classes.
It is the conceptual application architecture for scale and can be simply described as an onion layered architecture. It can be split into VIPER and RIB’s implementations.
VIPER stands for the View, Interactor, Presenter, Entity, and Router. Those are the building blocks of that architecture. RIB’s stands for Router, Interactor, Builder.
Builder is responsible for fetching or creating dependencies for the interactor, router, and view/presenter and initializing them.
The router is responsible for navigating to specific children RIB’s.
Interactor is responsible for all the business logic.
The presenter and the view are typically combined in a view controller where the presenter is responsible for formatting data and display in the view.
The view is responsible for displaying data on the screen and collecting user input.
The other design patterns that can be in use are SIngleton, Delegate, Observer …
After all of the process, you can watch some tutorials.
My favorite is from the Stanford YT channel.
A very good channel where you can find explanations is CodeWithChris.
Please check the Developer app on iOs or MacOS.
For more information and interaction with real developers, you can check the slack group – ios-developers.slack.com
Do not expect to be an iOS developer and find a job after a couple of months, the learning process is much longer. Sorry for the disclaimer 😀