What is iOS Development?

iOS Development is a specialized version of mobile application development, pertaining specifically to iOS devices. iOS refers to the mobile operating system created by Apple and is what powers many of the company's devices, including the iPhone, iPad, MacOS, and iPod Touch.

iOS development includes the construction of the user interface of an app, the handling of user interactions across the app, and the management of user data throughout the app. There are a number of ways to build iOS applications but the primary one is using Swift and in the Xcode IDE. The two native primary frameworks for building iOS applications are UIKit and SwiftUI.

Why should you take this course?

With iOS capturing almost 60% of the mobile operating system market share in the United States, iOS devices have become a ubiquitous part of daily life. Every day, you use your phone to communicate with friends, navigate to places, and keep up with social media. iOS development sits at the heart of all of the apps that you use for these activities. By taking this course, you will learn how to build an application from the ground up and gain the skills to transform any application idea into a working product.

Moreover, the skills that you learn in this course are broadly applicable to understanding other front end frameworks as well. As a result, many students who have completed this course end up more prepared to recruit for internships and build out their own products.

What will you learn in this course?

In this course, you will learn all the necessary components that comprise an iOS application. We begin with an introduction to Swift, the primary programming language for iOS. Then we will move on to teaching user interface development in UIKit, showing you how to build beautiful interfaces across all iOS mobile devices and how to visually organize data in applications.

Afterwards, we will proceed with lectures on networking, teaching you how to integrate your application with backend services by pulling data from and saving data to backend services.

From then on, we will delve in SwiftUI, a completely different (but equally useful) framework for building UI. Finally, we will learn advanced functionality such as creating push notifications, setting up authentication system. To put everything together, students will work on the Hack Challenge, a hackathon in which students from all AppDev courses build a full stack application from scratch. The winners will have their app features on the AppDev website!

First Day Jitters

Here are some pointers for gearing up for our first class on October 15th, 2025!

1. Ensure you've read through the rest of this page and filled out all necessary forms.

2. Install XCode from the App Store! (P.S. it takes a while 😄)

3. Join us on Ed, send us questions via email ＠[email protected], and get hyped!

Prerequisites

CS 1110 is a highly recommended co/prerequisite, but not required. You will also need access to a MacBook (Intel - macOS Catalina 10.15.4+, Apple Silicon - macOS Big Sur 11+) to participate in the course (the Xcode IDE is only available for macOS).

Enroll in the Course

1. Enroll in CS 1998-601 in Student Center. This is a 2 credit S/U course, but you may enroll for 1 credit to avoid going over the credit limit.

Ed Discussion

We will be using Ed Discussion for class communication and answering questions. Ed will be the main method of communication between students and course staff. You can join the Ed .

Install Xcode and Git

1. You can install Xcode through the .

   • If you do not have the latest Mac version and cannot update, you can find older Xcode versions .

2. We will be using . Double check that you can log in.

Figma

We will be using for app designs. You can create an account using your Cornell email.

Lecture Slides

Lecture Video

Lecture Slides

Lecture Slides

Useful resources:

Lecture Slides

Lecture Video

Lecture Slides

Lecture Video

Lecture Slides

Lecture Video

Lecture Slides

Lecture Video

Coming soon!

Coming soon!

Check out for all building codes on campus!

Lecture Slides

Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

Lecture Slides

Lecture Video (no audio 😢)

Lecture Demo

Install Postman and create a GET Request:

Docs:

Lecture Slides

Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

Lecture Slides

Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

Lecture Slides

Lecture Video

Spring 2025 Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

In almost any program that we create, we will need to store data at some point. In Swift, we can store data in two ways: variables and constants. We can think of both variables and constants as a box holding some value inside. However, there is one key difference between these two. A variable can change its value whenever we want. On the contrary, a constant can hold a value once and can never be changed again.

It may seem pointless to have both variables and constants; however, there are many advantages. If Xcode knows that a value will never change, it will optimize our program to make it run faster. Another advantage is that if we were to make a mistake and change a value of a constant when we don’t need to, Xcode will tell us and our code will not compile.

Variables

To create a variable, we use the var keyword.

To change the value of the variable, we can simply do the following.

Let’s try this in the Xcode playground.

Notice how we do not need to use the var keyword the second time. We should only use the var keyword if we are declaring a new variable. We can test this out in the Xcode playground.

Constants

Now, what if we wanted to use a constant instead of a variable? All we would need to do is to use the let keyword instead.

As we can see, changing the instructor variable to a constant caused Xcode to get angry. The error message clearly informs us that we are attempting to change the value of a constant.

What is UIKit?

UIKit provides a variety of features for building apps, including components we can use to construct the core structure of our iOS apps. The framework provides the core objects that we need to build apps for iOS. We use these objects to display our content onscreen, to interact with that content, and to manage interactions with the system. Apps rely on UIKit for their basic behavior, and UIKit provides many ways for us to customize that behavior to match our specific needs.

Create Views in UIKit

The UIKit framework provides an extensive library of classes that represent different kinds of views that we can utilize in our mobile apps. Thus, in order to create and customize these views, we need a basic understanding of classes, properties, methods, and inheritance. For example, suppose we wanted to display a title with a single line of text, we would first call upon the constructor to create an instance of UILabel:

Every view has a different set of properties that we can utilize to customize our frontend view. In the case of the UILabel, we can define many elements of the text such as, text, font, textColor, textAlignment, etc.

Thus, we are able to change the properties of the UILabel to display a customized view for our iOS App.

Setting Up a UIKit Project Programmatically

Before we write any code, let's make sure to properly set up our Swift files as detailed below. In this class we mainly teach UIKit with programmatic layout, and we DO NOT use Storyboard Swift. Follow the guide here:

In the previous section, we mentioned how data that is sent across the internet is represented as JSON. In this section, we will discuss how to decode JSON data and use it in our Swift code.

What is Codable?

In Swift, there are two protocols that our model structs/classes must conform to in order to be decoded: Decodable and Encodable. However, we commonly use the protocol Codable instead which essentially means that we are conforming to both protocols.

These protocols are very powerful and allow us to customize our own JSON decoder and encoder. For the scope of this course, we will only touch the bare surface.

Structuring our Data Model

Consider the following JSON data representing a student:

This is the information that we are given from the backend that represents a student. As a frontend developer, we need to make sure that both the frontend and the backend agree on one schema. Given this data, we have to decide on how to create our data model objects.

There are five keys in this JSON here: age, classes, first_name, last_name and major. Normally, we want the name of our properties to match exactly with the keys in the JSON (although there is a way to customize this). Once we have the names down, we need to determine the type of each property. Notice that the value for age does not have quotes around it so it is not a String. Also notice that the value for classes contains square brackets, indicating that it is an array where each element is a String. This gives us the following Student model:

