From Zero to App Store

Introduction

From Zero to App Store
1 Introduction 03:31
2 Defining a Minimum Viable Product 06:53
3 Setting Up the Project Plus 10:30

From Zero to App Store is a series that journals the development of Cocoacasts for iOS and tvOS. With this series, I aim to offer a look inside the workflows and processes I use to build and ship software. This series aims to touch every aspect of mobile software development, including source control, continuous integration, release management, and App Store deployment. It goes well beyond writing code.

This series has two objectives. The first objective is offering a comprehensive mobile software development workflow. You can find information about every aspect of software development, but it's often unclear how the numerous pieces fit together. This series aims to offer an overview of mobile software development. By using Cocoacasts as the subject, you have an example you can use and relate to.

While this series doesn't cover anything unique, it shows how to start with an idea and end up with a product in the App Store. The goal is to build a native, mobile client for the Cocoacasts website and, at a later point, add support for tvOS.

The second objective is more personal. Every developer has its own way of working. From Zero to App Store shows how I build and ship software. How I work isn't unique and I don't claim that it's the best or only way to create software. But it works and it has helped me build and ship software for many years. There's always room for improvement, though, and I learn something new every single day.

One of the most common questions I receive has the following format "How do you (fill in the blank)?" I know how useful and insightful it can be to take a peek behind the curtain. That's what this series offers.

What Is Covered?

The topics I plan to cover in this series include:

  • setting up a project
  • putting a project under source control
  • setting up a continuous integration solution
  • adopting a testing strategy
  • caching data to improve performance
  • managing dependencies using CocoaPods
  • fetching data from a remote API
  • deploying an application to the App Store
  • scheduling and managing releases
  • implementing push notifications
  • reactive programming
  • using the coordinator pattern
  • adopting the Model-View-ViewModel pattern
  • and much more

This series is a living journal that will evolve over time. There's a central storyline, building Cocoacasts for iOS and tvOS. Some of the topics are covered in more detail in several miniseries.

What Is Not Covered?

An aspect I won't cover in much detail is the implementation of the backend the application communicates with. The Cocoacasts API and website are powered by Ruby on Rails. Since Cocoacasts focuses on Swift and Cocoa development, I won't spend much time discussing the inner workings of the Cocoacasts API.

What's Next?

I'd like to kick the series off with a topic that's often overlooked, defining the scope of the first version or the minimum viable product. It's tempting to include too many features in the first version of a product and that often leads to delays and missed deadlines. That's something I want to avoid.

Next Episode "Defining a Minimum Viable Product"