App Development Recipes for iOS and watchOS

The provided text, “App Development Recipes for iOS and watchOS: A Problem-Solution Approach” by Molly K. Maskrey, offers a comprehensive guide for aspiring iOS and watchOS app developers. It covers essential aspects of the profession, beginning with career direction for software engineers, exploring options like traditional employment and entrepreneurship. The book then transitions into practical development skills, detailing how to set up Xcode, manage source code control using systems like Git, and understand development methodologies such as agile. Furthermore, it addresses critical topics like UI/UX design, working with targets and schemes in Xcode, comprehending embedded systems, publishing applications to the App Store, integrating web services and CloudKit, and implementing robust testing strategies, including unit and UI testing, alongside beta testing with TestFlight. Finally, the text presents several project-based chapters demonstrating practical applications, including converting Objective-C projects to Swift, building an Apple Watch “Coin Toss” app, creating a Home Automation project with HomeKit, and developing an external sensor interface for dance analysis.

Becoming an iOS and watchOS App Developer

App development, particularly for iOS and watchOS, involves moving beyond hobbyist coding to become a true professional in the software field. It encompasses more than just writing code; it’s about solving complex problems, having the freedom to choose work, and finding enjoyment in the process. The goal is to create a final product that is a “thing of beauty,” an “art form”.

Key Aspects and Skills of App Development: Developing an app is not a linear process; it requires a simultaneous understanding of many components. The book “App Development Recipes for iOS and watchOS” aims to guide aspiring developers through the various pieces and obstacles involved in delivering an iOS app to the Apple App Store, transforming them into capable professionals.

Key technical and process needs for app development include:

• Setting up Xcode for device installations
• Source-code control
• Development methodology
• UI/UX (User Interface and User Experience)
• Building targets
• Embedded systems
• App publishing
• Web services
• Testing
• iOS accessories

Platforms and Tools: The book focuses on iOS and watchOS platforms. Core technologies and tools for development include Xcode, Swift, and to some extent, Objective-C. Xcode itself includes built-in assistance to deal with process problems, but understanding each step is crucial for delivering work to the App Store or working at a software agency. Other specific tools mentioned are Git (for source control), Instruments (for profiling), and Balsamiq Mockups (for UI wireframes).

Challenges and Frustrations: App development can be fraught with problems and frustrations. While initial stages might go smoothly, expanding functionality often leads to issues, such as layouts breaking on rotation or looking different on a real device versus a simulator. Uploading to the App Store can also present numerous issues, creating a sense of failure. The author aims to reduce this frustration by showing that problems are solvable and by walking through common obstacles. It is important for developers to understand that they will “never be 100 percent ready” and should push their limits.

Career Paths: The book discusses three basic career paths for app engineers: employee, entrepreneur, and contractor (freelancer).

• Employee: Offers consistency and job security, with benefits and less concern for non-development aspects like insurance and client acquisition. However, it may limit project choice and involve working in open environments.
• Entrepreneur: Involves starting one’s own business, requiring proficiency in all development skills, plus business management tasks like licenses, tax filings, and investor meetings. This path offers more control but demands harder, longer hours. A strong business plan and understanding of market needs are crucial.
• Contractor/Freelancer: Sits between employee and entrepreneur roles. This can involve contract-to-hire arrangements or working through freelancing sites like Upwork. Freelancers set their rates and choose projects but still have clients as “bosses” and may experience sporadic income. Networking is a key method for finding projects.

Project Examples: The book references four major project types to illustrate development concepts:

• Code Conversion: From Objective-C to Swift, exemplified by an old slot machine game.
• Apple Watch Development: A simple coin-flipping game.
• Home Automation: Using Apple’s HomeKit framework, like controlling a disco ball with an iPhone.
• External Sensor Interface: Connecting to and displaying data from hardware accessories via Bluetooth Low Energy (BTLE), for instance, monitoring a dancer’s foot movements.

