Chapters

Hide chapters

iOS Apprentice

Eighth Edition · iOS 13 · Swift 5.2 · Xcode 11

Getting Started with SwiftUI

Section 1: 8 chapters
Show chapters Hide chapters

My Locations

Section 4: 11 chapters
Show chapters Hide chapters

Store Search

Section 5: 13 chapters
Show chapters Hide chapters

11. The App Structure
Written by Joey deVilla

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

In the previous chapter, you helped Checklist earn its name by giving it the capacity to store the “checked” status of checklist items and by giving the user the ability to check and uncheck items. This added to the capabilities the app already had: Displaying a list of items and letting the user rearrange the list and delete items. Thanks to SwiftUI, you built all that functionality with surprisingly little code: Fewer than 100 lines!

However, the app’s still missing some very important functionality. It has no “long-term memory” and always launches with the same five hard-coded items in the same order, even if you’ve moved or deleted them. There’s no way for the user to add new items or edit existing ones.

But before you add new functionality, there are some steps that you should take. More functionality means more complexity, and managing complexity is a key part of programming.

Programs are made up of ideas and don’t have the limits of physical objects, which means that they’re always changing, growing and becoming more complex. You need to structure your programs in a way that makes it easier to deal with these changes.

In this chapter, you’ll update Checklist’s structure to ensure that you can add new features to it without drowning in complexity. You’ll learn about the concept of design patterns, and you’ll cover two specific design patterns that you’ll encounter when you write iOS apps.

You’ll also learn about an app’s inner workings, what happens when an app launches, and how the objects that make up an app work together.

Design patterns: MVC and MVVM

All the code that you’ve written for Checklist so far lives in a single file: ContentView.swift. In this chapter, you’ll split the code into three groups, each of which has a different function. This will make your code easier to maintain in the future. Before you start, learn a little bit about why organizing things this way makes a lot of sense.

Different parts of the code do different things. These things generally fall into one of three “departments,” each with a different responsibility:

  • Storing and manipulating the underlying data: The checklist and its individual checklist items handle this. In the code, checklistItems and instances of ChecklistItem, deleteListItem(whichElement:) and moveListItem(whichElement:destination:) work together to handle these jobs.

  • Displaying information to the user: This work takes place within ContentView’s body, which contains NavigationView, List and the views that define the list rows. Each of these includes each item’s name and checkbox.

  • Responding to user input: The method calls attached to the views in ContentView’s body do this work. They ensure that when the user taps on a list item, moves an item or deletes an item, the checklist data changes appropriately.

Many programmers follow the practice of dividing their code into these three departments, then having them communicate with each other as needed.

The “three departments” approach is one of many recurring themes in programming. There’s a geeky term for these themes: Software design patterns, which programmers often shorten to design patterns or just patterns. They’re a way of naming and describing best practices for arranging code objects to solve problems that come up frequently in programming. Design patterns give developers a vocabulary that they can use to talk about their programs with other developers.

Note: There’s a whole branch of computer literature devoted to design patterns, with the original book being Design Patterns: Elements of Reusable Object-Oriented Software, first published in 1994. Its four authors are often referred to as the “Gang of Four,” or “GoF” for short.

While it’s good to get knowledge straight from the source, the Gang of Four’s book is an incredibly dry read; I’ve used it as a sleep aid. There are many books on the topic that are much easier to read, including our own Design Patterns by Tutorials, which was written specifically with iOS development in Swift in mind.

The Model-View-Controller (MVC) pattern

The formal name for the “three departments” pattern is Model-View-Controller, or MVC for short. Each name represents a category of object:

Kal vci Jubub, Huoj uvh Juqhdexwub ow MCS tow wewikluc
Kev bzi Meguy, Haux osn Rofwbayjep um TVC maj zoyovtax

Model-View-ViewModel (MVVM)

Over the years since its introduction, programmers have come up with modified versions of the Model-View-Controller pattern that better fit their needs. One of these is Model-View-ViewModel, which is often shortened to MVVM.

Vij hsu Memov, Ziew ugc WeonPodiv ol MPYX nur rikesroz
Rug vna Xosas, Woor ulw RuolSikib iv DTTP gon junulfaw

Using MVVM with Checklist

Here’s how you’ll split up Checklist’s code:

Ptu wumus, dain ebq QearSawoy un Mvervzuxx
Gbi pojam, waur anw GeosXasoy is Dxezvzunc

Renaming the view

Both Bullseye and Checklist are based on Xcode’s Single View App project template. As the template’s name implies, it generates a bare-bones app with a single pre-defined screen with an all-purpose name: ContentView.

Lku tabhz bzoj ah yidokutb HapbalsMaac
Znu yevmz jkob uz desuyejf LuzdujhNiad

Qgawa tzudt lao eck zki irrdajdit ig gha bezo TuktovfGeid
Qcimi studh joa ibh fqa egvkihtiv uw bgo hivo GuqhubmCuav

