Basic Process Phases for an iOS App

By Rajiv Ramnath

To understand how to design processes in iOS, you must understand process phases, which are a high-level categorization of process activities organized by common intent. Many of these activities involve object-orientation.

Here are the phases and their relationship to object-orientation:

  • Requirements identification: This is the phase where you identify some of the who — the people affected by the software, such as users, the sponsor, and so on — some of the why — the problem to be solved and the business case — and the what — the features of the solution.

  • Analysis: Analysis is all about understanding, as opposed to solving, aspects of the project and the software. This understanding needs to happen at multiple levels.

    • Domain analysis seeks to understand the environment in which the software will operate (such as your home, your kitchen, your likes and dislikes, and your needs in terms of food, and even potentially various kinds of cuisines).

    • Problem analysis tries to understand and characterize a specific problem in the domain (such as your difficulty in remembering and properly following recipes).

    • Solution analysis tries to understand how a proposed solution (such as a recipe program) might actually solve your problem.

    • Object-oriented analysis is the application of OO to analysis. In domain analysis, you might identify objects and their interactions in the domain; in problem analysis, you might identify objects and describe their interactions in the problem you’re trying to understand; and in solution analysis, you might describe how the system works in terms of interactions between external objects (or actors) and the system.

  • Architecture and design: Architecture and design taken together make up the phase where you determine the overall structure of the system and the design, which is what the individual components of the system are, all the way to the smallest granularity and how everything works together.

    Architecture is also the description of the high-level components of the system and how they interact at a component level. Architecture rarely concerns itself with what is inside a high-level component.

    It’s hard to discern what is architecture and what is design. Think of architecture as consisting of those design elements that are hard to change once put in place, such as programming framework (iOS), choice of database, and the major components of the system. Object-oriented design is the identification and definition of the classes that make up each component of the system and a description of how these classes interact.

  • Implementation: Implementation is the phase where the rubber meets the road, and you actually write and run the code that makes up the system. When you use OO languages in your implementation, the implementation is known as object-oriented programming.

  • Testing: Testing is the phase where you check whether the system actually works. Object-oriented testing can take place at the level of individual classes, at which point it’s called unit testing; after the classes and components are put together, where it’s called integration testing; or at the level of the entire system or program, where it’s called system testing. Developing production software involves all these levels of testing.

  • Deployment: Deployment is the phase where you actually put the program to work. For commercially available iOS apps, deployment starts with putting the app on the Apple Store and continues to when a user installs and runs it on an iOS device.

  • Maintenance: Maintenance is the phase where you keep the system working and useful as needs evolve by modifying the structure of the classes and the interactions between objects of these classes.

  • Project management: This is the phase where you plan, organize, resource, lead, control, and coordinate. Project management consists of the steps needed in the overall monitoring and control of the process and project.

However, note that the preceding phases of the software lifecycle are groupings of activities clustered around a common intent. The phases are not steps done in a particular order.