Author’s Philosophy: The author, Molly K. Maskrey, emphasizes finding passion and fun in mobile development, believing it’s key to happiness in a career. She encourages developers to adapt to the fast-paced, ever-changing Apple ecosystem with new devices, frameworks, and tools. Her personal experiences, including work in embedded systems and iOS accessory development, drive her focus on helping aspiring developers overcome common frustrations and make a meaningful impact through their work. She recruited friends, who were new to app development, to experience common issues first-hand to make the book more practical.

Professional iOS and watchOS App Development Guide

App development for both iOS and watchOS moves beyond basic coding to a professional field, focusing on solving complex problems and creating a final product that is considered an “art form”. The “App Development Recipes for iOS and watchOS” book aims to guide aspiring developers through the various components and challenges involved in delivering an iOS app to the Apple App Store, helping them become capable professionals [i].

Key Aspects of App Development (General to iOS/watchOS): Developing an app requires understanding many components simultaneously, rather than a linear process. Essential technical and process aspects include:

• Setting up Xcode for device installations: This is crucial for creating and testing apps on actual devices, not just simulators. Xcode includes built-in assistance for process problems, but understanding each step is vital for delivering work to the App Store or working at a software agency. Chapter 3 details this setup, including developer certificates, app IDs, and provisioning profiles.
• Source-code control: Tools like Git (integrated with Xcode) and SVN are used to protect code, track changes, and revert to earlier versions, especially important for team projects.
• Development methodology: Understanding agile processes like Scrum and Extreme Programming (XP) is key for working in modern software companies.
• UI/UX (User Interface/User Experience): This involves designing the app’s visual appearance and ensuring an intuitive and easy-to-use experience for the user.
• Building targets and schemes: Targets specify the product to be built, while schemes define how Xcode builds that target (e.g., run, test, profile, archive).
• Embedded systems and iOS accessories: iOS devices themselves are embedded systems, and development can involve interfacing with external hardware via various connections like Lightning, Bluetooth Low Energy (BTLE), or even the headphone jack.
• App publishing: This involves configuring the app, creating archives, and using the iTunes Connect portal to submit the app to the App Store.
• Web services: Essential for apps needing to send and receive data from the Internet, using methods like RESTful services or Apple’s CloudKit framework.
• Testing: Critical for ensuring app functionality, covering unit testing, UI testing, and beta testing (often using TestFlight).

watchOS Specifics: watchOS development often involves a three-target structure: the iPhone app, the Watch app itself, and the Watch App Extension.

• Architecture: The iPhone app handles connection and setup for the Watch. The Watch app provides the UI, while the Watch App Extension contains the logic. With WatchOS 2, the extension now runs natively on the Watch device, unlike WatchOS 1 where it ran on the iPhone.
• Limitations: The Core Bluetooth framework, crucial for sensor communication, is not available for Watch hardware directly, necessitating the iPhone as an intermediary for data transfer via the Watch Connectivity framework.
• Key Functions: awakeWithContext and willActivate are important functions for initialization and setting up timers or checking sensor status, similar to viewDidLoad in iOS apps.
• User Interface and Feedback: Watch apps can provide visual indications and haptic (vibration) feedback through the Apple Watch’s taptic engine, useful for subtle notifications during activities like dancing.

Development Challenges and Philosophy: App development can be frustrating due to layouts breaking, differences between simulators and devices, and numerous issues during App Store submission. The author emphasizes reducing this frustration by showing that problems are solvable and by walking through common obstacles. Developers are encouraged to adapt to the fast-paced Apple ecosystem with its frequent new devices, frameworks, and tools. The author believes that finding passion and enjoyment in mobile development is key to a fulfilling career.

Project Examples in the Sources: The book references several project types to illustrate concepts:

• Code Conversion: From Objective-C to Swift, exemplified by an old slot machine game.
• Apple Watch Development: A simple coin-flipping game.
• Home Automation: Using Apple’s HomeKit framework, like controlling a disco ball with an iPhone.
• External Sensor Interface: Connecting to and displaying data from hardware accessories via BTLE, such as monitoring a dancer’s foot movements.

