Take advantage of all the Git features and best practices to improve your daily iOS development workflow
Get the peace of mind of knowing you can experiment with your code and work with others without being terrified of arcane commands that could mess up your repository
Git is an essential tool for our work as iOS developers
You cannot do any serious development without Git, not even when working alone, unless you want to risk that simple mistakes could wipe out days of work.
Git is so ubiquitous that every developer needs to commit time to learning it, at least at a basic level. But this also means that many developers take it for granted. So, it’s not covered much in the iOS development world.
This forces iOS developers to learn Git all by themselves, almost as an afterthought. As a result, even expert developers are left browsing online resources that don’t help much. They often end up knowing only a small subset of Git’s features.
I was one of those developers.
Hi, I’m Matteo Manferdini, iOS developer, freelancer, and author.
I have used Git throughout my 15 years in iOS development, on solo projects, and working in teams with small and large clients.
I started using Git more than 15 years ago. Over time, I hacked together a superficial knowledge of a few commands. That allowed me to get by without understanding how Git works or how it is meant to be used.
Not that I cared, anyway.
I used Git only to create backups of my code instead of how it was designed
I would save my work any time I felt like it, without following any clear workflow or best practices.
For a while, it worked. I worked at a few jobs where I was mainly left alone, so it didn’t matter how I used Git or if I used it.
But software development is not linear.
Not all the code we write ends up being right. Often, our experiments fail, and we must discard them and restart from a clean slate.
That’s when I learned one of the dangerous Git commands: resetting. With that, I could easily discard all the snapshots I didn’t need and return to a stable version of my project.
That worked great until I made a severe blunder.
One day, I discarded one snapshot too many, and I lost hours of work.
If you ever made such a mistake, you know that sinking feeling. I scrambled, trying to recover my lost code, but to no avail. Since I didn’t understand how Git works, it was just an exercise in frustration.
So, after a lot of sweating, I resigned to my fate and rewrote all the code I had wiped out.
Little did I know that code is never lost in Git
There is always a way to recover from any mistake. You can’t imagine how stupid I felt when, years later, I learned how to recover any code from a Git repository. The memory of losing work is still burned into my mind ten years later.
My barebones knowledge of Git also didn’t help when I had to work with other developers
Years later, I joined a team of highly experienced developers at a big client. I was quite a knowledgeable iOS developer, but my Git skills remained flimsy.
So, when they started throwing around terms like “merge into the trunk” or “create a pull request,” I was lost. Again, I had to scramble online to fill the gaps and not look like a complete idiot.
Luckily, with time, my Git skills improved. Now, every project I work on, whether for clients, my courses, or the App Store, has a Git repository from day one.
I have a published app in the App Store with more than 10.000 lines of code. Managing that project would be a nightmare without using Git.
And even when I am the only developer working on a project, I still follow Git’s workflows and best practices because the reality is that I am constantly collaborating with at least another developer: my future self.
With time, I started taking Git for granted as other experienced developers do. Git is so fundamental that everyone surely must know how to use it. It’s like using copy and paste or find and replace in Xcode. So, I thought there was no need to talk about it.
That’s until I noticed that many of my students struggled to keep multiple copies of the code examples I provided in my courses. To my surprise, many were not using Git at all. They didn’t even know it existed.
I had to do something.
As an iOS developer, Git is not a tool you can ignore. As soon as you graduate from simple Swift exercises to a whole Xcode project, you need to start using Git, or you’ll suffer greatly and won’t even know life can be better.
That’s why I created this course.
Git for iOS Development
The practical course to fully use Git to safeguard your Xcode projects and share code with other developers without being frightened by its arcane-sounding commands.
Git can be remarkably difficult to use if you get the wrong mental model taught by many “Getting Started” guides that only teach basic commands.
Git for iOS Development covers everything you need to know about Git:
- Take maximum advantage of Git’s power. Many expert developers are afraid to admit they’re not well-versed in Git and just sort of use it. Make full use of Git’s capabilities instead of using it as a mere backup.
- Safeguard your personal projects and collaborate with others. Write new features and experiment with the confidence of never losing a single line of code. Even as a solo indie developer, Git is a lifesaver.
- Stop being terrified of messing up. Understanding how Git really works and how to fix errors will get you out of trouble should you ever make a wrong turn along the way.
- Best practices and workflows to improve your everyday work. Get better ways to achieve what you’ve already been trying to do, following best practices that help you avoid problems like merge conflicts and project corruption.
- Leverage Git’s Xcode integration and complement it with the terminal. Let the Xcode interface do the heavy lifting for you and use the terminal when Xcode fails or for advanced workflows only available at the command line.
You will quickly become productive and learn how to solve real issues instead of following random internet guides that only make everything worse.
You won’t only learn how to do things, but you’ll also understand why Git’s design made it the de-facto version control system used by hundreds of millions of developers worldwide.
Inside the Git for iOS Development system
Git, the Essential Tool of Professional Developers
Lesson 1.1 – Distributed Version Control Systems
How professional developers track changes and synchronize work
Lesson 1.2 – The One-time Git Setup
Setting your identity and editor preferences
Lesson 1.3 – Creating a Git Repository
The essential step to starting any project
What you’ll learn:
- How Git helps you track changes and collaborate with other developers. This is why Git is the de-facto version control choice for any iOS developer.
- Creating, locating, and deleting a Git repository for your projects. Plus, creating an Xcode behavior to quickly open the terminal at the correct folder using a simple keyboard shortcut.
- The Git configuration that will help you use it comfortably in Xcode and the terminal. This will help you avoid getting stuck inside Vim when using Git in the terminal.
Committing your Work in Well-Crafted Units
Lesson 2.1 – Creating Snapshots of your Work
Crafting Git commits in the staging area
Lesson 2.2 – Tracking and Committing
Adding files to the staging area and saving them to the repository
Lesson 2.3 – Atomic Commits
The best practice that improves all Git workflows
Lesson 2.4 – Keeping Files out of a Repository
Managing software settings, generated data, configuration files, and app secrets
What you’ll learn:
- The best practices to create atomic commits with conventional types and well-written commit messages. This alone singlehandedly simplifies all Git workflows, makes your history easier to browse, helps during code reviews, and makes merging more manageable.
- Using Git’s staging area to craft well-defined commits. While this is a fundamental feature of Git, it is partially hidden by Xcode’s integration.
- How the Xcode’s project and asset catalogs behave in Git commits. Once you understand how these particular files are structured internally, committing or merging changes will be easy.
- How to use build configuration files to keep information out of a repository. For security reasons, you should never save sensitive data like API keys and app secrets in a Git repository.
Shaping the History of your Repository
Lesson 3.1 – Commits and References
How Git’s non-destructive actions reshape the history of a repository
Lesson 3.2 – Following the Evolution of your Code
Exploring your repository’s history and comparing changes
Lesson 3.3 – The Amending and Resetting Workflows
How to write code naturally and still achieve perfect atomic commits
Lesson 3.4 – Building a Repository’s History Incrementally
Committing selected parts of an Xcode project file to always keep your code in a consistent state
Lesson 3.5 – The Rebasing Workflow
Fixing problems in your repository’s history without undoing important commits
What you’ll learn:
- The HEAD and branch pointers. These are the pieces that many developers miss in understanding how Git’s destructive actions are not destructive at all.
- Exploring the commit log of your repository and using Xcode to compare changes. Including the simple technique to restructure your project’s folders without losing the history of modified files.
- Using Git’s reflog to retrieve commits you think were lost forever. Many developers ignore that Git only adds information to its database, so no data is ever lost, even when you mess up.
- The amending and resetting workflows that allow you to create a clean history. You can benefit from regular work-in-progress commits to preserve your code while still creating perfect atomic commits.
- How to commit parts of the Xcode project file separately. This is a necessary technique to avoid creating broken commits.
- Using interactive rebasing to fix bad commits in your history without affecting good ones. Many developers are terrified of rebasing because they think it can create irrecoverable problems, but that is not true.
Branching Workflows for Solo Developers, Teams, and Open-Source Projects
Lesson 4.1 – Branching, Merging, and Conflicts
Git’s killer feature to coordinate parallel feature development
Lesson 4.2 – Branching Workflows
How companies and open-source projects coordinate the work of several developers
Lesson 4.3 – Trunk-Based Development
Managing release branches and disabling functionality using feature flags
Lesson 4.4 – Topic Branches in Git-Flow
Moving code across branches using the Git stash
What you’ll learn:
- How to use long-running and topic branches to develop app features in parallel. Plus, the best practices to minimize merge conflicts and simplify their resolution.
- The three fundamental Git branching workflows: Trunk-Based Development, Git-flow, and the Git maintenance workflow. These are the Git best practices used by small and large companies, open-source projects, and solo developers.
- Managing app releases with release branches and cherry-picking. Many developers ignore this Git feature, but it’s fundamental in any branching model you choose.
- How to enable and disable app functionality using feature flags downloaded from a remote API. This is the core practice used by large companies that use monorepos and continuous delivery.
- Moving uncommitted code across branches using the Git stash and how to recover when you commit to the wrong branch. Once you understand how branches behave in Git, no mistake will be unfixable.
The course is currently under development, so I am pre-selling it at a lower price. It will take me a couple of months to create the missing material.
Future modules will include:
- Git’s branching workflows to improve your app’s development and release process, both when working alone and with other developers.
- Resolving merge conflicts, including inside the dreaded Xcode project file. Plus, the best practices to minimize conflicts when working with others.
- Git’s distributed workflows to collaborate with other developers and how to use a centralized service like Github to coordinate work.
Frequently asked questions
I work alone. Do I need to use Git in my projects?
Yes, definitely. Git safeguards your code and has several benefits, even for solo projects.
- You can make changes and experiment with your code without the fear of losing work. This works much better than manually keeping multiple copies of your project.
- You can delete code you don’t need anymore, knowing that you can always get it back later if you need it again.
- Git’s branching models help you manage the development of new features, releases, and bug fixes in your published apps.
- You can back up your project using a remote service like GitHub if something goes wrong with your local copy or computer.
Can I do everything using Xcode, or do I need to use the terminal and other Git clients?
Xcode’s Git integration includes many everyday actions you must perform as an iOS developer. I cover all of them in the course.
However, some Git commands are essential for best practices and advanced workflows and are not included in Xcode. For those, you need to use the terminal. The course covers those too.
Once you understand how to use Git, you can pick a free or paid Git client that fits your workflows if you prefer to use a graphical interface.
What if I don’t know how to use the terminal at all?
Most of your interaction with Git will happen inside Xcode. And when using Git in the terminal, you only need to be familiar with a few basic shell commands, which I cover in the course.
What if I don’t know anything about Git?
The course covers Git from zero, so it’s perfect for someone that never used Git before.
What if I am already familiar with Git?
You can probably still benefit from following the course.
Many expert developers think they know Git well enough but miss essential best practices and workflows. On top of that, if you learned Git from random online tutorials, you might have the wrong mental model of how it works.
I recommend taking a close look at the course details to see if it includes something important you are missing.
Do I need to be an expert iOS developer?
No. Git is a fundamental tool that anybody can benefit from, regardless of their seniority as an iOS developer. The course shows Git’s best practices and workflows using a basic iOS app. This helps you apply concepts even if you have just started making iOS apps.
How is Git for iOS Development different from other courses?
Many books and courses about Git are generic and focus only on the terminal and Git clients you might never use. Some courses include information you might never care about, like using Git on Windows or Visual Studio.
I created Git for iOS Development specifically for iOS developers. It covers how to use Git in Xcode and the problems specific to our profession, like solving merge conflicts in the Xcode project file.
Can you show me a preview of the material in the course?
The emails you received in the past weeks are a preview of what you will find in the course. My free articles and guides will also give you an idea of the quality of my material. If at this point, you are still asking for more free material, this course is not for you.
Do I need to be in a specific location or follow the course at a particular time?
No. The course is entirely online and self-paced. You can follow it from anywhere in the world, at any time you like.
Do I have to hurry up and follow the course in a defined time frame?
No. The course is self-paced and online, and you have lifetime access. You can take your time and return to it whenever you want to refresh the concepts. It is not a live course, so you don’t have to attend a class at inconvenient times.
I am already overwhelmed. I do not want more material to study.
Every lesson in Git for iOS Development is short and to the point. The entire course is not long; you can probably go through it in a week and integrate what you learn into your daily job immediately.
What if I try Git for iOS Development and decide it is not right for me?
I stand by this course with a 100% money-back guarantee. Try the entire course for one month and decide if it is right for you. This means you can follow the whole course before deciding. If it does not give you any result, I will refund you 100% of your payment, no question asked.
Can I learn all this on my own?
Yes, definitely. After all, I learned everything by myself.
You can look online for free Git books and tutorials and integrate what you learn with Xcode. Then you can search for articles talking about best practices. When you have specific problems, you can ask questions on StackOverflow. And then, you can work with other developers and learn from them.
But why would you? I already did that and condensed everything I learned in a compact course at a competitive price. Imagine how many hours of work such a small investment can save you.
Do you offer discounts for bulk purchases for company/team access?
Yes, but not directly on this page. If you want to give your whole team or company access to the course, send me an email at email@example.com, specifying how big your team is.
Be aware that this is only for company purchases. I don’t allow individuals to team up for the only purpose of getting a discount. If you try to cheat, I will ban you for life from any of my products.
An UNBEATABLE guarantee: try Git for iOS Development for a full 30 days, more than 100% risk-free
Try the entire Git for iOS Development course. If it doesn’t help improve your day-to-day iOS development work, I insist that you get 100% of your money back, no questions asked.
On top of that, I’ll trust your honesty and let you keep full access to the entire course.
Let me tell you why I offer this unbeatable guarantee.
I extensively researched the content of this course to find the best Git workflows that will help you throughout your career as an iOS developer, both when working alone and with others.
I then complemented that knowledge with my 15 years of experience working with Git and Xcode, showing you how to apply it to the specifics of iOS development.
I am confident you will learn something new even if you know Git already. I know that because even I learned something while creating this course.
Git is a fundamental tool for any iOS developer, from beginners to experts, so I want anybody to get the benefits this course offers.
That’s why I more than guarantee Git for iOS Development.
Are there any catches to my offer? Not at all.
For my other premium courses, I usually require people to document that they followed the course to ask for a refund. But this course is so crucial that I won’t ask that to you.
So, take the course and see how it can help you.If it does not work, email me, and I will refund you 100% of your money, no questions asked. And, as a token of trust in your honesty, I will even let you keep full access to the course.
This guarantee extends for 30 days after you join, which is more than enough to go through the ENTIRE course.
If you don’t love it, email me anytime during the first 30 days, and I’ll give you your money back.
Do you need to learn Git right now?
We both know you don’t.
You can go on and use Git the way you think it should work instead of how it was designed. You can also not use Git at all in your projects.
Xcode also makes it easy to perform some basic Git actions. You can use Git superficially for several years without understanding how it works. I did that too.
That’s until things go wrong.
You lose hours of work with no way to recover them.
You need one of Git’s more arcane-sounding features that are only available in the terminal, but you don’t even know they exist.
You try some unfamiliar commands and mess up your repository.
Xcode’s integration fails and corrupts your project.
You work with other developers and need to perform tasks you have never heard about before.
In any of these cases, you will be left scrambling with online articles that, at best, don’t help much and, in the worst case, give you the wrong mental model and lead to costly mistakes.
It’s true that none of these scenarios might ever happen to you. But if you do any serious iOS development, the probability is high that at least one will happen.
And even when they don’t, you will miss out on workflows that can improve your day-to-day process, even when working alone.
The choice is yours.
You can trudge along doing what you already do.
You can wait until things explode in your face and then scramble for a solution.
Or you can learn how to use the full power of Git right now, make your life easier, and know that whenever a problem occurs, you will know how to fix it without breaking a sweat.