Free online courseiOS application development with SwiftUI ( CS193P ) by Stanford

3

(1)

22h10m of online video course

Quality content and selected for your learning.

Certificate of course completion

Download your digital certificate of course completion after watching all course videos.

Exercises to train your knowledge

Many of the courses available have exercises to help with learning.

Free lifetime access

This course is free today and always will be, from start to finish you will pay nothing.

Online course in English

App Development

Learn how to develop applications for android and ios (iphone) smartphones, using technologies such as Flutter, React, among others.

iOS Swift

Swift is a programming language developed by Apple for development on iOS, macOS, watchOS, tvOS, and Linux.

Teacher

Stanford
6 Courses / 8173 students

Located between San Francisco and San Jose in the heart of Silicon Valley, Stanford University is recognized as one of the worlds leading research and teaching institutions.

Course comments

Discussion Forum

There are no comments yet for this course.

Watch the 1st video of the course

Share

Evaluate course

Go to certificates

Report a problem

Course content

1h21m

Lecture 1: Getting started with SwiftUI

The first of the lectures given to Stanford University students who took CS193p, Developing Applications for iOS using SwiftUI, during Spring quarter of 2021. Paul Hegarty covers the logistics of the course and then dives right into creating an iOS application (a card-matching game called Memorize). The Xcode development environment is used to demonstrate the basics of SwiftUI’s declarative interface for composing user-interfaces. Note that this is not an active, on-line course. It is a release of lecture videos that were already given to Stanford students as part of its normal curriculum.

Course materials (homework assignments and demo code) are available at https://cs193p.stanford.edu.

1h25m

Lecture 2: Learning more about SwiftUI

The series of video lectures given to Stanford University students in the Spring of 2021 continues with the completion of the first prototype of a user-interface for a card-matching game called Memorize.

The very important concept of Views takes center stage as basic composition mechanisms of SwiftUI (stacking and gridding) are used to put multiple cards into the game, each built out of a reusable “card” View. A simple demonstration of handling a tap gesture gets the cards flipping over and a couple of buttons are added to the user-interface to control the number of cards in the game.

Course materials (homework assignments and demo code) are available at https://cs193p.stanford.edu.

1h35m

Lecture 3: MVVM and the Swift type system

Lecture 3 of Stanford’s Spring 2021 iteration of its CS193p course (Developing Applications for iOS) starts off with a conceptual overview of the architectural paradigm underlying the development of applications for iOS (known as MVVM) and an explanation of a fundamental component of understanding the Swift programming language: its type system. Then both of these are applied to the Memorize application started in the first two lectures.

It is impossible to develop applications for iOS using SwiftUI without using the MVVM architecture for organizing your code. This lecture explains what that is and then demonstrates how it works in the demonstration application, Memorize. SwiftUI development happens entirely in the programming language Swift. Swift is unique in its support of most modern language features, including object-oriented programming, functional programming and protocol-oriented programming. Since much of this is new to most Stanford students, this lecture starts the process of explaining how Swift works by covering the basics of its type system, including structs and classes, generics and functions as types. Memorize then moves to the next level, filling out its MVVM architecture by implementing the Model and ViewModel portions of the application while using both generics and functions as types along the way.

1h31m

Lecture 4: Memorize Game Logic

The series of video lectures given to Stanford University students in Spring of 2021 continues by completing the MVVM architecture in the Memorize demo by using the ViewModel to build the View. Swift’s powerful enumeration syntax is introduced, along with the specific enum Optional. The lecture concludes with using the Optional construct in Memorize as part of finishing off its game logic.

The Swift Programming Language’s semantics for enumerations is particularly powerful and contrasts with many of the languages taught in introductory Stanford computer science courses. Enumerations in Swift allow for storing data in each matching case, creating helper methods directly on the enumeration, pattern-matching in switch statements, and more. Furthermore, a vast number of standard Swift libraries utilize the enumeration Optional in their functionality, and the Swift Programming Language adds useful syntax for manipulating Optionals. Optionals also find use in graceful error-handling when an operation may or may not succeed in returning a desired value. This is applied directly in Memorize in the final demonstration, and the lecture concludes with the major features of Memorize in a working state.