Notice how the JSON has the key first_name and last_name, but in the model we use firstName and lastName. Although JSON is typically represented with camelCase, there are times when it may use snake_case (for example in our course). Since Swift's convention is to use camelCase, it has a built-in decoder/encoder that provides a neat way to deal with this, which we will look at in the next section.

What are Widgets?

Widgets enable you to view timely information from your favorite apps at glance in various environments across all Apple platforms. Introduced in iOS 14, widgets have become increasingly more flexible, adaptable, and powerful throughout the past few years. You may have experience using widgets on your iPhone’s home screen, but widgets can be used in many other areas on your devices.

Types of Widgets

• Home Screen: The most common widget is one that lives on your home screen, such as the Apple Weather, News, or Reminders widgets on iOS and iPadOS

• Today View: If you swipe right on your home screen, you can also view various widgets in your Today View on iOS and iPadOS.

• Lock Screen: On both iOS and iPadOS, widgets can now be added to your lock screen for quick viewing when you turn on your phone.

About This Textbook

This textbook was originally created in Fall 2023 by Vin Bui. Over the course of time, more chapters have been added by other instructors (see contributors below). Since the content may become outdated, all chapters will contain date information of when it was written. The lecture videos are from Fall 2023, but feel free to check out other semesters on the Cornell AppDev YouTube Channel.

Contributors

• Peter Bidoshi - Instructor FA24, iOS Lead FA25

• Richie Sun - Instructor FA23/SP24, iOS Lead FA24

• Vin Bui - Instructor FA23, iOS Lead SP24

• Tiffany Pan - Instructor SP24, iOS Lead FA23

Lecture Slides

Lecture Video

Lecture Demo

Lecture Slides

Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

Lecture Slides

Lecture Video

Lecture Demo

Install Postman and create a GET Request:

Pre-Class TODOs

• Fill out the course application .

• Add the to your GCal.

• Read the Getting Started, Syllabus, and Grading sections on the left.

Lecture Slides

Lecture Video

Lecture Slides

Lecture Video

What is Alamofire?

Alamofire is an HTTP(S) networking library written in Swift. It is built on top of URLSession, but is a lot simpler to use. Common use cases include:

• Fetching a JSON from an API

Of course our app won’t have just a single screen — we typically have multiple screens that we want to navigate to and from. In SwiftUI, navigation between views is very simple and similar to that of UIKit.

Creating a Navigation Stack

For iOS 16 and later, we use a NavigationStack which is a view that displays a root view and enables us to present additional views over the root view. This is similar to a UINavigationController in UIKit.

Lecture Slides

Lecture Video

Lecture Slides

Lecture Video

Lecture Slides

Lecture Video

What is SwiftUI?

SwiftUI is a declarative framework that allows us to create the user interface in our apps. It was introduced back in 2019 as a replacement for UIKit. The best way to understand declarative UI is to compare it to imperative UI.

Imperative vs Declarative

If you are familiar with languages such as Java or C++, these are imperative languages. Imperative programming defines how tasks should be accomplished. For example, say we plan on cooking steak for dinner. The imperative approach would be:

1. Walk to the meat section in the grocery store.

2. Search for any piece of fine steak starting from the top shelf to the bottom.

3. Once found, check the price and weight.

4. Place it in our shopping cart if we are satisfied.

As we can see, these steps tell us how we should shop for a piece of steak once we enter the grocery store. Now, compare this to the declarative approach:

1. Search for any satisfactory piece of steak in the grocery store.

There is one single step and that step tells us what to do. In other words, declarative programming defines what tasks should be accomplished compared to **how. When we think about computation, the imperative paradigm defines the control flow and state changes whereas the declarative paradigm defines only the logic.

The Issue with Imperative UI

If you are familiar with creating an app using the UIKit framework, you can see why UIKit is an imperative approach to creating UI. If we have a UILabel, then to change the state of that label, we could modify the properties of that object (such as .text). State is just another way of saying “the values that we store in our code.” The problem with imperative UI is that we need to constantly keep track of the state of our code and ensure that our UI correctly reflects that state.

For example, we could have a UIButton that, when tapped, triggers a change in the state of a UILabel. If we were to introduce another UIButton or an additional UILabel, we would need to write code to ensure that all of these UI components properly reflect the current state. As we add more components to our app, we can see that things can get pretty complicated.

Declarative UI to the Rescue

With SwiftUI and its declarative approach, we can create a Text view that is associated with some state variable. When the value of this variable changes (in other words, there is a state change), all views that rely on that state is updated accordingly. Everything stays in sync and is handled automatically. We no longer have to update our views manually when data changes.

That is the beauty of SwiftUI. We told it what to show based on the current state and SwiftUI moves between user interface layouts for us. That is the declarative approach. We define rules that our views should follow and SwiftUI enforces those rules.

The Future of SwiftUI

SwiftUI is relatively new and is only available for iOS 13 and above. It is also a growing framework and there are still a lot of improvements that need to be made. If you are new to iOS development and are deciding to choose between SwiftUI and UIKit, then I recommend learning SwiftUI. However, although SwiftUI is the future, many apps are currently built in UIKit. UIKit will still be needed for a few more years, so it is important to know both.

Coming soon!

This chapter only covers Xcode Cloud, but there are other CI/CD services that are commonly used such as Codemagic, fastlane, Jenkins, and GitHub Actions.

What is the Hack Challenge?

The Hack Challenge is an AppDev courses tradition where students across our 4 courses (iOS, Android, Backend, and DPD) come together to create their own mobile app in 2 weeks.

Why a Hack Challenge as a final project?

The purpose of our courses is to help our students gain skills that they can take into industry. The best way to develop these skills is by pursuing projects, especially with a team. Additionally, you will be able to put this on your portfolio, which will be an important factor when applying for internships.

How will the groups be assigned? Where will we find teams?

This depends on the number of students we have across all courses. However, most teams typically consist of 2-3 frontend members, 1-2 backend members and 1 designer. We will do a team matching mixer when the Hack Challenge begins. During this mixer, you will meet students in other courses and form a team.

Each team will also have a frontend mentor as well as a backend mentor to provide any help if needed.

How will grading work?

As a reminder, the Hack Challenge is worth 30% of your final grade. For iOS, you are required to have the following:

Midpoint Submission

• Multiple screens that you can navigate between OR at least one scrollable view.

Final Submission

• Multiple screens that you can navigate between.

• At least one scrollable view.

• Networking integration with a backend API.

Note that you can use either UIKit or SwiftUI for the Hack Challenge.

Do we win prizes?

Yes! We have prizes and awards for the following:

• 🏆 Best Overall

• 💻 Best Backend

• 📱 Best UI

• 🎨 Most Creative

Past Projects

Cornell GitHub

You can access the Cornell GitHub enterprise here.

Install Git (skip this step if you already have Git installed)

To check to see if you have git installed, open Terminal and run git --version. A message will display if you already have it installed.

