A developer's responsibilities

Before we get into anything too technical, let's go into a little detail about what an iOS developer does. It's obvious that we'll be doing a lot of coding, but that's not the whole story! As a developer, you might be responsible for many different technical aspects of a project depending on the team structure, which we'll get into shortly. But for now, we'll take a look at the general items that end up on a developer's to-do list.

Note

As we walk through the next few sections, don't be alarmed if you find yourself a little lost. Everything discussed here is explored in much more detail in this book, but for now we're going to jump right in and learn through immersion. By introducing you to terms in a meaningful context, you should hopefully have a good idea of how they relate to each other before we explore them individually.

Pre-production

Every project starts with an idea; that's the easy part. Unfortunately, you're not the idea person, but the one in charge of execution. In the pre-production phase of a project, your responsibilities are to take an idea and translate it from wishful thinking into a plan of action.

The first thing that usually happens after brainstorming is that you'll write out a list of features that the application will have. Using your programmer's point of view, you want to break down the idea into all of the technical components that you can.

As you become more experienced it will become easier to know what to plan for, but as a general rule of thumb you will only want to focus on the core features of your app here. What features are needed for a minimum viable product? Again, experience here will help you figure out how deep you should go into your plan, but once you have a good idea of what you will be doing, it's time to move ahead.

Project setup

Now, before you can even write one line of code, you first have to set up your development environment. For most projects, this means creating a new Xcode project and setting up your preferred method of source control.

When setting up a new project, it's important to refer back to the technical plan you made during pre-production to help inform your decisions. Are you going to be using any of the Xcode project templates? Where will your repository be located? Is there anyone else on the team that needs access to the source code? Does the app need any services enabled? Are there pre-existing code libraries that you need to import for your project?

It will be your job to make sure that Xcode and any other necessary tools are configured properly and optimized for the job ahead. Once you've got all of the setup out of the way, it's finally time to start writing some code!

Development

When the application is in active development, it is your time to shine. In this phase you'll be having the most fun, but you'll also have the most responsibilities.

When developing an application, you'll be writing code to handle both the data model and the user interface of the program. You'll also be using storyboards in Xcode to layout the screens of an application. A lot of your time will be spent with these two tasks to create new view controllers that add or change features in your app.

In addition to building the software, you will need to do routine project maintenance. This means that you should be frequently checking in with source control and reviewing other programmers' code additions. You will also be writing unit tests to make sure your code is functioning as expected. On top of all of that, you will be debugging and optimizing your code.

While development can take weeks, months, even years to get to a finished state, the market can't wait that long! Usually, once your app has all of its core features implemented and tested, you will polish it up and release it to the world to get feedback.

Deployment

When a new feature is complete, or when a predetermined milestone is hit in a project, you need to then get your app into the hands of people who actually want to use it!

For you, this means several things. First, you'll want to create a release build of the application that removes any debug features that an end-user doesn't need. Then you'll be responsible for packaging that build up and putting it somewhere that others can access it; if you're still beta testing, a platform like TestFlight might make sense, or if you have a finished, tested build, it's time to get ready for the App Store.