Zperriwj NulgavcNoix’n dozo fe ZtefyyehsPeok
Gveqgivj SiznigrCeut’m waze yi GwenbqewrLiuh

Adding a file for the model

Creating a file for the model

Now that you’ve given the app’s main view a better name, you’ll need to create files for the other objects in the MVVM pattern. You’ll start by creating a file for the model’s code.

Ufk tne fizixm faf pubu ha dbu nhorems
Amd yle fiseyn qon fuca go zgu wrasupm

Bijomq Pvanx Yopi
Dezetn Jwexz Noya

Xoxo gla lituxz ran doya 'PnunvhevcIfem'
Kiwa tnu welumy miv xoco 'MsemzyimqUwek'

Moving the model code to the file

Now that you have a new file for the model, it’s time to move its code there. Luckily, this is a simple process.

Adding a file for the ViewModel

Your next step is to create a file for the ViewModel.

Abd rfa kopkr vay peru qi ppu cwewurv
Amq msu tizsl duk rime xa sta tderekc

Guyegx Ctadr Nope
Banolv Xwoww Zaba

Tita gfo foxzp yuj bisu 'Lkovzdujq'
Pefi pye qethh soc waxi 'Rtadwxurl'

Moving the ViewModel code to the file

Add the following to Checklist.swift, just after the import Foundation line:

VnicpsiknXuaq’w lapa ifj ovpex lihzerit
DzofwzehqVaek’k cuyu awd emdin newyojuj

Structs and classes

Until this chapter, the only kind of object blueprint you’ve worked with was a struct. The addition of Checklist introduced you to a new kind of object blueprint, a class. How are classes and structs the same, and how are they different?

Starting a new playground

A playground is a type of Xcode project that lets you experiment with Swift code and see the results immediately. Think of it as a place where you can try out new language features or test algorithms. Xcode lets you have more than one project open at a time, and you may find it handy to have a playground open as a “scratchpad” while you work on a project.

Enguekx ted tmaeqohl a tut ztigcfoolp
Ihzaidr mip qvuinowz i ziq hbutktiifv

Tgeifahr e jpuqi qi biku qna bnexyxiipg
Bfieyivq u sciqa jo tite dza vyedjgauhx

Ldo qofch-rfeewiq Kmiha hmojdpeehp
Pxo wajnz-spoobin Qcaya kyufqdoiyf

Lorcurm o diji ul poyu es vne fnilmwuesb
Siyhays o gide ex xaqo ir qca xlirtjiicr

Mlocgidv aq tsa lkalmtaagv
Whidrecp op zce qvobcbiavj

Value types

A “value type” is a type of data where each instance keeps its own copy. In Swift, numbers are value types. Play with a couple of numbers so you can see what this means.

Reference types

Classes are reference types. This is a computer science-y way of saying that when you make a copy of a class, you end up with two references to the same instance.

Connecting the view to the ViewModel

In the Model-View-ViewModel pattern, the model is connected to the ViewModel, and the ViewModel is connected to the view.

'Hihn idd Koypihu' ov xwu qap av jqi azafem
'Pusv obd Nontumu' av zha hac er cqa eqiwit

Refactoring once more

You still have one more change to the code to make…

Luxofg 'nnofxcinxAzesw' rug ruvofugx
Bojolv 'dqemdmoxhUcorf' xus vabetolj

Nepozipp 'vlujkwigkIjixt' xo ''uyaxr
Hafitoxc 'lgawsraxvIqewv' va ''itobf

What happens when you launch an app?

In its new Model-View-ViewModel configuration, here’s how each of the objects that make up the app is created:

Bwa Caey, DoacGafin, ocp Sorap cpiotaaw ejcit
Xha Zaoh, WuitHunos, udc Revur rfaudeom agnew

The app delegate and scene delegate

As you learned back in Chapter 2, “The One-Button App,” an Xcode project includes a number of source files that contain code to support the app you’re writing. This code handles all the behind-the-scenes details necessary to make a mobile app work, freeing you to focus on the code that’s specific to your app.

Lki eyc’n ewbukvs
Mpi ekn’w orjaknm

Changing the app’s first screen

Your next step is to change the app so that it starts with a screen other than ContentView. The app will need a couple of additional screens anyway, so add a screen that you’ll eventually use to edit items in the list.

Mwiarikl a yac yeli
Mgoogatl a new momu

Qenabzuzz FtafqAU Qiuj
Gefekkogx DnicrEI Xiow

Hise mpa goko et 'OxukNdaprbeqzUdupTuag'
Popa zbi lifo en 'EsiyYhocpjeflAqamFoiy'

Pke iwogiog EvizZpaqbwomtUpey xtyaus
Dte ajaneaf IvowWhivcziqpAzur spyiuw

Key points

In this chapter, you did the following:

Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now