DEV Community: Fernando Martín Ortiz

This week I learned #1

Fernando Martín Ortiz — Sun, 07 Jan 2024 21:09:41 +0000

On these posts, I will list what I learned, or discovered, or reflected about during the last week. I believe that, by doing this, I will learn much better and keep learnings at a good pace. Also, as a byproduct, probably some readers will also learn something from these, or maybe they think I’m wrong and would like to comment something, so we can debate.

In any case, welcome every one.

Life/Work balance:

Working from home is amazing, and it’s much more amazing when you can share time with your partner and child. Seeing my baby grow, and being able to spend more time with him is much better than any benefit I could get.

Python:

Virtual environments are a mess. It’s much better to use Docker. There is an extension on Visual Studio Code called “Dev Containers”. It’s developed by Microsoft, and lets you run a terminal on a Docker Container, with the content of your VS Code project.

Elixir:

GenServer is the default way of handling state in Elixir. A GenServer stands for “Generic Server”, and it’s a process which run an contains a piece of state. You can send messages to that GenServer process by using its process ID (or pid), and mutate that state in a very “functional” way.
A module you own should use GenServer to be usable as a GenServer. Think of it as an interface being implemented.
If you include your GenServer as an application children, then the module you send to it is started as a process right away when the app starts.

Web Development:

Microsoft Azure has a service called Azure Container Apps, in which every app is containerized using Docker. All the apps (you can think of them as microservices) communicate using a Virtual Network (v-net).
Microsoft Azure has a language (DSL) called Bicep, which is similar to AWS CloudFoundation, to maintain infrastructure using IaC.
DAPR (Distributed Apps Runtime) is an initiative that was started by Microsoft, and nowadays maintained by the Cloud Native Foundation. Using DAPR, you can use the services defined on the standard to communicate with other microservices, handle state (using Redis, for example), add Telemetry, use Pub/Sub mechanisms, and other things. The specs defined in DAPR are like “abstract classes”. There is always an actual “component” which implements the spec. For example, you use the DAPR state management service, but under the hood, you’re using Redis to keep track of key/value pairs for that state.

Artificial Intelligence:

This week, I’ve been reading content and preparing myself for an upcoming project that will use LLMs.
This article is amazing: The architecture of today's LLM applications

IoT:

I’m preparing myself to work on internet of things projects using Nerves.
Nerves is a tool written in Elixir for creating IoT applications.
You can actually run Nerves project without having an actual device (like a Raspberry pi)! This is called “Host Mode”.

What’s the model?

Fernando Martín Ortiz — Fri, 05 Nov 2021 01:28:22 +0000

I teach iOS development as a side job. I work 9-5 (well, actually, it’s a bit earlier than that, since I’m working for an English company at this moment). After I finish working, three times a week, I teach iOS development to different people, for two hours. They are starting their careers, and they are developing their intuition about software engineering.

That’s really interesting from the point of view of somebody who has been in the industry for some years now. It’s good to remember how you started and what errors did you make at the beginning.

Today, I’m going to talk to you about an error I see over and over again, and recently, I think I reached a way of making people think about it, and reason about it.

Imagine you are developing an app for ordering food from restaurants:

You have a listwith different dishes and options.
You can add more units of any of the options you have in the list.
Each item in the list has the number of items of that type you’ve already added, it will let you add or sub any number of items at any moment.
Whenever you add food, there is a shopping cart or something like that at the bottom of the screen where you can see immediately updated the price of the food you’re buying.

Fairly simple, straightforward problem.

So, here is the thing. There are many ways on how to develop something like that. Imagine you’re using UIKit for now, and not SwiftUI. You would have tableView or collectionView cells for the items in the list, and you would sum to the amount that you have in the bottom.

This is how people tend to design these kind of apps when they start:

They detect the event to add more items of a certain type.
They check the label in the cell to know how many items of that type they have already added.
They add one to that number.
They update the label in the cell.

And they have similar solutions for the different parts of the UI in this and similar problems. They rely on the UI as the source of truth.

So I started to ask them: What is the model?. I start any exercise with them in the same way. Regardless of how simple of complex a screen is, I start asking them: What is the model in this UI?

The other thing that’s related to this I use to tell them from the very beginning is: We are UI developers. As UI developers, our goal isn’t only to deliver delightful UIs with animations and beatiful graphics. Our goal is to ensure consistency between the model and the UI. The part about the UI is usually easily understandable. The part about the model is very hard to understand when you’re starting.

Our goal is to ensure consistency between the model and the UI. You have a UI, what is the model?

Navigation in iOS apps

Fernando Martín Ortiz — Mon, 03 May 2021 22:13:37 +0000

Note: This article is part of the course Introduction to iOS using UIKit I've given many times in the past. The course was originally in Spanish, and I decided to release it in English so more people can read it and hopefully it will help them.

Introduction

So far, we've seen example applications where we only had a single view in the screen. In real world apps we have several screens per app. The user starts their journey in one of them but depending on the actions they take, the app will show them other screens.
The ability of moving between screens in an app is called navigation.

Stacks

What is a stack?

A stack is a data structure in which we can insert elements.
Whenever we add an element to the stack (push), it will be put at the top.
If we remove an element from the stack (pop), we'll always remove the top element in the stack, so the element that was below the top, will become the top after that.

Navigation Stack

In iOS, navigation works using one or many stacks. Each element in the navigation stack is a screen, and each screen is represented by a UIViewController.
The element (screen) that is in the top of the navigation stack is the screen that's visible to the user in the app.

Present/Dismiss

There is a "global" navigation stack in iOS. We don't have to do anything to create it. Just by creating an app in iOS, we'll have that global navigation stack ready to be used.
Every UIViewController subclass have a present and a dismiss methods.

Let's see an example:

If we want to navigate from FirstScreenViewController to SecondScreenViewController, we need to:

Instantiate SecondScreenViewController from a method on FirstScreenViewController.
Call the present method right after that, passing to it the SecondScreenViewController instance, a Bool indicating whether we want to present the screen using an animation transition, and optionally, also a closure that will be executed as soon as the transition has finished.

class FirstScreenViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
    }

    @IBAction func navigateButtonPressed() { 
        let secondViewController = SecondViewController()
        present(secondViewController, animated: true, completion: nil)
    }
}

Video

Optionally, we can configure the property modalPresentationStyle in SecondScreenViewController with the value UIModelPresentationStyle.fullScreen before navigating to it, so the destination view controller will fit the full size of the screen.

@IBAction func navigateButtonPressed() {
    let secondViewController = SecondViewController()
    secondViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen
    present(secondViewController, animated: true, completion: nil)
}

Video

The problem we have now is that, as it's now fullscreen, we can't go back to the first screen anymore. To avoid this, we can configure an action in the second screen, using the dismiss method.

The dismiss method takes two parameters: a Bool indicating if we want an animated transition, and an optional closure, in case we want to execute custom code after the transition has finished.

@IBAction func goBackButtonScreen() {
    dismiss(animated: true, completion: nil)
}

Video

UINavigationController

However, the practice of doing present/dismiss is commonly used to show a modal to the user in specific situatioons.

Most commonly, we'll use UINavigationController, which is a class that contains an internal navigation stack.

To add a screen/controller to a UINavigationController, we'll use the push method.

To remove a screen/controller from a UINavigationController, we'll use the pop method.

A UINavigationController is instantiated with a UIViewController that's called the root view controller, and that will be the bottom of the stack.

In addition, using a UINavigationController gives us a view at the top of our screens that's called UINavigationBar, that contains the current screen title, helper buttons at the sides, and back button, among others.

Let's try to modify the second screen of our app, so that it will be contained inside a UINavigationController.

Remember this action:

@IBAction func navigateButtonPressed() {
    let secondViewController = SecondViewController()
    secondViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen
    present(secondViewController, animated: true, completion: nil)
}

We'll modify it so that secondViewController will be inside a UINavigationController.

@IBAction func navigateButtonPressed() {
    let secondViewController = UINavigationController(rootViewController: SecondViewController())
    secondViewController.modalPresentationStyle = UIModalPresentationStyle.fullScreen
    present(secondViewController, animated: true, completion: nil)
}

The view that we see at the top is the UINavigationBar.

Something we can do to personalize it, is to assign a title to it. To do so, we'll modify the property title in the view controller:

class SecondViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        title = "Second"
    }

    @IBAction func goBackButtonPressed() {
        dismiss(animated: true, completion: nil)
    }
}

In order to perform a transition in a UINavigationController we need to:

Create another screen. I mean, a new UIViewController
Inside SecondScreenViewController, perform a push to the third screen.
To do this push, let's keep in mind that the class UIViewController has an optional property called navigationController with type UINavigationController?.

@IBAction func thirdScreenButtonPressed() {
    let thirdViewController = ThirdScreenViewController()
    navigationController?.pushViewController(thirdViewController, animated: true)
}

Video

You might have noticed that the navigation bar automatically adds a button to return to the previous screen. If we want to do a back navigation programmatically, we'll use the pop method from UINavigationController.

Small comment: to add a padding to the button, we can set the content insets of it in the attributes inspector

@IBAction func popButtonPressed() {
    navigationController?.popViewController(animated: true)
}

Video

Passing data

How could we send data from one screen to the next one. The answer is, that before performing the navigation, we can set a variable in the destination UIViewController.
We must NEVER configure a view on the destination controller, because they aren't initialized until the navigation is committed.

Using Xibs

Fernando Martín Ortiz — Mon, 03 May 2021 21:20:22 +0000

What is a Storyboard?

A Storyboard is one way of using Interface Builder for designing and developing views in iOS. Each Storyboard described one or many screens. Each screen in a Storyboard is linked to a UIViewController.
We can navigate between the screens that are designed using Storyboards using Segues.
In theory, it isn't required for us to instantiate view controllers manually if we decide to use Storyboards, because the navigation between them and the data that we need to pass between a screen to the next one, is all handled using segues.
In practice, this pattern can result not as intuitive as we want.

What is a XIB?

A Xib is another way of using Interface Builder for designing and developing view in iOS. Each Xib describes a single screen. As in Storyboards, each screen in a Xib is linked to a UIViewController.
Navigation between screens are defined outside of the Xib file, by manually instantiating controllers using their init method, as we've seen during the second lesson about Swift.

Which one are we going to use?

During this course, we'll use Xibs, because of a couple of reasons:

It's the most widely used way to develop views in the industry right now.
A Xib file loads quicker than a Storyboard in Xcode, because Xib files are much smaller. In a bigger project, with bigger Storyboards, this is even more important.
A Xib is commonly placed alongside its Swift counterpart. In a Storyboard, if we're looking for a specific view, this is slightly more inconvenient.
Instantiating a controller in code is more intuitive and it's more consistent with other patterns in iOS.