Becoming a Professional Software Engineer

Software engineering, in the context of the provided sources, involves moving beyond a hobbyist level to become a professional in the field of software. It encompasses solving complex problems, offering the freedom to choose when and where to work, and ideally, being a fun endeavor. The author’s goal is to help aspiring app developers become the kind of professionals she would choose to work with. A career in software development is described as well-paying and challenging, with opportunities to make an impact and derive personal satisfaction.

Here’s a discussion of software engineering based on the provided sources:

I. Defining Software Engineering Software engineering, as discussed, is about creating and deploying software products, often focusing on iOS and watchOS applications. It involves the entire process from conceptualization to deployment and maintenance, requiring a blend of technical skills and an understanding of human processes. The author emphasizes that while many resources teach coding basics, this book aims to cover the “other pieces” of app development that are not typically found in introductory material, such as confronting obstacles and working towards a successful conclusion. A key goal is to reduce the frustration developers often experience when things fall apart beyond simple “Hello, World!” apps.

II. Career Paths in Software Engineering The sources outline three primary career paths for iOS software engineers:

• Employee: This is the most common path, offering a steady paycheck, benefits (like insurance and vacation), and a consistent work schedule, typically at an office location. Employees often work in open environments, grouped by department, fostering teamwork and immediate assistance. The author notes that while overt discrimination is less common now, women in technology may still be outnumbered, but their quality of work can make them integral to the team. It is important to assess working conditions and the potential boss when interviewing.
• Entrepreneur: Starting one’s own software business, whether self-funded or through angel/venture capital, offers excitement and exhilaration. This path demands a comprehensive understanding of business, including creating a business plan and performing a SWOT (Strengths, Weaknesses, Opportunities, Threats) analysis. Entrepreneurs must manage stress, decide on a work location (home or business incubator), and take on all business management details in addition to development work. UI/UX design, app publishing, and thorough testing become paramount responsibilities.
• Contractor/Freelancer: This role falls between an employee and an entrepreneur. Contractors might work on a contract-to-hire basis, offering a trial period for companies and potentially higher hourly rates. General freelancers can set their own rates and choose projects, often through online platforms like Upwork. Networking is crucial for finding work assignments. While some business details might be offloaded to agencies or platforms, freelancers still need most of the skills required of an entrepreneur.

III. Development Methodologies Software engineering relies on various methodologies to guide the development process:

• Waterfall Development: This traditional, sequential approach treats software development like a manufacturing or construction process, moving through distinct phases: requirements analysis, design, development, testing, deployment, and maintenance. It is highly disciplined, with defined start and end points for each phase, and emphasizes detailed up-front planning and documentation. While it improves quality by catching flaws early, its rigidity in adapting to changing requirements makes it less suitable for dynamic software projects, though still used in large government contracts.
• Lean Manufacturing: Originally for physical products, this iterative method focuses solely on solving a customer’s problem. It involves rapid creation of Minimum Viable Products (MVPs) and well-designed tests to validate features against customer needs, aiming to drive waste out of the product development and ensure profitability. Each “failure” in a test is considered a valuable lesson, ideally occurring early in small experiments.
• Agile Development: An iterative and collaborative approach where everything evolves over time. It emphasizes quick development cycles and continuous feedback.
• Scrum: An agile project management methodology that applies empirical control through transparency, inspection, and adaptation. Teams work in short iterations called “sprints” (usually 2-4 weeks). Key roles include a Product Owner (customer representative), Scrum Master (facilitator removing roadblocks), and a self-organizing team.
• Extreme Programming (XP): This agile software development methodology focuses on engineering practices to deliver high-quality software. Core practices include Test-Driven Development (TDD), where unit tests are written before functional code, and Refactoring, which involves reusing and improving existing code. User stories, customer-written descriptions of desired system behavior, are also a key part of XP.
• Functional Design: A design approach where a problem is coded as a series of functions called from a master program. This is common in embedded systems where minimal code size and efficiency are critical, often without an intervening operating system.
• Object-Oriented Design (OOA/OOD): A widely used design approach in modern software, where systems are defined using objects, classes, properties, methods, and inheritance. While common in iOS development, it generally creates larger software images due to the need for an operating system to manage object interactions.

