Practical Programming For Swift & iOS Development

Welcome to my Practical guide to becoming an iOS developer using Swift UIKit and SwiftUI.

From absolute beginner to junior level software developer, this course will guide you from little to zero coding experience, all the way to launching your first apps.

Curriculum includes the following:

1. Swift coding fundamentals (variables, types, logic, functions, loops)

2. Building our first UI (starting with UIKit, then SwiftUI)

3. Navigation flow

4. App architecture (MVC vs MVVM) and dependency injection

5. Data structures & basic algorithms, and more Xcode

6. Network calls to APIs and third party SDKs

7. CRUD operations using various databases

8. Source control using Github

9. Debugging and unit testing

10. App deployment

11. Building our portfolio

The journey to becoming a software developer won't be fast or easy, but the person you become through your struggles will be well worth the effort!  If you're looking to change your career and the trajectory of your life, have faith in yourself and know that you CAN accomplish anything you put your mind to!

My name is Ryan Kanno, and I'm a self-taught iOS developer currently working in tech.  In college I majored in business, graduated in 2014 and worked as a bank teller, an Uber driver, a tour van driver, a semi-truck driver, taught myself how to code in 2020, and finally became a software developer in 2021.

The pain, struggle, and self doubt I felt when applying for jobs is still very memorable, and by making this course my hope is to help your journey to become a software developer at least a little easier.  Let's change our lives and learn how to code using Swift!

Download Xcode from your App Store or the Apple website.

An app is just data, and code is just a list of instruction for our computer to execute in a logical way.

Computers are "dumb", but they will follow EXACTLY what we tell them to do very quickly!

There's no magic in coding, everything happens for a reason.

Variables allow you to store and manipulate data in our program.  They act as placeholders for different types of information, such as text, whole numbers, decimal numbers, etc.

Variable declaration:
var age: Int = 20

• var indicates that this variable is mutable / changeable

• age is the name of the variable

• Int is the type of data

• = is the symbol we use to set the data to the following value

• 20 is the value that we're setting to the variable named age

Similarly:
let name: String = "Bob"

• let indicates that this variable is a constant / NOT changeable

Swift is a strongly typed language:

• The value of a variable can be mutated / changed but using the = symbol to set the new value.

• The value of a variable can only be changed to another value of the same type.  i.e. if we have a variable age of type Int, we can't change / set the value to be "zero", because "zero" is a String, which is a different data type.

Naming conventions:

The Swift programming language is case sensitive, and the convention for declaring variables is to start the variable name with a lowercase.

If we have a long name for a variable comprised of multiple words, we can use camel casing to separate words and make it more readable.  Although we could use an underscore (snake casing) when naming a variable, it is NOT the Swift convention, and you won't see in the wild. 

Camel casing example (Do this):
let minutesNeededForCooking: Int = 60

Snake casing example (Don't do this):
let minutes_needed_for_cooking: Int = 60

If statements are our first type of logic we can introduce to our program.

Example:
var number: Int = 10
if number > 5 {
   // do something
}

The if statement evaluates a conditional to see if it's true or false.  If the condition is true, it will then execute the code within the following curly brackets.  If the condition is false, it won't, and will continue executing any code thereafter.

Here we learn the following comparative operators:

• > greater than

• < less than

• == is equal to

• != is not equal to

• >= greater than or equal to

• <= less than or equal to

If statements can also include multiple conditions we can check for by using an else if after the initial if statement.

Finally, an else statement can also be used as a "catch all" if none of the preceding conditional checks were met.

Example:
var number: Int = 10
if number > 7 {
   // do something
} else if number > 5 {
   // do something else
} else {
   // default action
}

If statements (conditional checks) might need to check multiple conditions before executing certain actions.  These can be done with the && operator (equivalent to the English word and) and the || operator (equivalent to the English word or).

Example:
var number: Int = 10
if number > 5 && number < 15 {
   // do something
} else if number <=5 || number >= 15 {
   // do something else
}

We'll start building our first UI (user interface) using Storyboard from the UIKit framework.

SwiftUI is Apple's newer, and recommended UI framework, but many companies still use UI components created via UIKit.

SwiftUI was built on top of UIKit, and there are still some aspects of it that haven't been completely translated over from UIKit yet.  However, as SwiftUI continues to improve, I'm sure we'll get those updates in the near future.

UIKit is simpler and more verbose, but I think it's easier for beginners to grasp basic concepts in this framework first.

Functions are an integral concept used across all programming languages.  Functions are tools that may execute multiple actions each time it's called.  Similarly to variables, functions have their own function declaration syntax:

func doSomething(item: String) -> String {
   // do stuff
   return "some string"
}

• func - keyword

• doSomething - name of the function

• (item: String) - name and type of the parameter(s)

• -> String - type of the returned value

• return - returns the data of the specified type

Functions are an integral concept used across all programming languages.  Functions are tools that may execute multiple actions each time it's called.  Similarly to variables, functions have their own function declaration syntax:

func doSomething(item: String) -> String {
   // do stuff
   return "some string"
}

• func - keyword

• doSomething - name of the function

• (item: String) - name and type of the parameter(s)

• -> String - type of the returned value

• return - returns the data of the specified type

Functions are an integral concept used across all programming languages.  Functions are tools that may execute multiple actions each time it's called.  Similarly to variables, functions have their own function declaration syntax:

func doSomething(item: String) -> String {
   // do stuff
   return "some string"
}

• func - keyword

• doSomething - name of the function

• (item: String) - name and type of the parameter(s)

• -> String - type of the returned value

• return - returns the data of the specified type

Assignment operators are convenient and concise ways to perform arithmetic and set the value to the variable.

Here we have a variable:
var number: Int = 5

• number += 1 (number = number + 1)

• number -= 1 (number = number - 1)

• number *= 2 (number = number * 2)

• number /= 2 (number = number / 2)

Classes are an integral component when it comes to Object Oriented Programming (OOP).  Although Swift is technically classified as a Protocol Oriented Programming(POP) language, many OOP concepts still form the basic foundation for continuing our coding journey.

As we previously learned, each variable has a specified type, which could also be thought of as an object.  Objects are more complex data structures that contain other variables (also known as properties), and often times methods (also known as functions).  These objects can be used to organize our code into an organized collection of related variables and functions for us to better understand its intended usage.

Example class:
class Vehicle {
   var wheels: Int = 4
   var windows: Int = 4
   var engine: Int = 1

   func startEngine() {
      print("Start engine.")
   }

   func stopEngine() {
      print("Stop engine.")
   }
}

Here we have a class object called Vehicle, which contains 3 variable properties and 2 functions.  We can then use this object as a variable, and access its properties and functionality using dot notation.

Example dot notation:
var car = Vehicle()
print(car.wheels)
car.startEngine()