Base App

When we create a project in Xcode, it's created using Storyboards. Adapting it to use Xibs instead of Storyboards is a boring task that doesn't teach us much.
In order to avoid doing that, you can download this template from my Github.

Important: When you've downloaded it, open TutorialApp.xcworkspace.

In order to create a screen:

Create a folder (group), by right-clicking the group Application and selecting the option New Group.

Inside the new group, right-click and choose New File...

Choose iOS > Cocoa Touch Class.

Enter a name for the new screen, taking care that it's finished with ViewController, and that's a Subclass of: UIViewController, and also that the option Also create XIB file is checked (and that the language is Swift).

Save it in the default location.

And that's it. We've created our first screen using Xibs instead of Storyboards. In the next tutorials, we'll continue doing this process to create other screens and navigating between them.

Introduction to Swift - Part 2

Fernando Martín Ortiz — Mon, 03 May 2021 00:12:29 +0000

Object oriented programming

In every program we've got two well defined concepts: Data and behavior.
A tuple with five fields that define an address is data.
A function that takes that tuple and returns a String with its description is behavior.

Everything we've done so far in the first part of Swift introduction has been defining data on one side and the behavior that acts on that data in another, separated side, which has worked well for us so far. However, the most frequent way of organizing code in modern languages, such as Swift, is integrating data and behavior in cohesive structures such as the ones we'll see today, when we'll review Object oriented programming (OOP).

This will bring us some advantages. Especially, the ability to abstract. A class will have behavior that can be used from the outside. It means, we'll know what that class can do. However, the how is private to that class. That's known as encapsulation.

Class

A class is one of those structures that integrate data and behavior as a unit. Data inside a class is called attributes. Behavior inside a class is modeled as a set of functions known as methods.
In Swift, a class is defined using the keyword class followed by its name. Attributes will be variables, and methods will be functions.
Let's see an example of a class hierarchy and then we'll explain in detail what just has happened:

class Animal {
    var name: String
    var walks: [String]

    var animalType: String { return "" }

    init(name: String) {
        self.name = name
        self.walks = []
    }

    func emitSound() {}

    func walk(to place: String) {
        self.walks.append(place)
    }
}

class Dog: Animal {
    override var animalType: String { return "Dog" }
    override func emitSound() {
        print("\(name): Woof!")
    }
}

class Cat: Animal {
    override var animalType: String { return "Cat" }
    override func emitSound() {
        print("\(name): Meow!")
    }
}

class Person {
    private var name: String
    private var pets: [Animal]

    init(name: String, pets: [Animal]) {
        self.name = name
        self.pets = pets
    }

    func getHome() {
        print("\(name): gets home")
        for pet in pets {
            pet.emitSound()
        }
    }
}

let romina = Person(
    name: "Romina",
    pets: [
        Cat(name: "Fausto"),
        Dog(name: "Lupi")
    ]
)

romina.getHome()

It will print:

Romina: gets home
Fausto: Meow!
Lupi: Woof!

Inheritance

Ok, what just has happened here? First, we've defined a base class, called Animal. It's called base class because it's the class that will define the base of the class hierarchy, it will define the common set of data and behavior for the other classes in the hierarchy.

What can an animal do? (behavior). In this case, it can go for a walk, and it can emite a sound. What sound? We don't know that. The sound an animal emits will be define in its subclasses. That's called inheritance. An animal can either be a Cat or a Dog, in this example. So that, a Cat can say Meow, and define its type as "Cat", but it inherits all the behavior defined in its base class.

What do we know of an animal? (data). In this case, its name and the walks it has taken.

And animalType? It's a computed variable, or getter. A getter is essentially a function that returns a value. From the outside of a class, it's seen and it's used a variable that we can't change its value. It takes part of the behavior of a class.

Encapsulation

A class only exposes part of its data and behavior that we can use from its outside. What is internal to that class is defined with the keyword private. What is private can only be accessed from inside that class. What isn't marked as private is accessible from anywhere else in the app and it's known as the public interface for that class.

Init

The init method is an especial method of a class, that has the responsibility of define how an object of that class will be created. In this example, the Person class will have an init defined like this:

 init(name: String, pets: [Animal]) {
     self.name = name
     self.pets = pets
 }

self in this case refers to the same object on which we're working.

init doesn't have to be written in order to be used. Consider this example:

 let romina = Persona(
     name: "Romina",
     pets: [
         Cat(name: "Fausto"),
         Dog(name: "Lupi")
     ]
 )

Polymorphism

Functionality defined in a base class can be redefined with the keyword override in the subclasses. So for instance, emitSound doesn't have an actual functionality in the base class. But it does in its subclasses.
Subclasses "override" behavior from the base class. For instance:

 override func emitSound() {
     print("\(name): Meow!")
 }

What's interesting is that we can refer to dog and cats as Animal in the pets Array. Whenever we call pet.emitSound() we aren't sure if the pet is a cat or a dog, that's determined in runtime, where each object will execute the behavior defined by its specific subclass.

Protocol

A class answers the question What is this?

What is this? A Cat
What is this? A Dog
What is this? A Person

A protocol, on the other hand, answers the question What can this do?.
On its simplest form, a protocol (also called interface in other programming languages such as Java), is a set of method signatures under a name. Any class can implement a protocol. If a class implements a protocol, then it must implement all the methods defined on it. Otherwise, the code won't compile.

Let's see an example:

protocol EmitsSound {
    func emitSound()
}

class Animal {}

class Dog: Animal, EmitsSound {
    func emitSound() {
        print("Woof!")
    }
}

class Cat: Animal, EmitsSound {
    func emitSound() {
        print("Meow!")
    }
}

class Ringer: EmitsSound {
    func emitSound() {
        print("Ring!")
    }
}

Note here that:

A class can only inherit from a single class. However, it can implement as many protocols as we need. If a class inherits from another class and also implements protocols, what is written at the right of : must be first the base class, and then the protocols to be implemented.
A Dog, a Cat, and a Ringer are now of the same type. All of them are of the type EmitsSound. And as such, we can use them in an Array, for instance:

class SoundEffects {
    let sounds: [EmitsSound]

    init(sounds: [EmitsSound]) {
        self.sounds = sounds
    }

    func play() {
        for sound in sounds {
            sound.emitSound()
        }
    }
}

let getHomeSounds = SoundEffects(sounds: [Ringer(), Cat(), Dog()])
getHomeSounds.play()
// Ring!
// Meow!
// Woof!

As we've implemented EmitsSound for all our objects, regardless of their class, we can now use them to emit sounds. In this example, we use this to implement sound effects. In practice, this same principle is used a lot. Especially when all we need from other object is what it can do, regardless of what type it really is.

Struct

A struct is very similar to a class. Let's see some differences:

A class:

Has attributes and methods.
The attributes and methods it has may be private.
It can implement protocols.
It must implement a init method to initialize its attributes when it's instantiated.
It can inherit from other classes.

A struct:

Has attributes and methods.
The attributes and methods it has may be private.
It can implement protocols.
It is not necessary that it implements an init method to initialize its attributes in general. An init method is automatically generated.
It can't inherit from another class or struct.

A class also can't inherit from a struct.

protocol HasDescription {
    func getDescription() -> String
}

struct Address: HasDescription {
    let street: String
    let number: String
    let apartment: String
    let floor: String
    let city: City

    func getDescription() -> String {
        return "\(street) \(number) - Apt. \(floor)-\(apartment) - \(city.getDescription())"
    }
}

struct City: HasDescription {
    let name: String
    let state: State

    func getDescription() -> String {
        return "\(name), \(state.getDescription())"
    }
}

struct State: HasDescription {
    let name: String
    let country: String

    func getDescription() -> String {
        return "\(name), \(country)"
    }
}

let someAddress = Address(
    street: "Some St.",
    number: "18",
    apartment: "A",
    floor: "2",
    city: City(
        name: "Palermo",
        state: State(
            name: "Buenos Aires",
            country: "Argentina"
        )
    )
)

print(someAddress.getDescription()) // Some St. 18 - Apt. 2-A - Palermo, Buenos Aires, Argentina

In practice, the struct objects are used to model small chunks of information. They can serve us to describe an address, credit card data, etc.

Enum

A struct or class let us design based on "and". For example, struct Person has firstName and age, and email as its members.
An enum, on the other hand, allow us design based on "or". For instance, enum State has florida, california or texas as its members.

Unlike enum in languages as C, enum in Swift can get to be really complex. Anyway, we'll use basic functionality on these examples.

Let's see a basic example

class User {
    var name: String
    var credentialType: CredentialType

    init(
        name: String,
        credentialType: CredentialType
    ) {
        self.name = name
        self.credentialType = credentialType
    }
}

// enum CredentialType defines how a user created their account.
enum CredentialType {
    case email
    case facebook
    case apple
    case google
}

With the CredentialType enum, we can say that for instance, a user registered using email, or facebook, or apple, or google. It becomes impossible that a user has registered using more than one of these values, and this code makes it impossible.

Switch using enum

Ok, let's try to use CredentialType for our case. The most typical way of using an enum in our logic, is by using the keyword switch.

func isSocialNetworkUser(_ user: User) -> Bool {
    switch user.credentialType {
    case .email:
        return false
    case .facebook, .apple, .google:
        return true
    }
}

Also note that we could have defined that function inside User. And that we're combining several options inside the same case, but they could have also been written with a case for each option (facebook, apple, google).

Methods and attributes in `enum`

An enum may have methods and attributes, like a class. The most common pattern for doing that is including a switch self clause inside the method or attribute. Let's see an example:

enum Country {
    case argentina, germany, england, usa

    // We'll create a computed property. A `getter`.
    // Note that this is the same as write
    //
    // func isEuropean() -> Bool { ... }
    //
    // But when we call it, we won't use parenthesis, exactly as if we would be working with a property.
    var isEuropean: Bool {
        // switch self is VERY common in these cases
        switch self {
        // If we're calling this property for cases `germany` or `england`.
        // then we'll return `true`
        case .germany, .england:
            return true
        // However, if we're doing this from any other case of this enum, then
        // we'll return false
        default:
            return false
        }
    }

    // Similar to the previous case but with a String
    var nombre: String {
        switch self {
        case .argentina:
            return "Argentina"
        case .germany:
            return "Germany"
        case .england:
            return "England"
        case .usa:
            return "United States of America"
        }
    }
}