IV. Key Skills and Tools for Software Engineers The sources highlight several essential technical and process skills for iOS software engineers:

• Setting Up Xcode for Device Installations: Essential for testing apps on actual iOS hardware and distributing them to the App Store. This involves joining the Apple Developer Program, obtaining developer and distribution certificates, setting up app IDs, registering devices, and creating provisioning profiles. Xcode offers automation, but understanding the manual process is crucial for troubleshooting, especially with beta versions. Transferring development credentials between computers is also a key skill.
• Source-Code Control: Crucial for protecting intellectual property, tracking changes, and allowing reversion to earlier versions. Git is the de facto standard for iOS projects, tightly integrated with Xcode. Key operations include creating repositories, checking out/cloning projects, committing changes, and using remote repositories like GitHub. Tools like Tower offer graphical interfaces for Git.
• Development Methodology: Understanding different approaches like Waterfall, Lean Manufacturing, and Agile (Scrum, XP) is vital for working in teams and adapting to project needs.
• UI/UX (User Interface and User Experience): Critical for making a good first impression and engaging users. UI refers to the visual elements (buttons, labels, graphics), while UX encompasses the overall feel and ease of use, ensuring intuitive navigation. Information Architecture (IA) forms the backbone of UX, determining how content and actions are presented. Tools like card sorting help gather user requirements for IA. For UI design, tools range from graph paper to professional suites like Adobe Photoshop and Illustrator, or rapid prototyping tools like Balsamiq Mockups.
• Building Targets and Schemes: A target specifies the product to be built, and a scheme defines how Xcode builds that target (e.g., Build, Run, Test, Profile, Analyze, Archive). The “Archive” scheme is used for preparing apps for the App Store or beta testing. Troubleshooting issues, like a grayed-out “Archive” option, often involves checking build settings and device selections.
• Embedded Systems: iOS devices themselves are embedded systems at their core. Understanding embedded systems allows interaction with the real world beyond simulations. Hardware development can be simplified using prototyping kits like Microchip, Arduino, or littleBits. Programming for embedded systems often involves C-style languages without a full operating system, focusing on efficient processing loops and interrupt handlers. This knowledge is particularly valuable when developing iOS accessories.
• App Publishing: The process of placing an app for sale or distribution in the Apple App Store or privately for enterprises. This involves creating an archive, validating it, and uploading it through the iTunes Connect portal. The app undergoes various tests (performance, crash, Human Interface Guidelines compliance) before approval.
• Web Services: Essential for accessing external information from the Internet (“the cloud”).
• Classic Web-Service Access Mechanisms: Utilize RESTful services and HTTP methods (GET, POST, PUT, DELETE) for communication. This approach is versatile for multi-platform solutions, often involving XML or JSON data formats with server-side scripting like PHP and databases like MySQL.
• CloudKit: Apple’s proprietary framework for accessing iCloud servers, limited to Apple devices, offering an easier way to handle data storage and retrieval for homogeneous Apple ecosystems.
• Testing: Integral to ensuring app quality and functionality.
• Unit Testing: Focuses on testing the smallest individual components (units) of an application, typically functions or methods. XCTest is Xcode’s testing framework used for this purpose.
• User Interface (UI) Testing: Allows interaction with UI elements to validate their properties and state. Integrated into Xcode 7, it supports recording user actions to automate test creation.
• Beta Testing: Involves distributing pre-release versions of an app to actual users for feedback. TestFlight, integrated with Xcode and iTunes Connect, facilitates managing internal (team members) and external testers. External testing requires Apple’s review before distribution.
• iOS Accessories: External hardware devices that connect to iOS devices. Connections can be wired (Lightning connector) or wireless (Bluetooth 2.1+EDR, Bluetooth 4.0 Low Energy/BTLE, Wi-Fi, headphone jack). The Apple MFi (Made for iPod/iPhone/iPad) program is required for Lightning and standard Bluetooth connections. Uses range from point-of-sale systems to sports monitors, home automation, and medical devices. Frameworks include EAAccessory Framework for MFi devices (using NSInputStream and NSOutputStream) and Core Bluetooth for BTLE devices (using CBCentralManager for “central” role and CBPeripheral delegates for “peripheral” role). iBeacons are an example of BTLE technology used for targeted information.

