dreamapplehappy / 100-days-of-swift

Days 36-46: Scaling up to bigger apps

Day 35: Consolidation III

Days 26-34: Expanding your skills

• Day 34 – Project 6, part three notes

  • Animation: Wrap up
  • Review for Project 6: Animation

• Day 33 – Project 6, part two notes

  • Controlling the animation stack
  • Animating gestures
  • Showing and hiding views with transitions
  • Building custom transitions using ViewModifier

• Day 32 – Project 6, part one notes

  • Animation: Introduction
  • Creating implicit animations
  • Customizing animations in SwiftUI
  • Animating bindings
  • Creating explicit animations

• Day 31 – Project 5, part three notes

  • Word Scramble: Wrap up
  • Review for Project 5: Word Scramble

• Day 30 – Project 5, part two notes

  • Adding to a list of words
  • Running code when our app launches
  • Validating words with UITextChecker

• Day 29 – Project 5, part one notes

  • Word Scramble: Introduction
  • Introducing List, your best friend
  • Loading resources from your app bundle
  • Working with strings

• Day 28 – Project 4, part three notes

  • BetterRest: Wrap up
  • Review for Project 4: BetterRest

• Day 27 Project 4, part two notes

  • Building a basic layout
  • Connecting SwiftUI to Core ML
  • Cleaning up the user interface

• Day 26 – Project 4, part one notes

  • BetterRest: Introduction
  • Entering numbers with Stepper
  • Selecting dates and times with DatePicker
  • Working with dates
  • Training a model with Create ML

Day 25: Consolidation II

• Day 25 – Milestone: Projects 1-3 notes
  • What you learned
  • Key points
  • Challenge

Days 16-24: Starting SwiftUI

• Day 24 – Project 3, part two notes

  • Views and modifiers: Wrap up
  • Review for Project 3: Views and Modifiers

• Day 23 – Project 3, part one notes

  • Views and modifiers: Introduction
  • Why does SwiftUI use structs for views?
  • What is behind the main SwiftUI view?
  • Why modifier order matters
  • Why does SwiftUI use “some View” for its view type?
  • Conditional modifiers
  • Environment modifiers
  • Views as properties
  • View composition
  • Custom modifiers
  • Custom containers

• Day 22 – Project 2, part three notes

  • Guess the Flag: Wrap up
  • Review for Project 2: Guess the Flag

• Day 21 – Project 2, part two notes

  • Stacking up buttons
  • Showing the player’s score with an alert
  • Styling our flags

• Day 20 – Project 2, part one notes

  • Guess the Flag: Introduction
  • Using stacks to arrange views
  • Colors and frames
  • Gradients
  • Buttons and images
  • Showing alert messages

• Day 19 – Challenge day notes

• Day 18 – Project 1, part three notes

  • WeSplit: Wrap up
  • Review for Project 1: WeSplit

• Day 17 – Project 1, part two notes

  • Reading text from the user with TextField
  • Creating pickers in a form
  • Adding a segmented control for tip percentages
  • Calculating the total per person

• Day 16 - Project 1, part one notes

  • WeSplit: Introduction
  • Understanding the basic structure of a SwiftUI app
  • Creating a form
  • Adding a navigation bar
  • Modifying program state
  • Binding state to user interface controls
  • Creating views in a loop

Days 13-15: Consolidation I

• Day 15 - Swift review, day three notes

  • 1.Properties
  • 2.Static properties and methods
  • 3.Access control
  • 4.Polymorphism and typecasting
  • 5.Closures

• Day 14 - Swift review, day two notes

  • 1.Functions
  • 2.Optionals
  • 3.Optional chaining
  • 4.Enumerations
  • 5.Structs
  • 6.Classes

• Day 13 - Swift review, day one notes

  • 1.Variables and constants
  • 2.Types of Data
  • 3.Operators
  • 4.String interpolation
  • 5.Arrays
  • 6.Dictionaries
  • 7.Conditional statements
  • 8.Loops
  • 9.Switch case

Days 1-12: Introduction to Swift

• Day 12 - optionals, unwrapping, and typecasting notes

  • 1.Handling missing data
    • Optional: Why does Swift have optionals?
    • Test: Handling missing data
  • 2.Unwrapping optionals
    • Optional: Why does Swift make us unwrap optionals?
    • Test: Unwrapping optionals
  • 3.Unwrapping with guard
    • Optional: When to use guard let rather than if let
    • Test: Unwrapping with guard
  • 4.Force unwrapping
    • Optional: When should you force unwrap optionals in Swift?
    • Test: Force unwrapping
  • 5.Implicitly unwrapped optionals
    • Optional: Why does Swift need both implicitly unwrapped optionals and regular optionals?
    • Test: Implicitly unwrapped optionals
  • 6.Nil coalescing
    • Optional: When should you use nil coalescing in Swift?
    • Test: Nil coalescing
  • 7.Optional chaining
    • Optional: Why is optional chaining so important?
    • Test: Optional chaining
  • 8.Optional try
    • Optional: When should you use optional try?
    • Test: Optional try
  • 9.Failable initializers
    • Optional: Why would you want a failable initializer?
    • Test: Failable initializers
  • 10.Typecasting
    • Optional: When is type casting useful in Swift?
    • Test: Typecasting
  • 11.Optionals summary
    • Test: Optionals