Follow the instructions to install Git. I personally recommend using the Homebrew approach (requires you to install ), but the Binary Installer should work as well.

Generate SSH Key

1. Log in to your GitHub. Go to Settings > SSH and GPG Keys. Create a New SSH key.

2. Keep the page open. Open up Terminal and execute the two commands (replace YOUR NAME and YOUR GITHUB EMAIL):

   git config --global user.name "YOUR NAME"

   git config --global user.email "YOUR GITHUB EMAIL"

Configure SSH Agent

For newer Macs (12, Monterey/Ventura), run

ssh-add --apple-use-keychain ~/.ssh/id_ed25519

• If that command fails, try ssh-add --apple-use-keychain ~/.ssh/id_rsa

For older Macs (11, Big Sur), run ssh-add -K ~/.ssh/id_ed2551

• If that command fails, try ssh-add -K ~/.ssh/id_rsa

Cloning a repository (not needed for installation)

Open up Terminal and change the directory to wherever you want the repository files to be located. You can change the directory using the cd command.

• For example, if I want the repository files to be located in my Desktop, I would type cd Desktop

To clone a repository, simply type git clone <ENTER URL HERE>

In the course, we only utilized some basic functionalities of Git such as staging, committing, and pushing. However, Git is a lot more powerful than that which we will discuss in this chapter.

Branches

In the course, we mainly focused on one working branch known as main or master. When we made commits, we typically pushed them all into this one branch. When using this approach, collaborating with others was very difficult to do. If we did not fetch and pull from the main branch before working, we often had to deal with merge conflicts. Now, imagine if both developers are working on the same branch concurrently — a merge conflict is very likely to occur.

To avoid having to deal with merge conflicts every time we push to a branch, it’s often better to create separate branches when collaborating. To create a new branch and switch to it, use the following command:

Pull Requests

Pull requests (also known as PRs) allows us to discuss changes that were pushed onto a branch before merging it to the base branch. Let’s look at the following scenario.

Suppose we have a branch called A whose base branch was from main. We push commits and make changes to the branch A like how we would if it was the main branch. When we are ready to push these changes to the main branch, we can submit a pull request through GitHub to merge A to main. This allows other developers to review our code before merging it to the main branch. If changes need to be made, then we can push new commits to our A branch and request a review again.

When should we create a PR? There is no right or wrong answer to this question. A PR can be a single line of code or even a thousand lines. A good rule of thumb is to create a PR if it’s important to the state

PR Chaining

A huge benefit of creating branches and making PRs is that we can chain them together. Say we have two features, A and B, that need to be implemented. We create a branch off of main and call it A. When we are done with making changes to A, we can create a PR to merge it to main.

While the PR is being reviewed, we may need to work on a new feature (in this case feature B). What we can do is create a branch B from A (not main). Now, if we create a PR, we want to create a PR to merge B to A instead of main. This way, we do not have to wait for the previous PR to be reviewed. Additionally, only the changes made between A and B will be shown in the PR, making it a lot easier to review.

When both PRs are approved, we want to merge in the following order:

1. Merge the PR from A to main.

2. Delete the A branch. The target branch in the second PR will automatically change once A gets deleted.

3. Merge the PR from B

Resolving Merge Conflicts

There are times when we may want to merge a working branch into another without creating a PR. For example, if we are on a branch A, we can simply merge main into our branch with the following command:

When we run this command, we may receive merge conflicts. In other words, there are conflicts between the changes of the two branches, preventing the merge from happening. My preferred way to resolve merge conflicts is by using GitHub Desktop with Visual Studio Code (VSCode). VSCode will tell us where the conflict is occurring and allow us to resolve it quickly by clicking on “Accept Current Change” or “Accept Incoming Change”. See image below.

Of course, we can use our code editor to resolve the merge conflicts, but it can be difficult to locate where exactly the conflict is. GitHub Desktop works seamlessly with VSCode, allowing us to easily pinpoint and resolve the conflicts.

Undoing a Commit

There are times when we may want to undo a commit, such as when we push sensitive information to a public repository. To undo a commit, we can simply use the following command

where 2 means move backwards by 2 commits (we can replace this with a number of our choice). Note that this is a soft reset meaning that staged files are not reverted back to a previous state. In other words, we keep the code that we wrote on our local repository.

We can then create a new commit and then force push our changes to the repository:

Now that we have learned a bit about functions and how they work, we will discuss something more general, called Closures.

Closures are self-contained blocks of functionality that can be passed around and utilized within your code. The most simple example of closure is a function, but there exist others that are very important to understand before exploring future topics.

Imagine we have a function, which is a type of closure:

func getData() -> String {
    return "Fetched Data"
}

One way we could use the return of this function is as follows:

// Same code from above
func getData() -> String {
    return "Fetched Data"
}

// Save the string returned from the function in a variable
var data = getData()
// Print the variable
print(data)

Pretty simple right? However, we could also achieve this differently by using a Closure Expression. Closure expressions allow us to pass a piece of code as an argument to a function. To incorporate this, we need to change the method signature of our "getData" function.

// This is the syntax to indicate that this 
// function takes in another function!
// "handler" is just the name of the variable,
// and we can call it whatever we want
func getData(handler: (String) -> Void) {
    handler("Fetched Data")
}

What is going on here? Let's first talk about the method signature. You will notice we added an argument to the function that is called "handler". This argument has a type of "(String) -> Void". This represents a function that needs to take in a String and return nothing (void). The "getData" function then passes the String "Fetched Data" into that function. Now, let's change the other part of our code.

Here, we created a function called "printData" that takes a string and returns nothing (void). Notice that this signature (string -> void) is the same signature as our "handler" argument. We then pass the "printData" function as an argument to our "getData" function. with this, our "getData" function will pass the String "Fetched Data" to the "printData" function that was passed to it. This will achieve the same result as the original code.

However, this can be simplified! Instead of writing out a whole other function, let's provide the code right into the function! This is what a Closure Expression is all about.

Nice! "data in" is a tricky syntax that you will have to remember. The "data" represents a String that will be returned to the handler after the getData function is run. Swift is smart, so it can automatically infer the type of "data" as a String due to the getData method signature.

In the previous chapter, we learned what views are and how to create views in UIKit. We also learned how to use AutoLayout to position our views on the screen. However, our views contained hard coded data and did not have any functionality at all. When we create apps, we want our views to respond and update to user interactions.

MVC (Model-View-Controller) is a software design pattern which is a set of rules that govern the architecture that we follow when writing our code. There are other design patterns out there such as MVVM (Model-View-ViewModel) but we will be using MVC throughout this course. To better understand MVC, let’s take a deeper look at each component.

Model

Models are objects that represent our application’s data. Let’s look at an app we are familiar with, Eatery. The models in Eatery are the dining halls, the dishes and food items, the user’s information, etc. In other words, models contain information about our application and are often updated based on user interaction or from a backend service.