1h25m

Lecture 5: Properties Layout @ViewBuilder

Video 5 of the SwiftUI development lecture series given at Stanford during the Spring quarter of 2021 starts off by redefining the need and use cases for @State, while more specifically explaining its memory usage. More broadly in this lecture, the concept of properties is expanded to include computed properties and property observers. We then move on to the next major topic: the architecture for laying Views out on screen. This includes more details about combiner Views, some tools to modify a View's layout such as GeometryReader, overlay, and background, along with the @ViewBuilder directive which provides syntactical support for building (sometimes conditional) lists of Views. Many of these are demonstrated in the Memorize game by automatically sizing the game’s emoji font to fit the available space. Along the way, the “access control” on the internal APIs of Memorize is tightened up and numerous XCode features such as rename and fold are demonstrated.

1h22m

Lecture 6: Protocols Shapes

Lecture 6 of Stanford’s CS193p SwiftUI development course given during the Spring of 2021 finished off the discussion of the Swift Type System with an explanation of perhaps the most important kind of type in Swift: protocols. We touch on a number of protocol concepts, including a "constrains and gains" conceptualization of protocol extensions, the use of generics and protocols together, and protocol inheritance. After combining the concepts of protocols and generics in the Memorize game to size the cards to fit the available space on screen by creating an AspectVGrid, the lecture moves on to the topic of drawing arbitrary shapes using the Shape protocol. We take a look back at previously employed modifiers to Shape like .fill() which we can now more deeply understand through our studies of generics and protocols. We conclude this lecture by enhancing our Memory game to draw the pie-shaped countdown timer, using a custom Shape and ViewBuilder, which will be animated in the next lecture.

1h10m

Lecture 7: ViewModifier Animation

Lecture 7 of Stanford’s CS193p iOS Development course from Spring of 2021 begins with an explanation of ViewModifier, including a demonstration of how to create a custom Cardify ViewModifier for the Memorize game. The lecture then transitions into an in-depth look at animation, covering topics such as implicit vs. explicit animations, Animation structs, transitions, matched geometry effects, the impact of container views, Shape animations, animating ViewModifiers and more. We begin the first part of a two-lecture-long demo by illustrating how to use implicit animation to spin an emoji when a card is successfully matched in our Memorize game. Throughout this process, we constantly refer back to some golden rules of animation, and demonstrate how to use them to diagnose problems when our animations fail to behave as we expect.

1h24m

Lecture 8: Animation Demonstration

After having learned all about animation in the previous lecture, video 8 of Stanford’s CS193p iOS Development course from Spring 2021 is entirely comprised of demonstrations showing how to use animation to enhance our Memorize game. We learn how to animate the appearance (dealing out) of the cards using matchedGeometryEffect, the flipping of the cards using AnimatableModifier, the shuffling and choosing of the cards using explicit animation, and the counting down of bonus time on a card by animating the pie Shape from a previous lecture. We also discuss how to delay animations and use @State with animation.

1h32m

Lecture 9: EmojiArt Drag and Drop Multithreading

Lecture 9 of Stanford’s iOS Development course from Spring 2020 begins with a few miscellaneous topics (Collections of Identifiables, UIColor, UIImage and Item Providers) and then launches into a completely new demonstration, EmojiArt, first reviewing MVVM and then using SwiftUI API such as enums, initializers, extensions, tuples and Drag and Drop to create the beginnings of an “emoji artist’s” tool.  After the demo, the concept of multithreading using Grand Central Dispatch is explained in preparation for supporting the drag and drop of an image from the internet into EmojiArt in the next lecture.

1h25m

Lecture 10: Multithreading Demo Gestures

After demonstrating how to use multithreading to keep the downloading of a dragged and dropped background image from the internet from blocking the responsiveness of EmojiArt, lecture 10 of Stanford’s CS193p iOS Development course from Spring 2021 moves on to cover how to handle multitouch gestures.  Pinch and drag gestures are added to EmojiArt to zoom in and pan around to see our “works of (emoji) art” in more glorious detail.