• Day 11 - protocols, extensions, and protocol extensions notes

  • 1.Protocols
    • Optional: Why does Swift need protocols?
    • Test: Protocols
  • 2.Protocol inheritance
    • Optional: When should we use protocol inheritance?
    • Test: Protocol inheritance
  • 3.Extensions
    • Optional: When should you use extensions in Swift?
    • Test: Extensions
  • 4.Protocol extensions
    • Optional: When are protocol extensions useful in Swift?
    • Test: Protocol extensions
  • 5.Protocol-oriented programming
    • Optional: How is protocol-oriented programming different from object-oriented programming?
    • Test: Protocol-oriented programming
  • 6.Protocols and extensions summary
    • Test: Protocols and extensions

• Day 10 - classes and inheritance notes

  • 1.Creating your own classes
    • Optional: Why does Swift have both classes and structs?
    • Test: Creating your own classes
  • 2.Class inheritance
    • Optional: Why don’t Swift classes have a memberwise initializer?
    • Test: Class inheritance
  • 3.Overriding methods
    • Optional: When would you want to override a method?
    • Test: Overriding methods
  • 4.Final classes
    • Optional: Which classes should be declared as final?
    • Test: Final classes
  • 5.Copying objects
    • Optional: Why do copies of a class share their data?
    • Test: Copying objects
  • 6.Deinitializers
    • Optional: Why do classes have deinitializers and structs don’t?
    • Test: Deinitializers
  • 7.Mutability
    • Optional: Why can variable properties in constant classes be changed?
    • Test: Mutability
  • 8.Classes summary
    • Test: Classes

• Day 9 - access control, static properties, and laziness notes

  • 1.Initializers
    • Optional: How do Swift’s memberwise initializers work?
    • Test: Initializers
  • 2.Referring to the current instance
    • Optional: When would you use self in a method?
    • Test: Referring to the current instance
  • 3.Lazy properties
    • Optional: When should properties be lazy?
    • Test: Lazy properties
  • 4.Static properties and methods
    • Optional: What’s the point of static properties and methods in Swift?
    • Test: Static properties and methods
  • 5.Access control
    • Optional: What’s the point of access control?
    • Test: Access control
  • 6.Structs summary
    • Test: Structs

• Day 8 - structs, properties, and method notes

  • 1.Creating your own structs
    • Optional: What’s the difference between a struct and a tuple?
    • Test: Creating your own structs
  • 2.Computed properties
    • Optional: When should you use a computed property or a stored property?
    • Test: Computed properties
  • 3.Property observers
    • Optional: When should you use property observers?
    • Optional: When should you use willSet rather than didSet?
    • Test: Property observers
  • 4.Methods
    • Optional: What’s the difference between a function and a method?
    • Test: Methods
  • 5.Mutating methods
    • Optional: Why do we need to mark some methods as mutating?
    • Test: Mutating methods
  • 6.Properties and methods of strings
    • Optional: Why are strings structs in Swift?
    • Test: Properties and methods of strings
  • 7.Properties and methods of arrays
    • Optional: Why do strings behave differently from arrays in Swift?
    • Test: Properties and methods of arrays

• Day 7 - Closures, part two notes

  • 1.Using closures as parameters when they accept parameters
    • Optional: When would closures with parameters be used as parameters?
    • Test: Using closures as parameters when they accept parameters
  • 2.Using closures as parameters when they return values
    • Optional: When would you use closures with return values as parameters to a function?
    • Test: Using closures as parameters when they return values
  • 3.Shorthand parameter names
    • Optional: When should you use shorthand parameter names?
    • Test: Shorthand parameter names
  • 4.Closures with multiple parameters
    • Optional: How many parameters can a closure take?
    • Test: Closures with multiple parameters
  • 5.Returning closures from functions
    • Optional: Returning closures from functions
    • Test: Returning closures from functions
  • 6.Capturing values
    • Optional: Why do Swift’s closures capture values?
    • Test: Capturing values
  • 7.Closures summary
    • Test: Closures

• Day 6 – Closures, part one notes

  • 1.Creating basic closures
    • Optional: What the heck are closures and why does Swift love them so much?
    • Test: Creating basic closures
  • 2.Accepting parameters in a closure
    • Optional: Why are Swift’s closure parameters inside the braces?
    • Test: Accepting parameters in a closure
  • 3.Returning values from a closure
    • Optional: How do you return a value from a closure that takes no parameters?
    • Test: Returning values from a closure
  • 4.Closures as parameters
    • Optional: Why would you want to use closures as parameters?
    • Test: Closures as parameters
  • 5.Trailing closure syntax
    • Optional: Why does Swift have trailing closure syntax?
    • Test: Trailing closure syntax