V. Projects and Practical Application The book integrates these concepts through practical projects:

• Swift Conversion Project: Converting an older Objective-C slot machine app to Swift, highlighting the differences and challenges in language porting.
• Coin Toss Project: Developing a simple Apple Watch game, illustrating WatchOS development, including handling multiple targets (iPhone app, Watch app, Watch app extension) and graphics.
• Home Automation Project: Using Apple’s HomeKit framework to control a smart plug (e.g., for a disco ball), demonstrating interaction with HomeKit-certified accessories and the hierarchical structure of HomeKit.
• External Sensor Interface Project: Interfacing with a Bluetooth Low Energy (BTLE) sensor (e.g., for ballroom dancing foot orientation) using Apple’s Core Bluetooth framework, showcasing the communication flow between an external device, an iPhone, and an Apple Watch.

VI. Challenges and Philosophy The author acknowledges that software development is “fraught with problems, frustrations, and eventual fixes”. Common frustrations include difficulties with Xcode setup, unexpected errors during app submission, and issues with continuous integration. The book’s philosophy is that problems are solvable and that perseverance is key. The author encourages developers to adapt to ever-changing technologies and industry standards, and to find passion and fun in their work to make it a rewarding career. Networking and proactive learning are emphasized as vital for career advancement.

iOS Engineer Career Paths

The sources discuss three primary career paths for app engineers, particularly iOS software engineers: Employee, Entrepreneur, and Contractor/Freelancer. Each path offers distinct advantages and disadvantages, and individuals must weigh these factors when planning their future.

Here’s a discussion of each career path:

1. Employee

This is the most common career track for individuals developing software skills.

• Work Environment & Benefits: As an employee, you typically receive a salary, benefits such as insurance and vacation, and work a more or less consistent schedule (e.g., 9 to 5). Work is usually performed at an office location, which can range from a modern, “hip” part of town to industrial complexes. Many companies offer perks like public transit passes. Software teams often work cooperatively in open environments, grouped by department (e.g., iOS developers with other iOS developers), which can foster creativity and teamwork.
• Challenges: The “lure and romance” of working in big companies can wear off. While overt discrimination against women in technology has decreased in recent years, women are often outnumbered in development teams (e.g., 26% of professional computing occupations were held by women in 2014). Engineers might work frequent overtime in competitive environments. Job postings or recruiters’ promises should be approached with a skeptical mind. Dealing with a demanding manager or invasive workplace culture (e.g., calls during off-hours) can be intolerable.
• Skills Needed: A job with an established software company requires a basic set of tools covered in the book, extending beyond introductory material. Key technical and process skills include setting up Xcode for device installations, source-code control (Git is explicitly called out), development methodology (Agile Scrum is common), UI/UX understanding, building targets (especially continuous integration), understanding embedded systems, app publishing, web services, and testing. Employers expect you to know how to build an iOS project from Xcode to a device. Familiarity with terms like REST, XML, JSON, and PHP for web services is crucial. For testing, while unit testing skills are good, beta testing is often handled by an integration and test department in larger companies.
• Finding a Job: Networking is considered the “number one way” to secure a position. Attending meetups and engaging with people, offering help, and having a concise “elevator speech” are recommended. Maintaining an up-to-date LinkedIn profile focused on professional interests and seeking recommendations are also important. Relying solely on job-listing sites or talent-acquisition agencies is not advised. Local employment resource offices can also be valuable, often listing jobs first and providing support for training.
• Mindset: The author emphasizes that “you’re never going to be 100 percent ready” and encourages aspiring developers to “do it anyway” and “just get started”. Passion for the position can sometimes outweigh specific certifications. Adaptation is key in the fast-paced, ever-changing world of mobile technology, with new devices and frameworks constantly emerging.