func describe(country: Country) {
    if country.isEuropean {
        print("\(country.name) is European")
    } else {
        print("\(country.name) is NOT European")
    }
}

describe(country: Country.germany) // Germany is European

Another curious thing about enum is that when we need to use one of them, like in the case of describe, there is not necessary to specify the type. For instance, Country.germany could have been just .germany. (note: This is not specific of enums, but it's notorious and easy to recognize for these)

describe(country: .argentina) // It's the same to say describe(country: Country.argentina) and it feels more natural.

rawValue

There is an alternative way to define the country name, as we've seen in the previous example, and it's by using a rawValue. Each enum can have a single rawValue for each of its cases, and all of them must be of the same type.

rawValue let us not only get a value associated to each case, but also create a case for the enum based on that associated value.

enum State: String {
    case florida = "Florida"
    case newYork = "New York"
    case california = "California"
}

let state1 = State.florida
print("State 1 is \(state1.rawValue)")
// We use the rawValue to get the value for that state
// this will print "State 1 is Florida"

let state2 = State(rawValue: "California")
// Here, we're doing the inverse process
// instead of getting the rawValue of a state,
// we create the state based on its rawValue
//
// We can make mistakes, so there is no guarantee that it exists
// a state with that name, the type of state2
// is `State?`, an optional State.

if let state = state2 {
    print("We could get state2 and its \(state.rawValue)")
} else {
    print("We couldn't get state2, and it's nil")
}

Associated value

This is the last case we'll see here about enum. I'd like to explain them here because they are something very used in Swift, although it's not inside the scope of what's needed to continue with the course. I mean, it's not necessary to grasp the following lessons. However, knowing this can be very useful in your careers.

Each enum case can have associated values. For example, let's imagine a Cookie enum. Each cookie might be represented using a enum.

enum Cookie {
    // Each case may have any number of associated values. Each one may optionally have
    // an associated name and may be of the type we need.
    case chocChip(dough: DoughType)
    case stuffed(stuff: StuffType, dough: DoughType)
    case fortune

    var cookieDescription: String {
        switch self {
        // We can get associated values using the keyword `let`.
        case .chocChip(let dough):
            return "Chocolate chips cookie with dough of type \(dough.doughDescription)"
        case .stuffed(let stuff, let dough):
            return "Stuffed cookie of \(stuff.stuffDescription), flavor \(dough.doughDescription)"
        case .fortune:
            return "Fortune Cookie"
        }
    }
}

enum StuffType {
    case vanilla, strawberry

    var stuffDescription: String {
        switch self {
        case .vanilla: return "vanilla"
        case .strawberry: return "strawberry"
        }
    }
}

enum DoughType {
    case vanilla, chocolate

    var doughDescription: String {
        switch self {
        case .vanilla: return "vanilla"
        case .chocolate: return "chocolate"
        }
    }
}

struct CookieSet {
    let cookies: [Cookie]

    func describe() {
        print("-")
        print("Cookies:")
        for cookie in cookies {
            print(cookie.cookieDescription)
        }
    }
}

let cookies = CookieSet(cookies: [
    .fortune,
    .stuffed(relleno: .frambuesa, saborDeMasa: .chocolate),
    .stuffed(relleno: .frambuesa, saborDeMasa: .chocolate),
    .stuffed(relleno: .frambuesa, saborDeMasa: .chocolate),
    .chocChip(saborDeMasa: .chocolate),
    .chocChip(saborDeMasa: .vanilla),
    .chocChip(saborDeMasa: .vanilla),
    .fortune,
    .fortune,
    .chocChip(saborDeMasa: .chocolate)
])

cookies.describe()
//    -
//    Cookies:
//    Fortune
//    Stuffed cookie of strawberry, flavor chocolate
//    Stuffed cookie of strawberry, flavor chocolate
//    Stuffed cookie of strawberry, flavor chocolate
//    Chocolate chips cookie with dough of type chocolate
//    Chocolate chips cookie with dough of type vainilla
//    Chocolate chips cookie with dough of type vainilla
//    Fortune
//    Fortune
//    Chocolate chips cookie with dough of type chocolate

Closures

closure are also called anonymous functions. We'll see first the concept of function as a data type.

Functions as a data type

In Swift, Functions are a type of data, such as Int, Double, Bool, a class, struct, or enum. This implies that we could take a function a send it as an argument for another function, or make a function return another function as a result. Or have astruct` where one of its attributes is a function. This is actually a bit weird when we first see it, but it's actually pretty common in modern languages.

To convert a function into its related data type, we need to pay attention to the types of its input and output. So, the sum function:

swift func sum(x: Int, y: Int) -> Int { ... }

Is of type (Int, Int) -> Int because it receives to Int and returns an Int. Let's see other examples:

swift func sum(x: Int, y: Int) -> Int { ... } // (Int, Int) -> Int func describe(_ person: Persona) { ... } // (Persona) -> Void func printCurrentTime() { ... } // () -> Void func getCurrentDate() -> String { ... } // () -> String

And, as we said, a Function data type can be used as an argument for other functions:

`swift
struct Person {
let id: Int
let name: String
let role: PersonRole?
let age: Int
}

enum PersonRole {
case developer, projectManager, teacher, doctor
}

func printAdults(_ people: [Person]) {
for person in people {
if person.age >= 18 {
print("(person.id) - (person.name)")
}
}
}

let people = [
Person(id: 1, name: "Franco", role: .teacher, age: 34),
Person(id: 2, name: "Gimena", role: .projectManager, age: 24),
Person(id: 3, name: "Gonzalo", role: .teacher, age: 26),
Person(id: 4, name: "Noelia", role: .developer, age: 29),
Person(id: 5, name: "Pablo", role: nil, age: 15),
Person(id: 6, name: "Lourdes", role: .doctor, age: 29),
]

printAdults(people)
// This will work correctly
//
// However, we don't have a way to provide 'flexibility' to the algorithm. I mean,
// inside the function printAdults we filter by age, and then we print the result.
// If we would like to change the filter criteria, we'd need to write a completely new function.
// Let's convert this function in something more flexible:

// We are "injecting" a function into another function as an argument
func print(_ people: [Person], who matchesCriteria: (Person) -> Bool) {
for person in people {
if matchesCriteria(person) {
print("(person.id) - (person.name)")
}
}
}

func isAdult(_ person: Person) -> Bool {
return person.age >= 18
}

print(people, who: isAdult) // Exactly the same result. We're sending the function as an argument in this case.
`

Anonymous functions

Now it's time, with this introduction we can start talking about anonymous functions. An anonymous function, or closure is a function that lacks a name. It's as simple as it sounds. And the best context for using them is to send them to other functions. For example, in this case, I could have decided that it didn't make sense to define a new function just to determine is a person is an adult.

Let's define it as an anonymous function:

swift print("Printing adult people using a closure (1):") imprimir( people, who: { (person: Person) -> Bool in return person.age >= 18 } )

This is a closure, and there are a couple of different ways to define one, here are more examples: https://fuckingclosuresyntax.com/

For now, let's see the transformation step by step

We have this function:

swift func isAdult(_ person: Person) -> Bool { return person.age >= 18 }

Step 1: We remove the func keyword and its name:

swift (_ person: Person) -> Bool { return person.age >= 18 }

Step 2: In case its parameters have a different internal and external names, we will only use its internal ones:

swift (person: Person) -> Bool { return person.age >= 18 }

Step 3: We move the curly bracket to the beginning of the definition, and in its place, we will put in:

swift { (person: Person) -> Bool in return person.age >= 18 }

Perfect! This is enough to correctly define a closure. We can use this closure as it is right now, but I'll show you some extra steps we can take to shorten this definition even more. Again, this is completely optional:

Extra step 1: We remove the data type, as the compile can infer it based on the context for most situations:

swift { (person) in return person.age >= 18 }

Extra step 2: We remove the parenthesis around the arguments:

swift { person in return person.age >= 18 }

Extra step 3: If the closure has a single sentence, we can remove the return keyword.

swift { person in person.age >= 18 }

Extra step 4: Instead of using the arguments names (in this case person), we can refer to the arguments by its order. For instance, instead of person, we can use $0. If we had two arguments, the first of them would be $0 and the second one $1. If we had four, they would be $0, $1, $2, $3, and so forth:

swift { $0.age >= 18 }

And that's the minimum expression for this closure

swift print("Adult people who are teachers") print(people, who: { $0.age >= 18 && $0.role == .teacher })

If we had a closure as the last argument for a function, we can move it outside the function call. Let's make it clearer with an example:

swift print("Adult people who are teachers (2)") print(people) { $0.age >= 18 && $0.role == .teacher } // Exactly the same as the previous example

Map, filter, sorted and forEach

There are some functions inside the Swift standard library that take other functions as their arguments, especially when working with Array.

map is a function that let us transform each element of an array into another element by passing it a function that actually performs the transformation.
filter is a function that let us filter an array by passing a function that returns true in case the element should be included into the result array, or false otherwise.
sorted is a function that let us sort an array. It works similarly to the filter function, we will get two elements and we'll return true in case the first element should be first in the result array and which second.
forEach, let us iterate over an array, performing anything based on the origin array. This function won't return a new array, unlike map, filter and sorted.

It's important to note that all these functions (except forEach) return a new array. They don't modify the origin array.

`swift
let adultPeople = people.filter { $0.age >= 18 }
let names = people.map { $0.name }
let peopleSortedByAge = people.sorted { $0.age < $1.age }

// We can also "chain" these functions, because each of them will return a new Array.

print("Chained functions:")

people
.filter { $0.age >= 18 } // We'll only take into account adult people
.sorted { $0.age < $1.age } // We'll then sort them by age
.map { $0.name } // And we'll extract their names
.forEach { print($0) } // Finally, we'll print their names
// Gimena
// Gonzalo
// Noelia
// Lourdes
// Franco
`

Extensions

Extensions let us extend an existent type to add new functionality to it. This functionality may be computed properties or methods.

Let's consider a simple example:

`swift
struct Address {
let street: String
let number: String
let city: String
}

extension Address {
var addressDescription: String {
return "(street) (number) - (city)"
}
}

let address = Address(street: "Rivadavia", number: "185", city: "Palermo")
print(address.addressDescription) // Rivadavia 185 - Palermo
`

And that's exactly the same as this:

`swift
struct Address {
let street: String
let number: String
let city: String

 var addressDescription: String {
     return "\(street) \(number) - \(city)"
 }

}
`

An interesting use case for extension is to extend native types like Int, Double or String.

`swift
extension Int {
func isBigger(than anotherNumber: Int) -> Bool {
return self > anotherNumber
}
}

if 10.isBigger(than: 5) {
print("10 is bigger than 5")
}
`

Typealias

typealias are basically that, alias for types. This means that we can refer to an existing type with a new name. For example, let's suppose we're coding an app that handles users, where each user has an identifier. This user ID is an Int. However, a typealias can be even better, so we are sure we're talking about the identifier of a user.

Remember that a good code is easy to extend and easy to understand.

`swift
typealias UserID = Int

struct User {
let id: UserID
let name: String
}

typealias BuildingID = Int
typealias Address = (street: String, number: String, city: String, state: String, country: String)

struct Building {
let id: BuildingID
let ownerId: UserID
let address: Address
}

let office = Building(
id: 1,
ownerId: 10,
address: (
street: "Rivadavia",
number: "18451 PB Torre 2",
city: "Moron",
state: "Buenos Aires",
country: "Argentina"
)
)
`

Note that we could have done exactly the same without typealias. In general (except for advanced use cases we won't cover during this course), typealias bring clarity to the code, making our intention even more evident and clear to the other developers.

Exercises

We want to develop an application for organizing trips. The idea for the app is that we will have a list of possible destinations. The user can select their favorite destinations and save them, so they could then see those saved destinations in another list.

This exercise consists in developing the data structures needed to support the application use cases. It's required that, least:

Use classes, structs or enums to the entities User, Address, Place, Landmark.
Allow getting the favorites Place and Landmark objects for a certain user.

Use your creativity and try to get the exercise as complete as possible.

Introduction to Swift - Part 1

Fernando Martín Ortiz — Sun, 02 May 2021 21:51:55 +0000

Swift overview

Swift is a programming language developed by Apple to be used in application development for Apple platforms, as a replacement for (or in combination to) Objective-C, its previous recommended language. This way, and using Xcode, we can develop apps for iOS, iPad OS, MacOS, WatchOS and TVOS. Since 2015, Swift is also Open Source, being maintained not just by Apple, but by a open development community.

Swift is multi-paradigm, which means we can use it to develop object oriented code (OOP), functional programming, scripting, etc. Swift adapts to our preferred programming style, although the community has agreed on some best practices and a way to develop code following mainly an object oriented approach.

Swift is modern, which means it includes features from other modern languages, as we'll see during this course. What's more, it continues being added more features during the years.

Swift is simple to learn, but it can be as complex and go as low level as we need it to go.

During this course we'll learn the Swift syntax and usage examples. But not in depth. We'll learn the necessary syntax in order to start developing iOS application. However, it's important to note that the language can be much more complex than what we'll learn here. This course isn't intended to be comprehensive, but to bring the needed tools to start.

Variables

Variables are present in most (if not all) programming languages, and are names (also called identifiers), which contain a value.
In Swift, variables are declared using the keyword var, followed by a = and the value it contains. For instance:

var name = "Fernando"
var street = "Rivadavia Av."
var catLegsCount = 4

Something that could be curious in these declarations is that we aren't specifying their type. That's because Swift includes a feature called type inference. Type inference let us declare variables without having to be explicit about their types, because Swift is "intelligent" enough to figure out that a 4 is an Int, and that "Fernando" is a String.

We can be explicit

Of course, there are moments where it could be useful to be explicit about the data type of a variable. For instance, if we're talking about a price.

var price1 = 12

We could want to be explicit about the type because the price is a decimal value, and it's not an Int. In Swift, we can specify the data type using : <DataType>. For example:

var price2: Double = 2.50

Constants

Let's suppose we have a variable with a value that we know it won't change. For example, a cat has four legs. If we want to define the number of legs a cat has, we can use a constant. In order to so, we'll replace var by let, transforming that variable into a constant. A constant is a variable to which we can only associate a value once. If we want to update its value afterwards, we'll get an error.

var leavesInATree = 10
leavesInATree = 22
leavesInATree = 25 // We won't get any errors if we modify this value.
let catLegsCount = 4

// The next line won't compile.
// catLegsCount = 5

While naming a variable, it's important to be very explicit on its meaning. This means: do not abbreviate

lbl isn't a good variable name. label is.
chCnt isn't a good variable name. charactersCount is.
i isn't a good variable name. index is.

Every programming language has it's own "correct" way to write code with. We know it as best practices. In Swift, the best practice is to declare variables as constants, using let, and use var only when it's strictly needed. This will save us from potential headaches, because we know that the variable we're using that was declared using let, hasn't been modified. For complex functions, this can be critical.

Data Types

As we've seen in the last section, although it isn't necessary to be explicit about a variable's data type (because the compiler infers the data type), we can choose to be explicit and specify it anyway. In this section, we'll do it that way.
Swift comes with a set of predefined data types, and let us define our custom types, as we'll see in the following sections.

Numeric Data Types

Swift defines the following main numeric data types:

Int: Integer number.
Double: A decimal number.
Float: A decimal number, but with less capacity than a Double.

let legs: Int = 4
let price: Double = 30.50
let temperature: Float = 20.2

Bool

Bool is a boolean value. It can either be true or false. Those are only two possibilities.

let enabled: Bool = true
let isReady: Bool = false

String

String is a list of characters. It's used to define texts and words. For instance, a person name or a street name could be defined as String.

let name: String = "Fernando"

A curious fact about String values in Swift is that emojis are valid String values!
Why? Why not? 🤷

let fancyHelloWorld: String = "👋 🌎!"

Print

Sometimes we need to print a value in the console. In Swift, we can do that using the print() function. For example, a "Hello, World!" program can be written like this:

print("Hello, World!")

If you execute this program using the button in the left bar, a message will appear in the console that is at the bottom of the screen.

Comments

Comments can be single-line or multi-line.

Single-liner comments

They begin with a // and only occupy one line.

let mensaje = "Hello, world!" // This is a message

Multi-line comments

They begin with a /* and end with */.

/* This line
 prints the
 Hello, World! message */
print(mensaje)

Interpolation

How do we create a String from other variables? An easy way to do it is by concatenating the parts.

let firstName = "Fernando"
let lastName = "Ortiz"
let fullName = firstName + " " + lastName // Fernando Ortiz

The alternative, and the most common way to do it in Swift, is by using interpolation. A String interpolation consists in "embedding" variables inside a String. This is done by entering \(<variable>) inside the String. For instance:

let middleName = "Martín"
let experience = 7
let description = "My name is \(firstName) \(middleName) \(lastName) and I have \(experience) years of experience as an iOS developer."

print(description) // "My name is Fernando Martín Ortiz and I have 7 years of experience as an iOS developer."

Note that we're also introducing an Int in the middle of the String and we aren't getting problems. That's another advantage of String interpolation.

Collections

Let's collections in Swift to the data types that contain other data types on them and that we can iterate over them on some way.

Array

Also known as lists or vectors, they are data types that store values in a sequential way. What's interesting about Arrays in Swift is that you can't mix values of different types in an Array. The simplest way of defining an array is this:

let students = ["Federico", "Micaela", "Aldana", "Oscar"]

Note that we are just using String values. An Array with the values ["Fernando", 28, true] won't be valid, unless the Array is of type [Any]. The Any type is a type that can be of "any" type of value, but there are certain disadvantages on using it. My advice here is that, for now at least, AVOID USING IT.

If we want to be explicit about the type, we can also do it:

let numbers1: [Int] = [1, 21, 129]
let numbers2: Array<Int> = [3, 122]

There are many ways of declaring an empty Array:

let numbersEmpty1: [Int] = [] // Preferred
let numbersEmpty2: Array<Int> = []
let numbersEmpty3 = [Int]()
let numbersEmpty4 = Array<Int>()

Useful methods in `Array`

If we want to know the number of elements in an Array, we use the property count.

let numbers3 = [12, 31, 231, 23]
print("\(numbers3) has \(number3.count) elements")

Curious fact, String in Swift are actually sequences of characters, so they also have the count property defined on them. Actually, most of the things we explain in this section apply also for String values.

let name = "Fernando"
let nameLength = name.count
print("\(name) has \(nameLength) characters.")

If we want to get the first element in an Array, we'll use .first!, why we're using ! will be explained later. For now, let's say we're using ! to affirm that we know with full confidence that the first element in the Array will be there, because the Array is not empty. Note that if we do .first! and the Array is in fact empty, the program will stop executing and crash.

let names = ["Tamara", "Nicolás", "Francisco"]
let firstName = nombres.first! // "Tamara"

If we want to know if an Array is empty, we'll use the isEmpty property, that's of type Bool.

if numbersEmpty.isEmpty {
    print("It's empty!")
}

If we'd like to add an element to an Array, we'll use the functionappend`.

swift var namesToFill: [String] = [] namesToFill.append("Fernando") namesToFill.append("Martín") print("namesToFill has \(namesToFill.count) elements") // namesToFill has 2 elements

If we want to access an exact position in an Array, we'll use what's known as a subscript, and that's basically a number (the index) between square brackets. Indexes in a Swift Array start from 0. Note that if we want to get an element in a position that is undefined, the program will stop executing and crash.

swift let names2 = ["Aldana", "Iván", "Marcos", "Cristian"] let thirdName = names2[2] // "Marcos" // This will fail when executed. // let quintoNombre = nombres2[4]

Dictionaries

A Swift Dictionary is a container that associate identifiers to values. They are key-value structures where the key is generally a String and the value can be anything. In contrast to Array, where the Any type was generally discouraged, creating Dictionary objects where the key is String and the value is Any is perfectly normal and widely used.
The Dictionary type is similar to what a Map is in other programming languages.

swift let person: [String: Any] = [ // Note that when we define a dictionary withAny` as its value type, it can be anything.
"firstName": "Richard",
"lastName": "Brown",
"age": 27,
"position": "Project Manager"
]

let family: [String: String] = [ // If we define the dictionary as [String:String], values can only be String.
"mother": "Marge",
"father": "Homer",
"son": "Bart",
"daughter": "Lisa",
"baby": "Maggie",
"dog": "Santa's Little Helper"
]

let emptyDictionary: [String: Any] = [:] // The : sign must be there, so the compiler won't confuse this with an empty Array.
`

The advantage of using key-value objects is that we can now access to each value by its key. In the Family example:

swift let mom = family["mother"]! // "Marge"

The ! sign is necessary because we need to tell the compiler that there is an actual value associated to that key.

For

The for loop is a very well known structure in general programming languages. In Swift it's a bit different. The for loop let us execute a code fragment a predefined number of times. In practice, the most common use case for it, is to iterate over a collection, such as an Array or a Dictionary.

swift // We'll use these values for the examples. let names = ["Ayelén", "Lautaro", "Natalia", "Sergio", "Gerardo"] let person: [String: Any] = [ "firstName": "Richard", "lastName": "Brown", "age": 27, "position": "Project Manager" ]

for-in - Array

To iterate over an Array, we can use a for-in loop. In this case, this will print:

swift Name: Ayelén Name: Lautaro Name: Natalia Name: Sergio Name: Gerardo

swift for name in names { print("Name: \(name)") }

for-in - Dictionary

We can also iterate over dictionaries using the for-in loop. In this case, the syntax will be a bit different, because for each element in a Dictionary wi'll get a pair (tuple actually, as we'll see in a later section), with the corresponding key and value. Let's see an example. this will print:

swift lastName : Gomez position : Project Manager firstName : Ricardo age : 27

Also note that a Dictionary doesn't preserve the fields order. In this example, lastName was printed third, regardless I defined it first.

swift for (key, value) in person { print("\(key) : \(value)") }

Ranges

An alternative way of using for loops is by define a Range. A Range defines a value interval.

(0 ...< 10) for instance, defines a range from 0 to 10, not including 10.
(0 ... 10) defines a range from 0 to 10, 10 included.

Will print:

Number: 0 Number: 1 Number: 2 Number: 3 Number: 4 Number: 5 Number: 6 Number: 7 Number: 8 Number: 9 Number: 10

swift for number in 0 ... 10 { print("Number: \(number)") }

We can use the count property in Array, to iterate over it in a more "traditional" way. Note that for index in 0 ..< names.count is very similar to something like for var index = 0 ; index < names.count ; index++, which is a syntax that isn't valid in Swift. Furthermore, index++ isn't valid Swift code. An alternative to that is index += 1, but anyway, the most traditional way of using for isn't valid in Swift.

swift for index in 0 ..< names.count { print("Name: \(names[index])") }

While

The while loop is widely used in programming languages. However, if I have to be honest, in my almost 7 years as iOS developer, I don't remember having to ever use it. Most of the times, some sort of for is enough, and it's better also, because every time we use whie, we are in the risk of accidentally entering into an infinite loop.
In this section, I'll show you how to use while. But let me repeat, it's almost unnecessary to use it.
while is a keyword what let us define a condition and a block of code. The condition will be evaluated. It it's true, then the block of code will be executed. This process will be repeated indefinitely, until the condition is evaluated as false`.

This example will print:

 Name with while: Ayelén
 Name with while: Lautaro
 Name with while: Natalia
 Name with while: Sergio
 Name with while: Gerardo

var index = 0
while index < names.count {
    print("Name with while: \(names[index])")
    index += 1
}

Functions

Functions are blocks of code that can receive a set of parameters, the input, and can return a value as a result, named output.
In Swift, functions are declared with the keyword func. The structure to declare a function is the following:

func <functionName> (<input1>: <InputType1>, <input2>: <InputType2>, ..., <inputN>: <InputTypeN>) -> <OutputType> { <body> }

Functions may or may not have an output, as previously said. However, if we declare that the function will return a value, we need to return it using the return keyword.

All of this can be a bit confusing but it's actually very intuitive. Let's see some examples:

func sum(x: Int, y: Int) -> Int {
    return x + y
}

func helloWorld() {
    print("Hello, World!")
}

func greet(name: String) {
    print("Hi, \(name)!")
}

The sum function receives two parameters, x and y, and returns the sum of both of them (it has an Output).
The helloWorld function doesn't have an input, neither an output. It only prints "Hello, World!" in the console.
The greet function receives an input name and doesn't return anything.

Calling a function

Functions can be called (or "invoqued") by their name, and the names of their arguments explicitly. This is very important and it's different to other languages.

let sumResult = sum(x: 10, y: 14) // 24
helloWorld()
greet(name: "Fernando")

Legibility

Now, if you're detail-oriented people, you probably noticed that greet(name: "Fernando") doesn't read so natural, to be honest. We can fix that. Don't you think it would be easier to read greet(to: "Fernando")? However, that would make things worse, because inside the function we'd have a variable to, with the value "Fernando".
Actually, we aren't forced to choose between one way or the other. Swift differentiates between internal names and external names for function parameters. Let's do a modification here, with a new function sayHello.

func sayHello(to name: String) {
    print("Hello, \(name)!")
}

sayHello(to: "Fernando")

Much better! This new function sayHello receives a single argument with an internal name name, visible only inside the function body, and an external name to, visible from the outside of the function (when we call it). If we don't specify different names for the internal and external ones, both will be the same, such as in the first couple of examples.

Let's fix another thing. The function sum looks a bit weird. Instead of sum(x: 10, y: 14), it would be more natural to say sum(10, 14) or sum(10, to: 14), or something similar. Swift let us define empty external names using the keyword _. The low dash let us specify that we don't want an external name for that parameter.
Let's try to define a divide function that would look like divide(8, by: 2).

func divide(_ x: Double, by y: Double) -> Double {
    return x / y
}
divide(8, by: 2) // 4

Preconditions

A precondition is a condition that needs to be true so that a function is executed. If the precondition is false, then the function will return a different value or throws an error. In Swift, we express the preconditions using the keyword guard. We can read it as "Ensure this is true. Otherwise, do this instead".

func describeDivision(of x: Double, by y: Double) -> String {
    guard y != 0 else {
        return "Dividing by zero is not possible."
    }
    let result = x / y
    return "The result of dividing \(x) by \(y) is \(result)."
}

let description1 = describeDivision(of: 20, by: 5)
print(description1) // The result of dividing 20 by 5 is 4.

let description2 = describeDivision(of: 10, by: 0)
print(description2) // Dividing by zero is not possible.

Best practices

Until here, the theory of functions syntax. The following best practices section is entirely optional. Feel free to skip it or read it at the end of this course. However, I will give you a piece of advice that I think is important.
Why do we write functions? There are many reasons, but it's important to understand that a function is an important tool that we have to build abstractions in our code. An abstraction is in some way, to adapt a concept to natural terms, so we can reason on it in a more intuitive way. Considering we write code to define a solution to a problem in a way that not only the computer will understand (which is the simplest part), but also other people will be able to read it, understand it, and feel confident modifying it and extending it, then abstractions will allow us to improve the readability of our code.
A good function needs to be understandable, clear, readable and modifiable. I'll list, next, a couple of best practices when writing functions.

Short functions

A function shouldn't be longer than 10 or 15 lines of code, in general. If a function is longer than that, it's convenient to split it in smaller functions, and then compose those smaller functions into a bigger function. A single-line function isn't necessarily bad, if it bring clarity to the code.

Readable functions

This is try not only to the function body, but also to the function invocation part. Code inside a function needs to be a well defined sequence of steps. The invocation of that function needs to be read naturally.

Cohesive functions

A function must do one thing, and do it right. This is even more important than writing small functions. If a function is longer than 25 lines or code, but every line of code contribute to the same goal without adding cognitive load to the code reader, then there is no reason to modify it.

Tuples

A tuple is the first custom data type we'll see during this course. Tuples are sets of data with a name and without any additional functionality (unlike classes, for instance). A tuple can be defined using the keyword typealias, or when it's needed.

typealias FullName = (firstName: String, lastName: String)
let name: FullName = (firstName: "Fernando", lastName: "Ortiz")
print("The first name is \(name.firstName) and the last name is \(name.lastName)") // The first name is Fernando and the last name is Ortiz

The most common use case for tuples is to let a function return more than a single value.

func divide(_ dividend: Int, by divisor: Int) -> (quotient: Int, remainder: Int) {
    // We assume we're not dividing by zero
    return (
        quotient: Int(dividend / divisor), // Integer value without the decimal values
        remainder: dividend % divisor // Modulo operator returns the remainder of a division
    )
}

let result = divide(13, by: 4)
print("Quotient: \(result.quotient) ;; Remainder: \(result.remainder)") // Quotient: 3 ;; Remainder: 1

Destructuring

Destructuring is a way of split a tuple into its components. It's done by assigning a tuple to a set of variables in parenthesis, and separated by comma:

let (myQuotient, myRemainder) = divide(17, by: 3)
print("Quotient: \(miQuotient) ;; Remainder: \(miRemainder)") // Quotient: 5 ;; Remainder: 2

// We can also ignore any of those values with a low dash.
let (quotient, _) = divide(50, by: 4) // We are ignoring the remainder here
print("The result of dividing 50 by 4 is \(quotient)") // The result of dividing 50 by 4 is 12

Anonymous components

A tuple can also have their components are anonymous values. Even when it's not recommendable, it's possible. In this case, we can access to its components using their index. For example: tuple.0 for the first element, tuple.1 for the second one, etc. The alternative is to use destructuring let (first, second) = tuple, which is preferrable.
Let's see a last example, generating intervals using a function that will return the lower and the upper extremes in a tuple:

func generateInterval(value: Int, amplitude: Int) -> (Int, Int) {
    let lower = valor - amplitud
    let upper = valor + amplitud
    return (lower, upper)
}

// Using destructuring - Preferrable.
let (lower, upper) = generateInterval(value: 10, amplitude: 2)
print("[\(lower);\(upper)]") // [8;12]

// Accessing by order to the anonymous components
let interval = generateInterval(value: 10, amplitude: 2)
print("[\(interval.0);\(interval.1)]") // [8;12]

Optional data types

Let's suppose we want to describe a person. What attributes does a person have? We could say firstName, lastName, identifier, age, etc. All of them exist. A person always have a firstName. A person always have lastName. All of them are of type String. String is a non-optional type.
However, this isn't true for every attribute in a person. What about middleName? A person may not have middleName, it's OPTIONAL.
Optional data types in Swift let us design exactly that, values that may not be there, they may be nil. You might have already noticed that in all examples so far, we have used non-optional values, and only in specific places we have used ! to note that we are sure that the value is not nil, like in first!, for Array.
Every data type have its optional counterpart, that is defined with the ? suffix. So, for instance:

String? is a String that might have a String value or nil.
Int? is an Int that might be nil.
Bool? is a Bool that might be nil.
[String]? is an Array of String that might be nil.
(quotient: Int, remainder: Int)? is a type composed by two Int values. The tuple might be nil. Its components, on the other hand, can't be nil.
(firstName: String, lastName: String?) is a tuple composed by two String values. The first one (firstName) can't be nil. The second one might be nil. The tuple isn't optional.

typealias PersonData = (firstName: String, middleName: String?, lastName: String, age: Int)
let fernando: PersonData = (
    firstName: "Fernando",
    middleName: "Martín",
    lastName: "Ortiz",
    age: 29
)
let nicolas: PersonData = (
    firstName: "Nicolás",
    middleName: nil, // it's nil, it doesn't exist
    lastName: "Duarte",
    age: 29
)

Force unwrap optionals

If we're sure that an optional value isn't nil, we can force it to convert it into its non-optional counterpart. To do that, we can add a ! at the end of the variable name, and it will become non-optional.
Let's see some examples. I have to say, however, that this is a VERY BAD PRACTICE. If we add a ! to get the non-optional counterpart of a value that is actually nil, the app will crash because of a fatal error.

print("Fernando's middle name is \(fernando.middleName)")
// Fernando's middle name is Optional("Martín")
// We have to get the non optional value of Fernando's middle name.

print("Fernando's middle name is \(fernando.middleName!)")
// Fernando's middle name is Martín

if-let

This is one of the "correct" ways of handling optional values. Inside an if, we can include an assignment from an optional that will be executed just in the case that the value isn't nil. For example:

if let middleName = fernando.middleName {
    // Inside here, middleName isn't optional
    print("Fernando's middle name is \(middleName)") // Fernando's middle name is Martín
}

if let middleName = nicolas.middleName {
    // This won't be executed
    print("Nicolas' middle name is \(middleName)")
} else {
    print("Nicolas doesn't have a middle name")
}

guard-let

guard is the opposite of if. It will execute its body only in the case that the condition isn't met and it's used to express a precondition. guard can also be used to unwrap optionals in a safe way, such as if-let.

func getMiddleName(of person: PersonData) -> String {
    guard let middleName = person.middleName else {
        return "\(person.firstName) doesn't have middle name"
    }
    return "\(person.firstName)'s middle name is \(middleName)"
}

print(getMiddleName(for: fernando)) // Fernando's middle name is Martín
print(getMiddleName(of: nicolas)) // Nicolás doesn't have middle name

Implicitly unwrapped optionals

An implicitly unwrapped optional is an optional data type, that we can assign nil to, obviously, but that when we need to use it, it will be considered non optional for most of the cases.
Of course, the app will crash in case the value is actually nil and we try to use it as a non-nil value. And, of course, this is a bad practice. However, this is used a lot in iOS, especially in frameworks that are written in Objective-C (Swift's predecessor, in Apple's platforms).

let nonNilMiddleName: String! = "Marcos"
let nilMiddleName: String! = nil

func printMiddleName(_ middleName: String) {
    print(middleName)
}

printMiddleName(nonNilMiddleName) // Marcos
// printMiddleName(nilMiddleName) // CRASH!

Optional chaining

Let's suppose we have an optional tuple.

var optionalPerson: PersonData?
optionalPerson = (
    firstName: "Nicolás",
    middleName: nil,
    lastName: "Duarte",
    age: 29
)

If in this case, that optionalPerson is optional, we need to access any of its components, being them attributes or methods (such as in classes, as we'll see later), we can use a feature called Optional chaining.

Optional chaining lets us access members of the optional object using ?. instead of ..

let firstName = optionalPerson?.firstName // type: String?, because, although `firstName` in `PersonData` is `String`, we don't know if `optionalPerson` exists, or if it's `nil`.

Exercises

Define a tuple that describes an address, with fields like city, state, zipCode, country, etc. Feel free to experiment and use dictionaries, optional values, and everything we've learned in this lesson.
Inside the address, define some optional components, like floorNumber and apartment.
Create three addresses as constants.
Write a function that gets an address and prints it as a well formatted String. Use interpolation.
Write a function that gets an Array of addresses and returns an String with "floor: \(floor) ; apt: \(apartment)" ONLY for those addresses with non-nil floor and apartment.

Swift generics

Fernando Martín Ortiz — Sun, 25 Apr 2021 22:59:30 +0000

The problem

Let's imagine we need to write a Stack data structure. We could do something like this:

struct Stack {
    private var content: [Int] = []

    var topElement: Int? {
        return content.last
    }

    mutating func push(_ element: Int) {
        content.append(element)
    }

    mutating func pop() -> Int? {
        return content.popLast()
    }
}

And we can use it like this:

var stack = Stack()
stack.push(10)
stack.push(20)
print(stack.topElement) // 20
stack.push(15)
let topElement = stack.pop()
print()

The problem we'll have with this type is that if we need to define a StringStack, then we'd have to repeat the entire code!

struct StringStack {
    private var content: [String] = []

    var topElement: String? {
        return content.last
    }

    mutating func push(_ element: String) {
        content.append(element)
    }

    mutating func pop() -> String? {
        return content.popLast()
    }
}

The solution

The solution to that problem is generics, and it consists on replacing the specific types that will vary from implementation to implementation, by a template or generic type.

struct Stack<T> {
    private var content: [T] = []

    var topElement: T? {
        return content.last
    }

    mutating func push(_ element: T) {
        content.append(element)
    }

    mutating func pop() -> T? {
        return content.popLast()
    }
}

We don't have a IntStack and a StringStack as separate types anymore. What we have now is a Stack of type T, and that T can be replaced by a concrete type when we need a Stack.

var stack = Stack<Int>()
stack.push(10)
stack.push(20)
print(stack.topElement) // 20
stack.push(15)
let topElement = stack.pop()
print()

Constrained generics

Sometimes we need to force generic types to implement certain requisites. The most common case is that we need the generic type to implement a protocol.

protocol Noisy {
    func makeNoise() 
}

struct RingBell: Noisy {
    func makeNoise() {
        print("Ring!")
    }
}

struct Dog: Noisy {
    func makeNoise() {
        print("Woof!")
    }
}

Let's now imagine we want to create a noisy stack, so we can then have all our noisy objects to make noise at the same time!

struct NoisyStack<T: Noisy> {
    private var content: [T] = []

    var topElement: T? {
        return content.last
    }

    mutating func push(_ element: T) {
        content.append(element)
    }

    mutating func pop() -> T? {
        return content.popLast()
    }

    func makeNoise() {
        for item in content {
            item.makeNoise()
        }
    }
}

In this case, as the items in the NoisyStack are Noisy, we know that all the items on can make noise.

Examples

There are other examples of generic types we have been using so far.

The first one is Array. When we write [Int], we're actually creating a Array<Int>, but with a simplified syntax.

The second example is probably more interesting. Int? is actually Optional<Int>, but with some syntax sugar on it, but it's exactly the same as writing something like this:

enum Optional<Wrapped> {
    case none
    case some(Wrapped)
}

Introduction to Swift error handling

Fernando Martín Ortiz — Sun, 25 Apr 2021 22:28:55 +0000

Swift.Error

So far, we've been using optionals and other techniques to represent errors in Swift.

However, Swift has a native, correct way of representing errors, and that way is using custom enum types implementing Swift.Error, or simply Error.

The Error protocol won't ask us to implement any method or property.

Let's suppose we are modeling a banking app, so we could define our errors with a enum like this, where each of its cases will represent a different error, and the enum itself will implement the Error protocol.

enum AccountError: Error {
    case insufficientFunds
    case wrongPinCode
    case wrongAlphabeticCode
}

throws, throw

Once we've defined our Error enum, we can implement functions that use those errors. However, in order to do that, we must specify that our function can throw an error. This is done with the throws keyword.

class Account {
    var funds: Double = 0.o

    func deposit(amount: Double) {
        funds += amount
    }

    func extract(amount: Double) throws {
        // ...
    }
}

In this case, the extract method could throw an error, if we try to extract an amount we don't have in the account.

Let's then check that using a guard clause. If we find an error, we need to throw it specifying which error it is.

func extract(amount: Double) throws {
    guard funds >= amount else {
        throw AccountError.insufficientFunds
    }

    funds -= amount
}

do/try/catch

Nice! We can throw errors. Our next challenge is to handle them effectively when we get them.

The first we have to notice is that throwing functions need to be handled in a special way to use them.

Let's start with the code and then we'll explain it:

let account = Account()
account.deposit(amount: 100)
do {
    try account.extract(amount: 50)
} catch let error { 
    switch error {
    case AccountError.insufficientFunds:
        print("Insufficient funds!")
    default:
        print("Another error.")
    }
}

In the previous example we've defined two different regions.

One, inside the do block, where we can call throwing functions. Whenever we need to call a function that may throw, we use the try keyword.

The second region is defined inside the catch block. Inside the catch block we can define a custom name for our error. This is done with a let binding, followed by the error name. In this case, its called error, which is also the default error name, so it's unneeded in this case.

Inside the catch block, we can receive our error, which will be of type Error, so we can switch on it and do something different for each error case we've defined, and a default clause in case we are getting an error we aren't handling specifically.

try, try?, try!

Let's modify a bit our function so it will return an object of type Extraction, which will represent the extraction we're performing.

struct Extraction {
    let id: String
    let amount: Double

    init(amount: Double) {
        self.id = UUID().uuidString // Random ID string
        self.amount = amount
    }
}

And for our extract method:

func extract(amount: Double) throws -> Extraction {
    guard funds >= amount else {
        throw AccountError.insufficientFunds
    }

    funds -= amount
    return Extraction(amount: amount)
}

Let's suppose we are only interested in getting our Extraction object, and we aren't interested in the specific error we might get. We can get the Extraction object directy using any of these two try variations:

try?: Returns the throwing function result as an Optional value, which is nil in case the function throws.
try!: Returns the throwing function result as a non-optional value, or crashes in case the function throws.

Of course, we must be very cautious when using try!. try? instead, is much more widely used.

Let's see the three cases.

try:

let account = Account()
account.deposit(amount: 100)
do {
    let extraction = try account.extract(amount: 50)
    // `extraction` is non-optional.
} catch let error {
    switch error {
    case AccountError.insufficientFunds:
        print("Insufficient funds")
    default:
        print("Another error")
    }
}

try?

In this case, extraction is of type Extraction?, optional, and doesn't require a do-catch block.

let extraction = try? account.extract(amount: 50)

try!

In this case, extraction is of type Extraction, non-optional, and doesn't require a do-catch block.

let extraction = try? account.extract(amount: 50)

Result

Another way of working with errors is by using the Result type, included in the standard Swift library.

Remember that an enum could have values associated to each of its cases. Also, an enum can be generic!

Result is a generic type with two cases with associated values. The Result type is defined something like this, and has many methods to work with these two possibilities:

enum Result<SuccessType, ErrorType: Error> {
    case success(SuccessType)
    case failure(ErrorType)
}

This means that Result is a type that represents a case in which the operation has been successful, and a second case in which the operation has failed, so we will get the Error for that failure.

Of course, Result is included in the standard Swift library, so we won't need to define our own Result type.

Let's rewrite the extract function so it'll return Result<Extraction, AccountError>

func extract(amount: Double) -> Result<Extraction, AccountError> {
    guard funds >= amount else {
        return Result<Extraction, AccountError>.failure(AccountError.insufficientFunds)
    }

    funds -= amount
    let extraction = Extraction(amount: amount)
    return Result<Extraction, AccountError>.success(extraction)
}

As it's obvious that the result is of type Result<Extraction, AccountError>, so we can avoid writing that type in the return:

func extract(amount: Double) -> Result<Extraction, AccountError> {
    guard funds >= amount else {
        return .failure(AccountError.insufficientFunds)
    }

    funds -= amount
    let extraction = Extraction(amount: amount)
    return .success(extraction)
}

Once our function is rewritten this way, we can modify the code that calls the extract function.

let extractionResult = account.extract(amount: 50)

switch extractionResult {
    case .success(let extraction):
        print("Extraction id: \(extraction.id)")
    case .failure(let error):
        switch error {
            case .insufficientFunds:
                print("Insufficient funds")
            case .wrongAlphabeticCode:
                print("Wrong alphabetic code")
            case .wrongPinCode:
                print("Wrong pin code")
        }
}

Introduction to the Controller

Fernando Martín Ortiz — Sun, 25 Apr 2021 19:01:25 +0000

Views in UIKit

Views in UIKit inherit from the base class UIView. There are specialized type of views, such a buttons, sliders, lists, grids, etc. We can use UIView as it is, or subclass it, or use its subclasses.

UILabel

It's a text label.

Some of its more frequently used members:

text: String - it defines the text the label shows.
textColor: UIColor - it defines the text color of the label.
font: UIFont - it defines the font the label uses.

UIButton

It's a button with a text label on it. We can customize its behavior when it's clicked (more on this later).

Some of its more frequently used members:

setTitle(_:for:) - modifies the text inside the button label.
setTitleColor(_:for:) - modifies the text color of the button label.

For both of them, in the for param, let's use .normal.

UIImageView

It's a view with a image on it.

Some of its more frequently used members:

image: UIImage - defines the image the view is showing.
contentMode: ContentMode - defines the way the image will fit into this view in case their sizes aren't equal.

Most used values of ContentMode:

ContentMode.scaleToFit
ContentMode.scaleToFill
ContentMode.scaleAspectFit

UITextField

It's a view that shows an editable one-line text.

Some of its more frequently used members:

text: String - defines the text the textField shows.
textColor: UIColor - defines the textField text color.
keyboardType: UIKeyboardType - defines the keyboard type that will be displayed while interacting with the text field.
isSecureTextEntry: Bool - defines whether to show or not the text field as a password field with dots instead of characters.

UIStackView

It's a view that displays other views inside of it.

It allow us to sort view in vertical or horizontal axis.
A stackView doesn't require constraints for its subviews, although it needs constraints to display itself inside its container.

UIViewController life cycle

What is a life cycle?

A lifecycle is the set of states that define an object from its creation to its destruction.

In case of a controller or view, we aren't allows to modify its life cycle state, but we can react to those changes, and customize what happens when a view or a controller changes its state.

Whenever an object changes its state, a life cycle method (or simply called hook) is executed. We can override any of those methods to customize what will happen in such a case.

The diagram above shows the different methods in the view controller life cycle and the possible transitions between them.

For this course, we'll just see the most important states and transitions.

init: it's executed when a controller is instantiated. In this moment, we don't have the view loaded in memory yet. If we want to access an element in the view at this point, the app will crash. Be careful.
viewDidLoad: Once the view in the controller has been loaded into memory, this method will be executed. It will happen once in the entire controller's life cycle.
viewWillAppear: Once the view in the controller is shown to the user, this method will be executed. It can happen any number of times during the controller's life cycle.
viewDidAppear: This will be executed once the view is already shown in screen. If the app navigates to another view using an animated transition, this method will be executed once the transition has finished animating. In this moment, the views has actual values for its constraints.
viewWillDisappear/viewDidDisappear: They are like viewWillAppear and viewDidAppear but in the opposite direction.

@IBOutlet and @IBAction

A controller has two responsibilities:

To send the data from the model to the view: This can be done by setting attributes to the views the controller has access to. The controller must have references to its views. Those references are simple implicitly unwrapped optional (!) variables marked with @IBOutlet. So, @IBOutlet means that the view annotated with it is going to be linked to a view in the interface builder.
To reflect user actions in the model: This is done by having methods in the controller annotated with @IBAction, which will be linked to actions in views (such as a button tap). There are other ways other than using @IBAction, but that's good enough to start.

Let's say we have this view:

The functionality that we need to add to the controller is to respond to the tap/click event in the UIButton that says "Generate full name", so we can take the text property in the UITextField views for the first and last names, and replace the text in the UILabel that says "Full name".

In order to do this, we need references in the controller for:

firstNameTextField: UITextField!
lastNameTextField: UITextField!
resultLabel: UILabel!

Why are these Optional? Because when we instantiate the controller, the view isn't loaded yet! we know when the views are instantiated because the viewDidLoad method is executed. This is VERY important, it will save us from getting random crashes.

To generate an @IBOutlet

Open an editor in the right

In the right editor, open the class ViewController.swift

In the left editor, search for the view you want to link.
Keeping pressed the control key in the keyboard, drag and drop the view to any place of the controller code (not inside a method).

A simple way of ensuring this has worked correctly is to select the view controller in the left editor. In the last tab in the right panel we'll see the names of the @IBOutlet and @IBAction we've linked.

Apart from the @IBOutlet, we'll need to react to the action in the UIButton using an @IBAction, that, as we've already learned, it's a method that will be executed when some action occurs in the view.

@IBAction func generateNameButtonPressed() {
    // ...
}

The @IBAction for a button might be associated to different events of that button. In general, we'll use the event touchUpInside, which is the most standard tap on the button.

The steps to generate a @IBAction are exactly the same than for generating a @IBOutlet, except that at the end, we need to choose an action instead of an outlet in the last step.

Once views and events are connected, we can insert custom logic to the controller. In this case, we'll need to obtain the first name and last name from the UITextField views, and then assign the concatenation of them to the text property in the UILabel.

Practice

Create an app that is just a label with a 0 (zero) in the middle of the screen with two buttons, one at the left for decrementing the value of the counter label, and another at the right for incrementing the value.

Also... what if we add a textField to customize the amount we will increment or decrement when the buttons are pressed?

Introduction to iOS using UIKit

Fernando Martín Ortiz — Sun, 25 Apr 2021 18:36:07 +0000

Today, I decided to start open sourcing my iOS tutorial I've been using to teach iOS trainees (50+ I think) over many years. The tutorial I'm going to be releasing is just the last of many iterations.

I haven't done this before, because the course has been originally written in Spanish. This list of articles has been translated to English by myself.

Before listing the articles, I have to say that, if you're starting iOS development in 2021, you probably want to start by learning SwiftUI, and not UIKit. When I started writing these tutorials (back in 2017), there was no clue we were going to have a new framework to nearly replace UIKit.

If you prefer to learn SwiftUI, I recommend this course by Paul Hudson.

If you're still here, this is the list of tutorials:

Introduction to Swift - Part 1
Introduction to Swift - Part 2
Introduction to the View
Introduction to the Controller
Using Xibs
Navigation in iOS apps
Understanding Delegation (under translation)
Introduction to UITableView (under translation)
Introduction to Networking (under translation)

Extra:

Introduction to Cocoapods (under translation)
Swift generics
Introduction to Git (under translation)
Introduction to Swift error handling

I honestly hope anyone could take advantage of these course.

Please reach me over dev.to, or to my email.

Thank you!

Introduction to the View

Fernando Martín Ortiz — Sun, 25 Apr 2021 16:53:40 +0000

SwiftUI? UIKit?

When we develop apps for iOS, we have two base frameworks we can choose from. SwiftUI and UIKit.
Both of them allow us to develop user interfaces (UIs).

SwiftUI

Released in 2019. It's a framework for building declarative user interfaces. It's modern and its approach is similar to React, Flutter and Jetpack Compose in other platforms.

It's clearly the future of iOS development.

You might be forced to use UIKit, because of backwards compatibility, or because it's the framework used in the company you work for. If not, I recommend closing this course and start learning SwiftUI using some the great tutorials in the web, like Paul Hudson's 100 days of SwiftUI.

UIKit

UIKit is the framework all iOS user interfaces are based upon. SwiftUI uses many UIKit components under the hood when compiling for iOS, so knowing UIKit is a great knowledge to have, even if you aren't directly using it in a daily basis.

Another important thing is that SwiftUI can be extended using UIKit components. And you can embed SwiftUI in UIKit if needed. So both of them are complementary to some extent.

In this course we'll focus on UIKit, using MVC as the design pattern for organizing our code.

Model - View - Controller

Design patterns are solutions for software design problems. If many people experience the same problems over and over again, it makes sense to document the ways that problem can be solved, regardless of the specific language or platform you're working on.

Model View Controller (MVC) is the design pattern Apple recommends to use in order to design iOS applications.

The MVC pattern divides classes in three different groups or layers:

In the Model we have all the classes that are responsible for managing the data for your app.

In the View we include all the classes that are responsible for showing the data (or anything needed) to your users.

So we have a model that holds our data and a view that shows that data to our users.

So, the question here becomes: how does the view know the model and what subset of the model data it should be showing to the user?

As iOS developers, we are developers of user interfaces. The goal of any user interface is to provide a consistent representation of the internal state of a system in a visual way to a user.
The internal state is known as a model, and can be as simple as plain Swift classes.
The visual representation is known as view and we'll develop it using components defined in UIKit.

As user interfaces developers we have two goals:

First, we must send the data from the model to the view. The view must always reflect the current model state.
Second, we must reflect the user actions in model data changes. We have to modify the data in the model according to what happens in the user interface.

Both of those actions are done in the controller. At least at the beginning, you can assume that every screen is controlled by a controller.

Each view is a subclass of UIView, defined in UIKit.
Each controller is a subclass of UIViewController, defined in UIKit.
Each controller has a root view. That root view can be accessed through the .view property in UIViewController.

The View

The view is the layer responsible of visually representing the state of the model to a user, and it's organized in the form of a tree.

Quick recap for those who don't know/remember what a tree is: A tree is a hierarchical data structure composed by nodes. Starting from a root node, each node may have children, which may also have other children node, until we finally get nodes without children. Those nodes are known as leaves.

The view is organized as a tree. That means that we will have a root view, which can be accessed from our view controller. Starting from our root view, we may find children views, or subviews, which may have their own subviews.

So, for this example:

This could be a possible (simplified) view tree (or view hierarchy):

Constraints

Given that the views are the elements shown to the user, and that they compose in form of tree structures, the constraints are the elements that will let us define the exact place where each view should be shown in the screen.

In order to place a view in screen, we must define two values: origin and size.

The origin is the point from where the view starts to be drawn. This value is expressed as a coordinate (CGPoint to be precise), defining the top left corner of the view.

While the size is a value composed of the width and size of the view (CGSize to be precise).

Constraints are just that, constraints, that we apply to our views. The requisite is that we need to determine the origin and size of our views in such a way that isn't ambiguous to UIKit.
If after we apply our constraints to our views, they can take more than one possible value for any of those dimensions (origin.x, origin.y, size.width, size.height), then the constraints applied to the view are considered ambiguous, and we can get non expected results.
We must be specific.

A constraint is composed by:

origin view + origin attribute
destination view + destination attribute
constant
multiplier (by default it's 1.0)
relationship operator (by default, and almost always, it's going to be ==)
priority (by default, 1000 (required)).

Based on these elements, we can build EVERY POSSIBLE LAYOUT. That's why the UIKit constraints system is so powerful.

Attributes can be:

leading
trailing
top
bottom
width
height
center X
center Y

Example 1

We want to add a view to a container in such a way te view will occupy the total space of its container.

Solution:

View2.top == View1.top (constant: 0)
View2.trailing == View1.trailing (constant: 0)
View2.bottom == View1.bottom (constant: 0)
View2.leading == View1.leading (constant: 0)

There is other way for them to follow these constraints than to be equal in terms of origin and size. And that's the way to think on constraints.
We left them no choice. The only thing they can do is to fit in the place we want.

Alternative solution:

View2.width == View1.width (constant: 0)
View2.height == View1.height (constant: 0)
View2.centerX == View1.centerX (constant: 0)
View2.centerY == View1.centerY (constant: 0)

This means that we can get the same layout using different sets of constraints.

Example 2

We want a view that is inside a container view with a margin of 20 points.

Solution:

View2.top == View1.top (constant: 20)
View2.trailing == View1.trailing (constant: 20)
View2.bottom == View1.bottom (constant: 20)
View2.leading == View1.leading (constant: 20)

Example 3

We want two views that are inside a third one, and both of them have the same size.

The solution for this problem is a bit more complex, so let's divide it in subproblems.

The first thing we have to fix is how to get View2 to stay on the left part of the container, View1. We can get that in a simple way:

View2.top == View1.top (constant: 0)
View2.leading == View1.leading (constant: 0)
View2.bottom == View1.bottom (constant: 0)

Then, we can add do the same for View3, in order to have that anchored to the right side of its container:

View2.top == View1.top (constant: 0)
View2.leading == View1.leading (constant: 0)
View2.bottom == View1.bottom (constant: 0)
View3.top == View1.top (constant: 0)
View3.trailing == View1.trailing (constant: 0)
View3.bottom == View1.bottom (constant: 0)

And finally, we need to disambiguate how those two views, View2 and View3 are related (they need to be equal in size).

View2.top == View1.top (constant: 0)
View2.leading == View1.leading (constant: 0)
View2.bottom == View1.bottom (constant: 0)
View3.top == View1.top (constant: 0)
View3.trailing == View1.trailing (constant: 0)
View3.bottom == View1.bottom (constant: 0)
View2.width == View3.width (constant: 0)
View2.trailing == View3.leading (constant: 0)

How to create a project

Open Xcode and click on File > New > Project...
Select iOS > App in the newly opened window. Click on Next.

In Product Name insert the name of the application you'd like to create. In this case, "TutorialApp" is good enough. Don't pay attention to Team and Organization Identifier for now. Interface should be Storyboard, Language should be Swift, and let's unselect Use Core Data and Include Tests.

Select any location in your disk you may want to save your project in, and click on Create.

In the initial project you will find:

AppDelegate.swift: It's a class where we'll have methods that are executed when something happened in our app (for instance, whenever the app goes to background). We can add custom code to those methods, in order to customize the app behavior.
SceneDelegate.swift: Similar to AppDelegate (for now, let's assume this).
ViewController.swift: An example UIViewController
Main.storyboard: We'll explain it in more detail in the next section. It's a file where the UI is described in a visual way.
Assets.xcassets: It's where we'll save graphic resources for our app. Images, Colors, etc.
LaunchScreen.storyboard: It's where we define the "Splash" screen of our app, the loading screen that's shown at the application startup. It will only count with a view, without a controller, and can't have any kind of interactivity or animations.

Interface Builder

UIs can be built programmatically. We can instantiate UIView subclasses and add NSLayoutConstraint (the constraints we've just learned) in plain Swift code. However, that can result in a lot of boilerplate. What's more, it isn't clear what kind of UI we're building in plain sight.
Xcode has a bundled tool called Interface Builder, which will allow us to develop user interfaces in a visual way. .storyboard and .xib files in our project are user interfaces descriptions.

Once a storyboard or xib is opened in the Interface Builder, you can open the UIKit components library by pressing Cmd + Shift + L.

Let's search for UIView and select the first component that appears in the selector, and drag and drop it to our screen.

In the right side of the screen, we have an editor for the view attributes, when we have the view selected.

Let's change its background color.

In the lower part of the interface builder interface, we'll find some important controls to create constraints.

In the third option, we'll have tools to generate constraints for:

width/height (just constants, without comparing them to other views)
top
leading
trailing
bottom
aspect ratio (height vs width inside the same view)

That's always calculated from the view to the nearest neighbor.

Let's keep Constraint to margins always unchecked.

Inside the second option, we'll find tools to define:

CenterX
CenterY

Let's create constraints to the top, leading, bottom, and trailing with 0 as their constant, so that view will have the same size as its container.

After that, let's click on Add 4 constraints.

If we go to the sixth tab in the right panel, always maintaining the recently added view selected , we'll see its origin and size and the list of its constraints.

If we do double-click on any of those constraints, we'll see its details, with all the components we've detailed previously.

Note: To delete that constraint, we can press delete in our keyboards.

The other option while generating constraints is to keep control pressed, click on a view and drag and drop to another view.

Some options will appear then, and we'll be able to edit them from the panel at the right.

That will let us generate constraints of, for instance, width or height relative to another view.

Practice

In order to do the following exercises, we'll create views using simple colored rectangles, as we've seen in the section about Interface Builder .

You can practice with the examples I'll write in this section or with any example you can think of.

Exercise 1

A view with 20 pts of margin to its container

Exercise 2

Two views with the same height, one below the other:

Exercise 3

These weird examples

Or any Mondrian you like 😅

Notes and links on fixing font imports in iOS

Fernando Martín Ortiz — Mon, 19 Apr 2021 22:02:19 +0000

This will be a quick one. I won't explain how you should import a font in iOS. There are plenty of great resources in the internet.

Here are two :

The Apple documentation: nicely explained. You can follow the guide and you won't have problems with it 99% of the times.
Common Mistakes With Adding Custom Fonts to Your iOS App: by Chris Chang, this has been my go-to guide when importing custom fonts since the beginning.

So I won't talk about it. I won't repeat what brilliant people in the internet have already said.

Today I had to import a custom font in a project. I imported the font as I have already done. Well, I imported 4 fonts to be clear. However, only two of them appeared when I run this code to log the fonts in the console:

for familyName in UIFont.familyNames {
    print("-------------")
    print("FAMILY: \(familyName)")
    for fontName in UIFont.fontNames(forFamilyName: familyName) {
        print("- \(fontName)")
    }
}

The other two were completely missing! I was doing something that haven't done in the past: I imported .woff fonts. So the first things I thought was obvious, this format isn't completely supported in iOS. However, while the Apple documentation recommends using .otf or .ttf formats, .woff is still supported since iOS 10.

So, what was the problem?

Let me tell you how I found it. I used https fontdrop. This is an incredible resource: https://fontdrop.info/

Using fontdrop, you can just drag and drop your font, regardless of its format, and discover many metadata about the font, including its name, and guess what? The font I was trying to import had a completely random name. Big facepalm for me.

The fix for this could have included asking the designer to fix it for me. However, I tried to do it myself.
Surprisingly, changing a font name is not very difficult. Using FontForge for instance, you can download the open source tool, import your font, being patient with its Java-like UI, and you can select Element > Font Info..., and change three parameters: Fontname, Family Name and Name For Humans (which I suspect is the name you get when you are selecting the font from the interface builder).

After editing those parameters, you can choose File > Generate Fonts..., and export the font as True Type Font (i.e. ttf format).

After that, I finally got to show the font in the console in my project!

Now that you've read until here, let me show how to use the font in SwiftUI.

// In a new file...

import SwiftUI

// The SwiftUI font type
extension Font {
    static func customSemibold(ofSize size: CGFloat) -> Font {
        return .custom("SomeCustomFont-Semibold", size: size)
    }
}

And you can add as many static functions as needed depending on the number of custom font types.

Inside your views, you can use this font using something as simple as this:

struct ACustomView: View {
    var body: some View {
        Text("Some Text")
            .font(.customSemibold(ofSize: 14.0))
    }
}

I sincerely hope this can help anyone at some point.

DEV Community: Fernando Martín Ortiz

This week I learned #1

What’s the model?

Navigation in iOS apps

Introduction

Stacks

Navigation Stack

Present/Dismiss

UINavigationController

Passing data

Using Xibs

What is a Storyboard?

What is a XIB?

Which one are we going to use?

Base App

Introduction to Swift - Part 2

Object oriented programming

Class

Inheritance

Encapsulation

Init

Polymorphism

Protocol

Struct

Enum

Switch using enum

Methods and attributes in enum

rawValue

Associated value

Closures

Functions as a data type

Anonymous functions

Map, filter, sorted and forEach

Extensions

Typealias

Exercises

Introduction to Swift - Part 1

Swift overview

Variables

We can be explicit

Constants

Data Types

Numeric Data Types

Bool

String

Print

Comments

Single-liner comments

Multi-line comments

Interpolation

Collections

Array

Useful methods in Array

Dictionaries

For

for-in - Array

for-in - Dictionary

Ranges

While

Functions

Calling a function

Legibility

Preconditions

Best practices

Short functions

Readable functions

Cohesive functions

Tuples

Destructuring

Anonymous components

Optional data types

Force unwrap optionals

if-let

guard-let

Implicitly unwrapped optionals

Optional chaining

Exercises

Swift generics

The problem

The solution

Methods and attributes in `enum`

Useful methods in `Array`