Classes vs Structs

Notice that we often use structs instead of classes when representing our models. The difference between these two is that structs are value types whereas classes are reference types. What this means is that if we were to change a property of an instance of a struct, the entire instance changes. On the other hand, if we change a property of an instance of a class, the instance does not change.

For example, consider a User model with the property name. For a class object (reference type), if we changed the value of name, all locations that have a reference to that object have the new updated value for name. If this were to be a struct object (value type), changing the value of name in one location DOES NOT update other locations because a new instance is being created. We can think of reference types as sharing a Google Doc with other collaborators. If one person were to change something on their side, the others would be able to see those changes. For structs, we can think of it as making a copy of the Google Doc.

One advantage of using a class is inheritance. In other words, we can use properties and methods already defined by a parent class, commonly seen in UIKit. However, there are times when we don't need to use all of these properties and methods, making structs more preferable. This is commonly seen in SwiftUI and why using structs is a lot faster than classes.

View

Views are the visible components that are used to build the user interface (UI). This includes buttons, labels, images, etc. In Eatery, everything we see is a view. For example, the name of the dining hall is a UILabel which contains information from the dining hall model. We don’t see models. We see views that contain information from the models.

Controller

Controllers belong in the middle between models and views. The main goal of a controller is to establish a connection between models and views. The controller is also in charge of processing the logic to update the models and views. For example, in Eatery, there is a User model that represents the logged in user. When we sign in, we are interacting with views. How does the model update based on what we passed into the text field? Well the controller handles that logic. If we provided the correct credentials, it will modify the models and update the views such as showing a logout button. If we provided invalid credentials, then the controller will still update the view and show a red error message.

Putting everything together

One important thing to keep note of is that views and models are separate. They cannot directly interact with each other, but rather, they must go through a controller to make that connection.

We can think of MVC as watching television: the TV is the view, the remote is the controller, and the channels/content is the model. How does the TV (view) change the channel (model)? It can’t! We must use a remote (controller) in order to do that. When we change channels using the remote, we made changes to the model and tell the TV to update its view.

So far, we only created static, non-moving views. However, many apps today have views that are scrollable. One way to implement a scrollable view with UIKit is with a UITableView.

What is a UITableView?

A UITableView is a subclass of UIScrollView which is a view that users can scroll through. We can think of a UITableView as a list of data. Each item inside of this list is represented by a view called a UITableViewCell. Each cell tends to look very similar to one another but are holding different data.

Examples of a UITableView

Breaking Down a UITableView

A UITableView contains sections where each section contains rows, and each row being represented by a cell. Let’s take a look at Settings:

As we can see, a UITableView can contain as many sections as it wants, and each section can contain as many rows as it wants. The rows are represented by a UITableViewCell which is a view. In the image above, we can see that each cell looks very similar to one another. Each cell contains a UIImageView representing the icon as well as a UILabel describing that cell. In the next section of this chapter, we’ll learn how to create these custom cells.

For more information, check out the Git Documentation

Sharing and Updating Repositories

Git Pull

Pulls changes from a remote repository into the current branch. If the current branch is behind the remote, then by default it will fast-forward the current branch to match the remote.

Git Status

Displays paths that have changes between your local repository and the HEAD of the remote repository

Git Add

This command updates the index using the current content found in the working tree, to prepare the content staged for the next commit. To stage all changes, use git add .

Git Commit

Create a new commit containing the current contents of the index and the given log message describing the changes.

Git Push

Updates the main branch of the remote repository based on the last local commit

Branching and Merging

Git Branch:

Lists all existing branches; the current branch will be highlighted in green and marked with an asterisk

Git Checkout:

We learned that we can use an HTTP request to retrieve information from a server. We also learned that the server responds with a status code and some data represented by JSON. Now, how do we make these API calls in Swift?

Understanding Network Calls

Before we look at Swift code, let’s try to understand how a networking call works in the perspective of the client. Grab a phone and open Instagram or any social media app. When we launch the app, not all of the information is fetched from the backend right away. If we had a slower internet connection, these posts and stories will take even longer to load. Now notice how the app does not freeze even though we are sending network requests to the backend server. What’s really happening is that these network calls are happening asynchronously. In other words, it is running in the background.

Why is this necessary? A client’s internet connection can vary and we do not know exactly how long it will take to receive a response back from the server. Because of this, we do not want our app to freeze while we are fetching information from the backend. Additionally, we want to be notified as soon as the server sends a response back so that we can perform any UI updates. In the case of Instagram, once the client receives these posts on their feed from the server, the client is notified and the app automatically updates the UI. There are many ways we can handle asynchronous code in Swift. In this course, we will be using a traditional approach using callbacks (completion handlers).

Callbacks Explained

A callback is a function that is passed into another function as an argument and is called after the original function completes. In Swift, these callback functions are known as completion handlers. Imaging this scenario:

You are expecting a package delivered to your house containing a gift for your parents. Unfortunately, you are out of town and will not be able to deliver the gift yourself. You ask your friend that lives in your house to give it to your parents once the package arrives. Your friend could do two things:

1. Stand at the front door and wait for the package for days without doing anything else, then deliver it to your parents

2. Have common sense and go on with life while they wait for the package to arrive, and then deliver it once it arrives

In this example, the package delivery is the network request. Your friend delivering it to your parents once the package arrives is the callback. You are the original function that requested this callback function to do something. Another common real-life example would be asking someone to call you back once they are ready to call you back instead of staying on the line.

Writing Callbacks

Consider a social media app similar to Instagram. We have a Post object representing a post. When we open our feed page, we send a request to our backend server to fetch new posts. Our function header to fetch our feed could look something like this:

We create a function called fetchFeed that takes in another function as an argument (the callback) with the name completion. We can name this callback function to whatever we want, but make sure it is clear that it is a completion handler. So this completion parameter needs to have a type, as with any parameter inside of a function header. Well, we want this parameter to be a function type in order for it to be a callback. When we declare a function type, we need to specify the types of the function’s parameters as well as the function’s return type. Remember, the purpose of this callback function is to deliver the information from the backend, so its parameter type will be an array of Post objects. This callback function receives these posts as an argument but does not return anything, hence the return type of Void.

Just to bring everything together, we declared a function as a parameter inside of fetchFeed called completion whose type is ([Post]) -> Void meaning it takes in one argument which is an array of Post objects and does not return anything.

You may have noticed the keyword @escaping. In the example earlier, when I asked my friend to deliver the gift to my parents, I am the original function. During that original function call, I asked my friend (the callback) to complete this task for me, but only want to ask them once and forget about it for now. We can think of the original function call being erased here. However, my friend still has a task to do, and I do not want them to forget (be erased). Connecting this back to Swift, we mark these callback functions (completion handlers) with the @escaping keyword so that it can outlive the original function. Otherwise, as soon as the original function is complete, the callback will be erased as well and we do not want that!