2. Entrepreneur

This path offers the excitement and exhilaration of starting your own business but comes with significant stress.

• Getting Started: There is no single correct way to start a business. It is highly recommended to create a business plan to avoid jumping into execution without planning. A business plan should define the problem the business is solving, its market, and execution strategy. A SWOT (Strengths, Weaknesses, Opportunities, Threats) analysis can help assess key aspects. Businesses can be consulting-oriented (developing code to customer specifications) or product-oriented (selling your own technology/app).
• Funding & Operations: Unless you have free capital, seeking investors is an option, which requires a great idea and a business plan. Consulting businesses might find it hard to attract investors. A critical concept in startups is “runway,” which is the length of time a business can operate based on its cash and burn rate.
• Work Location: While working from home saves costs (gas, wear and tear), it can lead to isolation and lack of community. Business incubators offer a solution by providing rented spaces (desk to full office), amenities (WiFi, snack bar, business address), and a sense of community, fostering collaboration and connections. Some incubators also provide business/marketing advice, technical support, and funding connections.
• Skills Needed: Entrepreneurs need all the skills required of an employee, plus business management responsibilities. Key skills highlighted as more important for entrepreneurs include Xcode setup (on a per-project basis), UI/UX design (as first impressions are critical), app publishing (responsible for getting apps into the store and passing Apple testing), and thorough testing (unit, UI, and beta testing) to avoid negative reviews. Hardware engineering background makes accessories development easier.
• Mindset & Rewards: Starting your own company means taking on far more responsibility, often leading to longer hours. Stress management is crucial, and anticipating potential stressors through planning can help. The rewards are also higher, as you manage the business and direct its course, keeping a larger percentage of the revenue compared to a salaried employee or contractor.

3. Contractor/Freelancer

This option serves as a bridge between being an employee and running your own business. Freelancers are self-employed and not committed to a specific long-term position.

• Types:Contract-to-Hire: Companies try you out for a period (e.g., a few months) before offering a permanent position. This often means higher hourly pay but no benefits like vacation or insurance. Contractors generally follow company rules but may have more flexibility in their work schedule.
• General Freelancer: You choose the projects you want and work directly for clients. Payment can be in cash, products, or services (bartering).
• Finding Work: Networking is the “absolute best method” for finding projects. Freelancers often form loosely coupled networks to share tips, ideas, and projects. Online freelancing sites like Upwork allow customers to find project-based talent and allow freelancers to list their specialties and rates. Temporary agencies in larger cities can also provide work, particularly for short-term events.
• Skills Needed: Freelancers need most of the same skills as entrepreneurs, as they effectively run their own business but offload some details to agencies or websites. Xcode setup, source control, UI/UX design, target building, and web services are generally of similar importance to employees. The importance of app publishing can be similar, as clients might expect it, but testing may depend on the client’s needs. Agile methodology might be less critical if working alone, but general adaptability is always important.

In summary, regardless of the chosen career path, continuous learning, adaptability to new technologies (like Apple’s frequent updates), effective problem-solving, and strong networking skills are crucial for success in iOS development.

iOS Project Management: Methods and Tools

Project management in software development, particularly for iOS apps, has evolved significantly, moving from traditional rigid approaches to more flexible, iterative methodologies. The sources discuss several key methodologies, along with essential tools and concepts that support effective project management.