• Day 5 – Functions notes

  • 1.Writing functions
    • Optional: What code should be put in a function?
    • Test: Writing functions
  • 2.Accepting parameters
    • Optional: How many parameters should a function accept?
    • Test: Accepting parameters
  • 3.Returning values
    • Optional: When is the return keyword not needed in a Swift function?
    • Optional: How can you return two or more values from a function?
    • Test: Returning values
  • 4.Parameter labels
    • Optional: Why does Swift use parameter labels?
    • Test: Parameter labels
  • 5.Omitting parameter labels
    • Optional: When should you omit a parameter label?
    • Test: Omitting parameter labels
  • 6.Default parameters
    • Optional: When to use default parameters for functions
    • Test: Default parameters
  • 7.Variadic functions
    • Optional: When to use variadic functions
    • Test: Variadic functions
  • 8.Writing throwing functions
    • Optional: When should you write throwing functions?
    • Test: Writing throwing functions
  • 9.Running throwing functions
    • Optional: Why does Swift make us use try before every throwing function?
    • Test: Running throwing functions
  • 10.inout parameters
    • Optional: When should you use inout parameters?
    • Test: inout parameters
  • 11.Functions summary
    • Test: Test

• Day 4 – loops, loops, and more loops notes

  • 1.For loops
    • Optional: Why does Swift use underscores with loops?
    • Test: For loops
  • 2.While loops
    • Optional: When should you use a while loop?
    • Test: While loops
  • 3.Repeat loops
    • Optional: When should you use a repeat loop?
    • Test: Repeat loops
  • 4.Exiting loops
    • Optional: Why would you want to exit a loop?
    • Test: Exiting loops
  • 5.Exiting multiple loops
    • Optional: Why does Swift have labeled statements?
    • Test: Exiting multiple loops
  • 6.Skipping items
    • Optional: When to use break and when to use continue
    • Test: Skipping items
  • 7.Infinite loops
    • Optional: Why would you want to make an infinite loop?
    • Test: Infinite loops
  • 8.Looping summary
    • Test: Looping

• Day 3 – operators and conditions notes

  • 1.Arithmetic Operators
    • Optional: Why can’t Swift add a Double to an Int?
    • Optional: Why does Swift have a dedicated division remainder operator?
    • Test: Arithmetic operators
  • 2.Operator overloading
    • Optional: Why does Swift need operator overloading?
    • Test: Operator overloading
  • 3.Compound assignment operators
    • Optional: Why does Swift have compound assignment operators?
    • Test: Compound assignment operators
  • 4.Comparison operators
    • Optional: How does Swift let us compare many types of data?
    • Test: Comparison operators
  • 5.Conditions
    • Optional: What’s the difference between if and else if?
    • Test: Conditions
  • 6.Combining conditions
    • Optional: How to check multiple conditions
    • Test: Combining conditions
  • 7.The ternary operator
    • Optional: When should you use the ternary operator in Swift?
    • Test: The ternary operator
  • 8.Switch statements
    • Optional: When should you use switch statements rather than if?
    • Test: Switch statements
  • 9.Range operators
    • Optional: Why does Swift have two range operators?
    • Test: Range operators
  • 10.Operators and conditions summary
    • Test: Operators and conditions

• Day 2 arrays, dictionaries, sets, and enums notes

  • 1.Arrays
    • Optional: Why does Swift have arrays?
    • Test: Arrays
  • 2.Sets
    • Optional: Why are sets different from arrays in Swift?
    • Test: Sets
  • 3.Tuples
    • Optional: How are tuples different from arrays in Swift?
    • Test: Tuples
  • 4.Arrays vs sets vs tuples
    • Optional: When should you use an array, a set, or a tuple in Swift?
    • Test: Arrays vs sets vs tuples
  • 5.Dictionaries
    • Optional: Why does Swift have dictionaries as well as arrays?
    • Test: Dictionaries
  • 6.Dictionary default values
    • Optional: Why does Swift have default values for dictionaries?
    • Test: Dictionary default values
  • 7.Creating empty collections
    • Optional: Why would you want to create an empty collection?
    • Test: Creating empty collections
  • 8.Enumerations
    • Optional: Why does Swift need enums?
    • Test: Enumerations
  • 9.Enum associated values
    • Optional: Why would you want to associate a value with an enum case?
    • Test: Enum associated values
  • 10.Enum raw values
    • Optional: Why do Swift’s enums have raw values?
    • Test: Enum raw values
  • 11.Complex types: Summary
    • Test: Complex types

• Day 1 – variables, simple data types, and string interpolation notes

  • 1.Variables
    • Optional: Why does Swift have variables?
    • Test: Variables
  • 2.Strings and integers
    • Optional: Why is Swift a type-safe language?
    • Test: Strings and integers
  • 3.Multi-line strings
    • Optional: Why does Swift need multi-line strings?
    • Test: Multi-line strings
  • 4.Doubles and Booleans
    • Optional: Why does Swift need both Doubles and Integers?
    • Test: Doubles and Booleans
  • 5.String interpolation
    • Optional: Why does Swift have string interpolation?
    • Test: String interpolation
  • 6.Constants
    • Optional: Why does Swift have constants as well as variables?
    • Test: Constants
  • 7.Type annotations
    • Optional: Why does Swift have type annotations?
    • Test: Type annotations
  • 8.Simple types: Summary
    • Test: Simple types