The complete network call could look something like this:

Firebase Crashlytics is a real time crash reporting tool that helps us pinpoint crashes from our users. It makes is very easy to receive detailed insight on the events that led up to the crash, allowing us to quickly reproduce bugs and determine the root cause.

Getting Started

In order to set up Crashlytics, we must have a Firebase project configured for our app.

1. Under Project Settings > General, download the GoogleService-Info.plist file and drag it into our project directory.

2. Install the Firebase SDK via CocoaPods or Swift Package Manager and choose the libraries that we want to use (in this case FirebaseCrashlytics).

3. Follow the instructions from the to add the initialization code.

Adding the SDK

The does a pretty good job explaining how to set up Crashlytics so I won’t repeat it here. Follow the guide to add the SDK.

Note: If we are using CocoaPods as the package manager for our project, then there are 2 differences:

1. Firstly, skip Step 1 (adding Firebase through github and Swift Package Manager). The only thing we want to do from that step is check that Other Linker Flags does have -ObjC.

2. Secondly, when adding a new script to Build Phases, we need to make sure to use the script ${PODS_ROOT}/FirebaseCrashlytics/run instead of the provided script (which will search for a Swift Package Manager file that doesn’t exist)!

Viewing Crashes

If we followed the documentation correctly, our app’s dSYM’s files should automatically be uploaded to Crashlytics, allowing us to read and process crashes.

Lecture Slides

Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

What is a UICollectionView?

Similar to a UITableView, a UICollectionView is a sub-class of UIScrollView. In other words, it is also a scrollable view. However, a collection view is more dynamic and customizable than a table view. A collection view still contains sections, but instead of rows in a table view, it uses items. Each item is represented by a UICollectionViewCell and can be displayed in a grid-like manner. Additionally, a UICollectionView also supports horizontal scrolling.

Examples of a UICollectionView

Breaking Down a UICollectionView

A UICollectionView contains sections where each section contains items, and each item being represented by a cell. If we look at the Spotify example above, we can see 3 sections, each having its own header. For example, the top section has the header “Made For vinnie”. Now, each section contains items, which are represented by a UICollectionViewCell. In each section, the square image is a UICollectionViewCell. If you have used Spotify before, then you know that these sections are horizontally scrolled.

As we can see, a UICollectionView is a lot more versatile and customizable than a UITableView. It allows for horizontally scrolling as well as laying items out in grid-like manner.

Lecture Slides

Lecture Video

Lecture Demo

Clone the Repository

Checkout Branches

Preparation

First, we want to change our app’s marketing version and build number. For consistency, use the following guidelines for minor updates:

• 1.1.1 → 1.1.2

• 1.1.9 → 1.2.0

• 1.9.9 → 2.0.0

Xcode Cloud handles build version, but keep the project updated with the next build version, which should always be incremented by 1, independent of the current version. If there is a major update, such as from Eatery to Eatery Blue, you can skip this versioning incrementation and change the first number completely (e.g X.0.0).

Before we get started with AppStore Connect, our app bundle must be archived and uploaded. The most common way to do this is to go to Xcode, then Product > Archive. Alternatively, we can use a CI/CD service such as Xcode Cloud that will automate this process for us.

Using TestFlight

1. Log in to our Apple developer account and select our target product.

2. In the TestFlight tab under Builds, select the archive and click through the dialogs for Export Compliance Information. For AppDev members, Vin automated this process for most of our apps so this can be skipped.

   1. Encryption: Standard Encryption

Submitting the Build to the AppStore

1. Go to Apps -> <app_name> and select the Overview tab.

2. Click the + button next to iOS App to create a new app version matching the latest version number.

3. Under “What’s new in this version”, write down what changes were made (e.g. “Bug fixes and improvements.”)

Join the Google Calendar

Schedule

In the variables and constants section above, we assigned a text to a variable. In Swift, this is called a String and is one of the most important types we will use. However, there are many more types of data that Swift handles. In the example earlier, let’s try to do the following:

There are two ways we can fix this error:

1. Initialize the variable with a value when we create it.

2. Tell Swift what data type the variable will hold on later.

If we want to execute a chunk of code only when a condition is met, then in Swift, we can use if, else if, and else statements. Let’s take a look at the following example:

When using conditionals, we must provide a condition which is an expression that evaluates to true or false. To enclose a block of code in Swift, we use curly brackets ({ and }). In the example above, the expression a == 0 evaluates to true so the block of code containing print("Zero") will be executed.

Now that we know how to define class and utilize UIKit views, how do we position and organize these views in our apps? There are multiple ways to layout views to a screen in iOS development – some examples include frame-based, storyboards, and programmatic AutoLayout. However, the method we will be learning in this course is programmatic AutoLayout.

What is AutoLayout?

AutoLayout is a constraint-based organization system used for UI development in iOS applications. This constraint layout system allows for adaptive UI which adapts to screens of different sizes and orientations, using a relational layout structure to organize views with respect to one another. Thus, this method tends to be less error-prone and does not require us to worry about the coordinates of individual elements on the screen.

Structs for Views

Why does SwiftUI use structs for views? First, structs are simpler and faster than classes. But there’s more to it than just performance. In UIKit, every view is a subclass of UIView which is the superclass that contains hundreds properties and methods such as frame, backgroundColor, etc, that we don’t even use them all. You would then create a subclass of UIView and perhaps even a subclass of the subclass and you could keep going forever. Because classes can change their properties freely, things can get messy.

Data persistence is the mechanism involving the storage of data on a disk without being altered by the user the next time the app is launched. In the iOS world, this primarily involves storing the data locally on the user’s device.

Why Persistence?

By default, the data that is allocated in our app is stored in RAM which is immediately cleared as soon as the user closes out of the app. For example, say we had an array of students displayed in a table view. Assuming there is no backend integration, when we launch the app, this array is stored locally in RAM. If we were to add a new student to this array during the app’s lifetime, we will notice that when we relaunch the app, the added student is gone.

Sometimes we want to save data on the user’s local disk so that when the user opens the app again, that data persists

Lecture Slides

Lecture Video

Tired of having to type the extremely long code for setting up auto-layout with NSLayout? SnapKit is here to make our lives easier! SnapKit is a wrapper library that makes setting constraints with auto-layout very simple.

Installation

You can use either Swift Package Manager or CocoaPods to install SnapKit. If using CocoaPods, simply write pod SnapKit in our Podfile then use pod install.

We learned how to use variables and constants to store data, but only explored basic values such as integer numbers and text. However, when we program, we often need to hold more complicated data that requires a specialized format for organizing and retrieving the data. To do this, we use Data Structures.

Arrays