Development Methodologies

Traditionally, software development, like hardware projects, followed a Waterfall methodology. However, more recently, Lean Manufacturing and Agile methods, including Scrum and Extreme Programming (XP), have become prevalent due to their adaptability and focus on customer needs.

1. Waterfall Methodology

The Waterfall model views the software development process as a steady, sequential flow through distinct stages, much like a manufacturing or construction process.

• Phases:
• Analysis of Requirements: This crucial initial phase involves gathering customer needs, defining the problem the product will solve, and understanding constraints and functions. The outcome is typically a formal requirements document.
• Design: In this stage, the hardware and/or software architecture, components, interfaces, and data structures are documented to satisfy the requirements. This includes choosing tools and creating strategies for issues like exception handling.
• Development: The product is actually built by a team of engineers, programmers, and designers according to the design specifications. Source and version control are critical here.
• Change Management: A formal Change Control Board (CCB) reviews and approves, denies, or modifies change requests, which can be arduous due to the linear nature and traceability requirements of the methodology.
• Testing: Near the end of development, individual components and the integrated system are tested against requirements. This includes unit, system, and acceptance testing, often conducted by an independent Quality Assurance (QA) team.
• Deployment: The tested and reasonably bug-free app is made available to its intended market, either through the App Store or via enterprise distribution.
• Maintenance: Modifications are made to the system after deployment, either due to customer change requests or defects found during live use, resulting in new product releases.
• Advantages: The staged development enforces discipline, with clear start and end points for each phase, aiding project tracking. Emphasizing upfront requirements and design aims to minimize wasted time and effort, and can improve quality by catching flaws early. It also aids knowledge transfer across dispersed teams.
• Disadvantages: The biggest issue is that customer requirements often change during a project, making the rigid, upfront approach unrealistic. This model is generally recommended only for stable projects or when contractually required, such as in large-scale government software development.

2. Lean Manufacturing

Lean manufacturing is an iterative product development and testing method that singularly focuses on solving a customer’s problem.

• Key Concepts:
• Minimum Viable Products (MVPs): Through rapid creation of MVPs and well-designed tests, any feature that cannot be proven to solve a customer’s problem is eliminated.
• Customer Focus: The emphasis shifts from the innovator’s dream to what a customer will actually use and buy.
• Failure as Learning: Each test, even if it “fails,” provides valuable lessons, and it’s better to fail early in tiny experiments than during a major product launch.
• Riskiest Assumption First: It’s crucial to solve the most critical problems at the start, as other tests become meaningless if the core problem isn’t addressed.
• Distinction from Agile: While lean manufacturing targets developing a marketable product that returns profit, Agile processes primarily focus on the development of the product itself once the client has decided what needs to be built. Lean helps determine what to build, while Agile focuses on how to build it efficiently.

3. Agile Methodologies

Agile methods are iterative and collaborative, where everything evolves in a cooperative environment. Teams are supposed to be self-organizing and cross-functional, though in practice, basic management infrastructure often remains, and Agile “loosens” it up. Two prominent sub-classes are Scrum and Extreme Programming (XP).

• Scrum:
• Definition: Scrum is an Agile project management methodology that applies empirical control to the software development process, requiring transparency, inspection, and adaptation.
• Principles:
• Transparency: Every part of the development process is open and observable to all team members, fostering direct collaboration (e.g., product backlog, task boards, daily standups).
• Inspection: Work flow is continuously evaluated by the team in a productive, non-threatening manner.
• Adaptation: Knowledge gained from inspection is used to make incremental improvements to the process, allowing for design and development efforts to adapt for the overall good of the project.
• Roles: Scrum teams include domain experts, functional analysts (though this role is slowly being absorbed by developers), solutions architects, and software engineers. A Scrum Master facilitates the process by removing impediments, ideally remaining least visible.
• Process:

1. Product Owner (customer representative) creates a prioritized backlog (wish list of tasks).
2. During sprint planning, the team selects tasks from the backlog to form a sprint backlog.
3. The team completes work within a fixed sprint duration (typically two to four weeks), with daily Scrum meetings to assess progress.
4. The Scrum Master keeps the team focused and removes roadblocks.
5. Completed tasks should ideally be shippable at the end of a sprint.
6. The sprint concludes with a sprint review and retrospective to evaluate and plan for the next sprint.
7. The process repeats.

• Summary: Scrum focuses on small, manageable, quantifiable tasks, with clear outcomes deliverable to the customer for inspection and review.
• Extreme Programming (XP):
• Definition: XP is an Agile software development methodology focused on engineering practices that deliver quality software.
• Practices: Key practices include:
• Test-Driven Development (TDD): Unit tests are created based on requirements before functional code is written, enabling automatic evaluation.
• Refactoring: Reuse of existing, working code with small changes to improve readability, reduce complexity, and enhance maintainability.
• User Stories: Customer-written descriptions of needed system functionalities, used for planning and time estimates.
• Relationship with Scrum: XP provides the process for creating software in an Agile way, which can then be managed as a Scrum project. They are not mutually exclusive and often go hand-in-hand.
• Functional Design vs. Object-Oriented Analysis/Design (OOA/OOD): These are design approaches, not methodologies. Both can be used within either Agile or Waterfall. Functional design structures code as a series of callable functions, often used in embedded systems with limited memory and no operating system. OOA/OOD, more common today, structures code around interacting objects and classes.

Supporting Project Management Tools and Concepts

Beyond methodologies, several technical tools and practices are integral to project management in app development:

• Source-Code Control: Essential for protecting the investment in developing an application and for managing changes, especially in team environments.
• SVN (Apache Subversion): An older system, still found in some companies, tailored for multiple developers working on web projects. It provides reliable source control with atomic operations and version history for files.
• Git: Has become the de facto standard for iOS projects due to its tight integration with Xcode. Git allows developers to clone the entire project database, commit changes, create branches for experimentation, and merge successful changes back into the main branch. Tools like Tower offer graphical user interfaces (GUIs) for Git.
• Xcode and Git Integration: Xcode tightly integrates Git tools, making it easy to create Git-managed projects, modify code, commit changes, and upload to remote repositories like GitHub.
• Continuous Integration (CI): This process streamlines testing and distribution, especially when multiple developers work on projects concurrently. CI systems (e.g., Jenkins, Travis, Apple’s bots) automatically integrate all developer changes into a single build, identify issues early, and automate testing. “Breaking the build” is a common term for when an engineer’s code causes problems in the integrated suite.
• Targets and Schemes (Xcode): These are Xcode-specific constructs for managing the build process:
• Targets: Define the product to be built and the instructions for building it (e.g., an app, a unit test bundle, a Watch extension). Multiple targets can exist within a single project, but branches in source control are preferred for testing different ideas.
• Schemes: Define what happens when a target is built or run. Options include simple build, build-and-run, test, profile (for performance analysis), and archive (for App Store submission or distribution).
• App Publishing (iTunes Connect): This is the portal for developers to sell and distribute iOS and Mac applications. It allows managing portfolio content, legal/tax documents, and sales progress. While larger agencies might have a separate distribution department, entrepreneurs and freelancers will need to know this process. The process involves creating archives in Xcode, validating them, and submitting them through iTunes Connect.

In essence, successful project management in iOS development requires not only understanding these methodologies and tools but also cultivating adaptability in a rapidly changing technological landscape, where new devices and frameworks constantly emerge.

By Amjad Izhar
Contact: amjad.izhar@gmail.com
https://amjadizhar.blog

Affiliate Disclosure: This blog may contain affiliate links, which means I may earn a small commission if you click on the link and make a purchase. This comes at no additional cost to you. I only recommend products or services that I believe will add value to my readers. Your support helps keep this blog running and allows me to continue providing you with quality content. Thank you for your support!