The most common data structure that we will be using is an array. Arrays store a group of values together into a single collection, and we can access these values using their position in the array.

We use square brackets

When we want to repeat a code a certain number of times in Swift, we can either copy and paste the code or even better, we can use loops. There are two main loops in Swift: a for loop and a while loop.

Looping over a fixed number of times

Let’s say we wanted to print out the numbers 1..10. In Swift, we can use the closed range operator (...) which is three periods in a row.

The variable i is known as a loop variable which is a variable that lives within the scope and lifetime of the loop. For every iteration, the value of i will change. Now, what if we didn’t need to use i and just wanted to print "Hello Vin and Richie" 10 times? We could still use for i in 1...10; however, it would be better to use an underscore (_) instead.

Why is ... called a closed range operator? Well, that’s because there is also an open range operator (..<). The difference between these two is that the closed range operator is inclusive whereas the open range operator is not. The following code will only be executed 9 times. It goes up to but not including 10.

Looping over arrays

Swift provides a nice way to loop over the elements of an array using the for-in loop.

In this code, the loop variable is person. For every iteration of this loop, the value of person will be the value of every element inside of the array staff, in order.

Instead of looping over the element of the array, we could have looped over the indices of the array. The following code is equivalent:

While Loops

If we don’t know exactly how many times to repeat a block of code, but do know that we want to repeat it while a condition is true, then we can use a while loop.

The above code will print out the value of i and increment the value of i by 1 while i < 10 evaluates to true.

However, be very careful when using while loops because we can create an infinite loop. In the code below, the value of i never changes and will always be less than 10. In this case, there will be an infinite loop:

Connecting to the Internet

So far, the data that we have used have been hard-coded on the frontend. For example, in our A3: ChatDev assignment, the Post objects that are displayed in the table view are hard-coded inside of our code. There is an array of Post objects written in Swift code known as dummy data. In other words, these posts are expected to be fetched from the internet and displayed onto our app. If a different user creates a post, then we want it to be updated on our side.

Clients and Servers

A client is a device or software that requests a service. In this course, the client is our iOS app because it requests information from some service. Who provides this service? That’s the job of a server. A server is a device or software that responds to clients with these services. Remember, clients send a request and a server responds.

What is an HTTP request?

An HTTP request is a method used to communicate between a client and a server. There are many different types of HTTP requests; however, the most common types are GET, POST, PUT, and DELETE. For the scope of this course, we will only discuss a GET and a POST request (and maybe DELETE).

These requests are commonly paired with a CRUD operation. CRUD stands for CREATE, RETRIEVE, UPDATE, and DELETE. This idea is often used when dealing with models. For example, we can retrieve posts on Instagram, create a post on Instagram, etc.

HTTP Response Codes

So, the client sends an HTTP request to a server asking for some service. What can the server respond with? Well, the server can respond with the service the client is requesting, but we don’t live in a perfect world and things can go wrong! For example, when we click on a website, as clients, we are sending an HTTP request to the web server to provide us with the website information. But what if our WiFi connection gets cut as we are sending the request? How will the server communicate with us about what went wrong?

An HTTP response code (or status code) indicates whether an HTTP request has been successfully completed and provides information about the request. Have you ever went to a website and received a “404 Not Found” error? Well, this “404” is an HTTP response code indicating that the server could not find what the client was looking for.

HTTP response codes range from 1XX to 5XX, with the first digit indicating the category:

Storing and Transporting Data with JSON

So far, we’ve learned that clients send an HTTP request and a server responds back with a status code. However, clients and servers need to understand the data that is being transmitted. The issue is that most of the time, client-side and server-side code are written in different languages. For example, our code may be written in Swift, but the backend server may not be able to recognize it. Then, how are we able to send this data? We use JSON.

JSON (JavaScript Object Notation) is a text-based data format that is language-independent. The powerful thing about JSON is that it is widely used and many modern programming languages and frameworks have built-in functionality to parse data in JSON format. JSONs have key-value pairs, just like dictionaries in Swift. The keys are always strings, but a value can be a string, number, object, array, boolean, or null.

Consider the following Student model:

In Swift, if we wanted to create this object, we could write the following code:

Now, this object is currently stored locally on the frontend. If we wanted to fetch this from the backend, then the server response can represent the data as a JSON (notice that this is very similar to a dictionary in Swift):

Creating the Project

1. Enter the name of our app. In this example, we will be calling our app Sample.

2. Choose SwiftUI for the Interface.

Project Navigator

On the left side of Xcode, we shoul see a list of files in the directory. This is known as the project navigator.

• SampleApp.swift contains code that is executed when we launch our app. If we want to create something when we launch our app and keep it throughout the app’s lifetime, we will write it here.

• ContentView.swift contains code that defines the UI for our app. Most of our code will be written in a file similar to this.

• Assets.xcassets is a catalog that contains the app’s images, icons, colors, and more.

Canvas and Live Previews

On the right side of Xcode, we should see a canvas containing a preview of the app. If not, go to the Editor menu and select Canvas (alternatively ⌥ ⌘ ↵). The device that is shown on the preview depends on the device we select at the top center of Xcode. Because the preview is updated live, errors within our code can cause the preview to pause. To resume, we can click Resume in the canvas or even better, use the shortcut: ⌥ ⌘ P

Exploring ContentView.swift

To use all of the functionality provided by the SwiftUI framework, we must import it using import SwiftUI. This is similar to how we import other frameworks such as UIKit, MapKit, etc.

Next, we create a struct called ContentView that conforms to the View protocol. The View protocol is a type that represents our app’s UI and provides modifiers to configure our views. If we want to draw anything on the screen using SwiftUI, then it must conform to the View protocol.

Inside of the ContentView struct, there is a required property called body that has the type of some View. What this type really means is that this property will return something that conforms to the View protocol. Later on, we will learn that the actual return type of this property is very complicated (could be 1000+ characters) so providing a general return type of some View means we can ignore that. The body property is the only requirement needed to conform to the View protocol.

iOS 17 Onwards

Starting in iOS 17, the syntax for the preview is different:

The functionality is the exact same as it was in previous iOS versions.

The Project

In this project, we will create a Weather Widget that can show up to 6 six different weather conditions. The conditions will change based on a location you input into the widget. Additionally, this widget will scale to look great in a small, medium, and large variant. As well, it will adapt to be viewable as a lock screen widget and standby widget on iOS. It will also be available on iPadOS and macOS. We will also use App Intents to allow this widget to be configurable and let the user input a location and have the weather and widget display update.

Creating a Widget Extension

1. Create a new app. While you can use either SwiftUI or UIKit for your app, your Widget can only be built in SwiftUI.

2. Our Widget will live in a Widget Extension. Create a new Widget by selecting File → New → Target → Multiplatform → Widget Extension.

3. You can specify the platforms you want this widget to be available on. We want this widget to work on all platforms available, so we will select Multiplatform.

Project Navigator

A new directory will be generated inside of your project navigator:

• WeatherWidgetBundle.swift is the main entry-point for our widget. If we have multiple widgets for our app, we can declare them here within a WidgetBundle.

• WeatherWidget.swift contains the majority of code that defines the Widget. It contains four components, the widget extension’s TimelineProvider, its TimelineEntry, its View, and the Widget

Canvas and Live Previews

On the right side of Xcode, you should see a canvas containing a preview of the app. If not, go to the Editor menu and select Canvas (alternatively ⌥ ⌘ ↵). The device that is shown on the preview depends on the device you select at the top center of Xcode. Because the preview is updated live, errors within your code can cause the preview to pause. To resume, you can click Resume in the canvas or even better, use the shortcut: ⌥ ⌘ P

The canvas shows the default widget generated by Xcode on the home screen. Beneath, you can see a visualization of the timeline for this widget. We will discuss the Widget’s timeline in more depth shortly. Feel free to play around with the Widget’s View inside of WeatherWidget.swift and see how the live preview responds!

Project Setup

While it is nice to have this boilerplate code generated for us, we want to start things off from scratch to better understand how Widgets are built.

1. Delete all of the code inside of WeatherWidget.swift. Eventually, this file will contain the widget and its configuration.

2. Create 4 new Swift files:

   1. Weather.swift: This file will contain the Weather model to hold our data.

As developers, we are often faced with bugs that require us to debug our code. The most common way to do this (and the way it is taught in many CS courses at Cornell) is to use print statements. Although print statements are a very powerful tool to help debug our code, we can go beyond that and use a library called OSLog.

What is OSLog?

OSLog is Apple’s recommended library for logging and is a replacement for print statements and NSLog. OSLog allows us to mark different logging levels such as “warning” and “error” as well as structuring our app’s logging into categories that we can create. Additionally, it works perfectly with Xcode 15’s new logging console, enriching our debugging experience even further.

Getting Started with OSLog

To get started, let’s create a file in our project directory called Logger.swift. Inside of the file, add the following code:

1. We first import this library with import OSLog in order to use all functionality provided by it.

2. We then create an extension of the Logger class which is already defined in OSLog.

3. Every Logger instance requires two things: a subsystem and category.

Writing Logs

To write a log, we can use the following syntax:

We use the static variable services that we created earlier (which is a Logger object), followed by a log level (in this case info). There are many log levels that we can choose from, each being displayed differently in the Xcode console.

• default (notice): The default log level which should be avoided. Our logs should be more specific.

• info: Log information that may be helpful but is not necessary for debugging.

• debug: We use this level during development while actively debugging.

We also need to make sure that our console has the proper Metadata selected to display the logs properly:

Data Privacy

When logging, we need to consider data privacy. For example, if we wanted to log a user’s birthday, we can use the following code:

We use string interpolation to output the value of the birthday constant and mark it as private. We want to do this to prevent external apps such as Console to be able to view sensitive information in our logs.

Console App

For more advanced logging, we can use the Console app to read our logs. The Console app supports optimized logging structures with alignments which improves readability. Additionally, we can filter logs from multiple devices, categories, and log levels. Learn more about logging in the .

So far, we've only worked with one screen which may contain many views. For this single screen, we controlled the models and views with a single UIViewController. However, many of the apps that we use today contain multiple screens that we can navigate between. In UIKit, we represent every distinct screen with a separate UIViewController. There are two ways to navigate between screens: 1) pushing/popping and 2) presenting/dismissing.

Pushing/Popping

Before we dive in to the technical details, let’s observe what pushing and popping looks like.

As we can see, when we tap on one of the cells, a new screen shows up. Each new screen that we push is a separate UIViewController. So then, how do we keep track of the view controllers that have been pushed to figure out which one needs to be popped? We use a navigation stack. Every time a view controller is pushed, it goes on top of the navigation stack. Think of the navigation stack as a stack of books where each book is a view controller. The last item to be pushed into this stack will be the first one to be popped out (LIFO). How do we represent this navigation stack in UIKit? We use a UINavigationController.

Inside of SceneDelegate.swift add this code to the function scene:

The important step to remember here is step 3 where we first initialize the view controller (rootVC) that we want to be displayed when the app launches. Now, we have to place rootVC into the navigation stack by creating a UINavigationController with rootVC as the root view controller.

One thing to keep in mind is that the line let rootVC = ViewController() creates a view controller whose class name is ViewController. When we create a new project, by default, a class called ViewController is created for us. If we created a new class or renamed the class to HomeViewController, then we would use HomeViewController() instead.

Now, to push and pop a view controller is very simple:

UIViewController will be the view controller object that we want to push. Most of the time, we want to set animated to true. For example, if we had a class called ProfileViewController and wanted to push it, we would write the following code in the view controller class that is pushing it (not inside ProfileViewController):

To pop the ProfileViewController, we would write this code in ProfileViewController:

We could then link this code to some action such as a tapping on a button, cell, image, etc.

Presenting/Dismissing

Let’s observe what presenting and dismissing looks like.

As we can see, a modal sheet is presented from the bottom of the screen and gradually transitions up. This is presenting. To dismiss, we can simply click on the cancel button or more commonly, swipe downwards from the top of the modal sheet. The view controller that is being presented is displayed on top of the previous view controller. There is not a navigation stack at play here ⇒ No UINavigationController.

To present/dismiss a view controller:

For example, if we had a class called ProfileViewController and wanted to present it, we would write the following code in the view controller class that is pushing it (not inside ProfileViewController):

To dismiss the ProfileViewController, we would write this code in ProfileViewController:

As we may have notice from the function header above, there is an optional parameter called completion. This is known as a completion handler which is a function that gets executed when the function call is complete. We will discuss this in detail once we get into networking.

Imagine a large scale application with thousands of lines of code. The codebase would be very messy! To solve this, we need to be able to reuse our code. We can do this with functions.

Functions allow us to define reusable blocks of code. We define a function by using the func keyword followed by the name of the function (myName) and open/close parentheses:

If we were to just define this function in the playground, nothing will be printed out. This is because we also need to call the function. We can call the function we previously defined with the following code:

Let’s test this in the playground:

Parameters and Arguments

The nice thing about functions is that we can pass in arguments to make our functions a lot more useful. Using the example above, let’s customize our function to make it a lot more versatile:

This function has a parameter called name which is of type String and uses string interpolation to output the name. We would then need to pass in an argument to the function call:

External and Internal Parameter Names

In Swift, we can change the way parameters are named in the function call and inside of the function definition.

In this example, the name of the parameter within the function definition is str but when we call the function, we use name. str is known as an internal parameter and name is called an external parameter. This may not seem useful at first glance, but it is a very powerful feature once we begin writing code.

We can also use an underscore (_) as the external parameter.

By doing this, we do not need to provide the external parameter name when passing in our argument in the function call.

Returning Values

The functions that we defined earlier did not have any return value, meaning that when we called the function, nothing gets sent back to the function caller. However, many of the functions we create will have a return value. To do this in Swift, we use the right arrow (→) followed by the return type.

The function above will return true if the argument that we pass in is an even number and false otherwise.

Because this function returns a value, we can do many things with this function call such as assigning the returned value to a variable.

When we create apps, we don’t just care about creating our views — we also want to lay them out. In SwiftUI, there are three main ways to lay out our views:

1. HStack

2. VStack

3. ZStack

HStack

An HStack is a view that arranges its views in a horizontal line. For example, to lay out the text “Cornell” and “AppDev” horizontal, we can use the following code:

VStack

A VStack is a view that arranges its views in a vertical line. For example, to lay out the text “Cornell” and “AppDev” vertically, we can use the following code:

ZStack

A ZStack is a view that overlays its subviews, aligning them in both axes. For example, to place the text “AppDev” above a background color of red, we can use the following code:

Spacers

A Spacer is a flexible view that expands along the major axis of its containing stack layout, or on both axes if not contained in a stack. For example, to place the text “Cornell” as far away from “AppDev” in an HStack, we can use the following code:

Other Views

Of course, there are other types of views we can use to lay out our views. I recommend reading the Apple Documentation for each one if you’re interested.

• LazyHStack

• LazyVStack

• List

• ScrollView

Breakdown

- Best Backend

Frank Dai, Qiandao Liu, James Tu, Huajie Zhong

• Account login and registration (with profile image)

When creating any application, it’s very important that we ensure our apps function properly and maintains that proper functionality for as long as possible. However, this can be quite difficult when working with larger codebases and more complex applications as adding new code may cause undesirable changes to our app. To maintain functionality, we often write unit tests to ensure that our code works properly after making changes to our codebase. In the iOS world, we typically write unit tests for the smallest, yet important, functions that control the logic of our app.

Getting Started

There are multiple ways to create our testing suite.

In Swift, there are two ways that we can build complex data types beyond the given basic types like Int, Float, and String. Classes are one such way that we can build some of these complex data types that we'll see later on in the UIKit framework as well as many other Swift packages.

Defining a Class

If you have taken CS 1110 or 2110, then classes may already be familiar to you, but essentially; Classes can be thought of as blueprints. Within these blueprints, there are many different specifications and properties, for what we want the objects of the class to possess.

Thus, under the same analogy, objects are the houses that are built from the class blueprints

• Class = Blueprint

• Object = House built from blueprint

For example, let's suppose we define the following class for a house below:

Within the house class, there are many properties such as color, material, and owner along with their specified type, as well as any methods associated with the class.

Instantiation and Objects

However, with properties alone, the class is not complete, we need to also define an initializer as shown above. Essentially what the initializer does, is that it instantiates an object of the class.

In the code chunk above, notice the keyword self. The self keyword is used to represent an instance (or object) of the given class. In this case, the initializer creates the instance of the House class, which is then represented by the self keyword. Then, the properties color, material, and owner are initialized through self.

As shown below, the initializer is a function that is the same name as that of the Class, where we are able to pass in the desired values for the specified properties.

blueHouse and redHouse are both objects (or instances) of the same House Class

Now that we have an instance of that class we can then access its properties and call any class methods as shown below:

Inheritance

Classes can also be built based on other classes, this is known as class inheritance. This is a prominent technique that we'll see used extensively throughout UIKit, even in the most basic apps, so it's something we will need to eventually get familiar with.

Lets move back to our scenario with the House class that has properties color, material, and owner, and methods like the initializer and paintHouse method.

Supposed we wanted to define a new class to represent a TreeHouse, which includes all the properties that the House object does, but also includes new properties like treeType and slideColor.

Of course, it may seem logical at first to take all the code defined in the House class and copy it over to the TreeHouse, but this repetition of code may come back to bite us later on when we want to change the House class and also want the same changes to TreeHouse. We would have to change the same code twice!

Luckily, Swift offers a smarter solution with class inheritance: We can define the TreeHouse class based on our existing House class

The colon above is what establishes this inheritance, it indicates that TreeHouse is a subclass of House, or House is the superclass of TreeHouse; thus, TreeHouse will inherit all properties and methods from the House class.

However, we are not quite there yet, we also want to add the properties treeType and slideColor, and also change the paintHouse method so that we also have a color option to paint the slide.

Notice that we did not redefine any of the properties that already exist in House since they are inherited. In the initializer, notice a new keyword super. The keyword super represents the superclass, where in this case we are calling the initializer from the superclass House, which initializes the original 3 properties.

Now let us change the paintHouse function:

Notice the keyword override. In Swift, override indicates that a method is implemented in the superclass, but we want to change it for the subclass. Thus, if we want to redefine the paintHouse function to apply for TreeHouse, we need to “override” the existing method

We have seen the four basic math operations in elementary school: addition, subtraction, multiplication, and division. In Swift, we can use operators to perform these operations.

Basic Operators

The following lines are equivalent:

These operators are self-explanatory; however, if we were to take a closer look at the the line a = a / 10 we can notice that the output is 2 instead of 2.5. The reason for this is because the type of a is an Int. If we were to perform these operations on a, then we must also use an Int.

Then, how do we get the value 2.5? Because the type of a is an Int, then we must introduce a new variable of type Double or Float since we cannot change the type of a variable once initialized. We would also need to make sure that the values in which we apply these operators on must also be a Double or Float.

Let's take a look at the line Double(a). This is known as type casting. Because a is an Int and we needed a Double, Double(a) converts the value 2 to 2.0. Note that this does not change the type of a. It only produces a value to be used for that operation.

One more common operator we may see is the modulus operator (%). This is similar to the / operator except we return the remainder.

Common Operators

The following is a list of common operators that we are likely to use.

String Interpolation

String interpolation is a way of combining variables and constants inside a string. Take a look at this example:

Of course, we could have used the + operator to concatenate these strings together.

The problem with this approach is efficiency especially if we want to concatenate multiple variables. Another issue with using + is that Swift does not allow types such as Int or Float to be glued with a String.

We could cast age to a String but that would be expensive.

Using string interpolation is a lot more efficient and looks cleaner too!

AppIntents

AppIntents is the framework developed by Apple that allows us to configure our widgets with custom information provided by the user.

Creating a New Intent

We will create a new intent that allows the user to input a location and have the weather widget update its displayed conditions.

Let’s start by creating a new Swift file, which we will call LocationAppIntent.

Within that file, we will define a new structure that conforms to the WidgetConfigurationIntent protocol. This protocol provides us with an interface for configuring a WidgetKit widget.

This protocol requires us to implement a title for this Intent. Additionally, we can also implement a description on what this intent does.