Forem: Odewole Kehinde

Day 6 of 100 Days of SwiftUI

Odewole Kehinde — Tue, 21 Jan 2020 14:37:09 +0000

After going 5 days straight non-stop. I decided to take a break on the 6th day for a recap, and also to catch my breath. There is so much information to take in.

Introduction

This is my sixth day of learning SwiftUI using Paul Hudson's 100 Days of SwiftUI challenge.

Today I learned how to write and use basic closures. Quite confusing initially but I think I've figured out the basics to get started with.

Summary

Closures

// Declaring a closure 
let lol = {
    print("I'm laughing out loud")
}

// Invoking the anonymous closure like a regular function
lol()

// Closure can also accept parameters like functions. To make a closure accept parameters, list them inside parentheses just after the opening brace, then write "in" so that Swift knows the main body of the closure is starting.
let sentence = { (action : String) in
    print("I'm \(action) out loud")
}

// Always remember that you don’t use parameter labels when calling closures
sentence("thinking")
sentence("laughing")


// Closure can also return values
// So we need to use -> "The_return_type" before in, then use return just like a normal function:
let expression = { (action : String) -> String in
    return "I'm \(action) out loud"
}

// Again, you don’t use parameter labels when calling closures
let yelling = expression("yelling")
print(yelling)

// For the last time, remember you don’t use parameter labels when calling closures
let smiling = expression("smiling")
print(smiling)

Using closures as a parameters to a function - Closures can be used as integers and strings.

let text = {
    print("Followed by a sample text")
}

// When you use a closure that returns nothing as a parameter to a function, we would specify the parameter type as () -> Void. That means it “accepts no parameters, and returns Void(nothing)”
// Let's declare a paragraph function that accepts a parameter called "word"...that is a closure
func paragraph(word : () -> Void) {
    print("This is the first text")
    word()
    print("This is the last text")
}

// Calling the paragraph function, and passing the closure
paragraph (word : text)

// Another example of closure as a parameter to cement the learning
let something = {
    print("I just said something!")
}

func saySomething(sentence : () -> Void) {
    print("Kenny, will you say something?")
    sentence()
    print("Glad you did!")
}

// calling the function passing in the closure as a parameter
saySomething(sentence : something)

// If the last parameter to a function is a closure, Swift lets us use special syntax called trailing closure syntax.
saySomething() {
    print("This will replace the sentence in the closure")
}

// If there are no other parameters, we can get rid of the parenthesis
saySomething {
    print("This will ALSO replace the sentence in the closure")
}

Thanks for reading🙏🏿.

You can find me on Twitter @RealKennyEdward

I'm on to Day7!

Day 5 of 100 Days of SwiftUI

Odewole Kehinde — Sun, 19 Jan 2020 22:51:50 +0000

Introduction

This is the fifth day of learning SwiftUI using Paul Hudson's 100 Days of SwiftUI challenge.

Today I learned how to write re-usable code using a function.

Summary

Function - Repeating code is a bad idea, functions helps us avoid doing that.

// Declaring a function
func readMe() {
    let text = """
        Welcome to our application

        We love making beautiful apps!
    """
    print(text)
}

// Calling the function
readMe()

// You can send values to a function. These values are called parameters. You tell Swift the type of data it must be
// Here we're telling the function to expect to receive two floats called base and height
func areaOfTriangle(base: Float, height: Float) {
    let result = 0.5 * base * height
    print("The area of a triangle is: \(result)")
}

areaOfTriangle(base : 7.0, height : 2.0)

// Swift allows us to provide two names for each parameter. One to be used externally when calling the function, while the other one is used internally respectively. It helps to give the variable a sensible name inside and outside the function
func areaOfTriangle2(base b: Float, height h: Float) {
    let result = 0.5 * b * h
    print("The area of a triangle is: \(result)")
}

areaOfTriangle2(base : 3.0, height : 4.0)

// Swift allows us to omit parameter labels by using underscore (_) for external parameter name but generally, it is better to give parameters external names to avoid confusion
func sayHello(_ name : String) {
    print("Welcome, \(name)")
}

sayHello("Kehinde")

// You can send back data from a function. You will specify the kind of data to be returned. The return keyword is required inside the declared function
//Instead of printing out the output, we'll return a value
func areaOfRectangle(length: Float, breadth: Float) -> Float {
    return length * breadth
}

areaOfRectangle(length : 10.0, breadth : 5.0)

// Default parameters
func welcome(to name: String = "Africa") {
    print("Welcome, \(name)")
}

// This will print "Welcome, Africa"
welcome()
// This will override the default value to print "Welcome, Las Vegas"
welcome(to : "Las Vegas")

Variadic function - You can make any parameter variadic by writing ... after its type. This means that there are zero or more integers, and Swift converts the value passed into an array of integers.

func square(numbers : Int...) {
    for number in numbers {
        print("\(number) squared is: \(number * number)")
    }
}
// runing the function with some numbers seperated by commas
square(numbers: 8,3,2,4,1)

Writing throwing functions - Writing throwing functions - Swift allows us throw errors from functions by marking them as throws before their return type. It uses the throw keyword when something goes wrong. The first step is to define an enum that describes the error we'd like to throw. It must be based on Swift's existing Error type.

// example
enum PasswordError: Error {
    case obvious
}

func checkUserPassword(_ password: String) throws -> Bool {
    if password == "iamapassword" {
        throw PasswordError.obvious
    }
    return true
}

Running throwing functions - You need to call these functions using three (3) keywords. (1) do - starts a section of code that might cause problems (2) try - it is used before every function that might throw an error (3) catch - lets you handle the error gracefully. If error are thrown inside a do block, execution jumps to the catch block immediately.

do {
    try checkUserPassword("iamapassword")
    print("This will not print")
} catch {
    print("This will be printed instead")
}

inout functions

I still find this concept a little confusing

// original valariable outside the function
var myOriginalVariable = 30

// print myVariable
print("myOriginalVariable is \(myOriginalVariable)")

// This directly changes the value directly rather than returning a new one
func doubleTheNumber(number : inout Int) {
    number *= 2
}

// The ampersand (&) makes it an explicir=t recognition that you're aware that it is being used as inout
// This outputs 60
doubleTheNumber(number: &myOriginalVariable)

Thanks for reading🙏🏿.

You can find me on Twitter @RealKennyEdward

I'm on to Day6!

Day 4 of 100 Days of SwiftUI

Odewole Kehinde — Sat, 18 Jan 2020 22:32:27 +0000

Introduction

This is the fourth day of learning SwiftUI using Paul Hudson's 100 Days of SwiftUI challenge.

Today's lessons were pretty straightforward. It's all about loops. Loops are used to tell computers to repeat a task multiple times. Examples of loops include - for loop, while loop, repeat loop.

Summary

For loops

let count = 1...10

// for loop
for number in count {
    // to skip an item and continue to the next one, you'll use the keyword continue
    if number == 3 {
        continue
    }
    if number == 6 {
        print("Human, I'm done counting!")
        // to exit a loop, use the break keyword
        break
    }
    print ("Number is now \(number)")
}

// If you don’t use the constant that for loops give you (as in number in the code above), you should use an underscore instead so that Swift doesn’t create needless values:
for _ in count {
    print("Number")
}
let artists = ["Don Moen", "M W Smith", "Sinach", "Jamie Grace"]

for artist in artists {
    print("You're currently listening to: \(artist)")
}

While loop

// while loop
var age = 1

while age < 25 {
    print("You can't manage the estate yet :(")
    age += 1
}

print("Now you are well able!")

Repeat loop - same as while loop except that the condition comes at the end.

var loginAttempt = 1

// the code will at least run once before the condition is checked
repeat {
    print("Enter your login details")
    loginAttempt += 1
} while (loginAttempt <= 3)

print("Correct details or not, you're now logged in")

Nested loops operators - Tthis is when you put a loop inside a loop.

// This is a nested loop
// to break out of two loops simultaneously, we need to add a label to the outside loop, and then use break {name_of_outside_loop label} in the inner loop
outerLoop: for x in 1...5 {
    for y in 1...5 {
        let multiply = y * x
        print("x * y is \(multiply)")

        if multiply == 20 {
            print("We're done here!")
            break outerLoop
        }
    }
}

Infinite loop - This means that your loop will repeat forever. All apps on your iPhone use infinite loops, because they start running, then continually watch for events until you choose to quit them. Please always make sure you have a check that exits your loop, otherwise, it will never end. They are made using "while true".

var counter = 0

// Infinite loop
while true {
    print ("I'll print forever, I'll even crash your system!👹")
    counter += 1

    if counter == 5 {
        print("Yo!, I won't let you👼🏿")
        break
    }
}

Thanks for reading🙏🏿.

You can find me on Twitter @RealKennyEdward

I'm on to Day5!

Day 3 of 100 Days of SwiftUI

Odewole Kehinde — Fri, 17 Jan 2020 22:54:23 +0000

Introduction

This is the third day of learning SwiftUI using Paul Hudson's 100 Days of SwiftUI challenge.

Today I learned about Operators and Conditions

Summary

Please find below a summary of my jottings on these topics

Operators - We have addition, substraction, multiplication, division, and modulus.

let testScore = 45
let examScore = 30

let addition = testScore + examScore

let substraction = testScore - examScore

let multiply = testScore * examScore

let division = 50 / 5

// Returns the remainder after a division operation
let modulus = 15 % 6

Operator overloading - This means that what an operator does is dependant on the values used with it.

// Addition
let result = 10 + 10

// String concatenation (as it is called in JavaScript)
let firstPart = "Welcome home "
let finalPart = "Africans!"
let welocmeMessage = firstPart + finalPart

// We can even join arrays together using + operator
let initialArray = ["East", "West"]
let additionalArray = ["North", "South"]
let cardinalPoint = initialArray + additionalArray

Compound operators - They assign the result back to whatever variable you were using.

var score = 70
let attendanceMark = 10

score += attendanceMark

// Similarly, you can add one string to another using +=
var fact = "Nigeria is the giant of "
fact += "Africa"

Comparison operators - These includes equality operators, inequality operators, greater than, and less than.

// comparison operators
let first =  19
let second = 23

// equality operators: checks two values are the same
first == second

// inequality operators: checks two values are not the same
first != second

// greater than, greater than or equal to
first > second
first >= second

// less than, less than or equal to
first < second
first <= second

// Each of these operators also works with strings, because strings have a natural alphabetical order
// Prints true
"a" < "b"
// Prints false
"Africa" > "America"

Conditions - You give Swift a condition, and if that condition is true it will run the code you instruct it.

let firstAge =  50
let secondAge = 50

// if the condition is true, the code in the bracket will run
if firstAge > secondAge {
    // Swift built-in function to print output
    print("The first dude is older.")
} // You can chain conditions together using else if
else if (firstAge == secondAge) {
    print("Wow, you guys are mate!")
}
//  If you want you can provide alternative code to run if the conditions are false, using else
else {
    print("The second dude is older.")
}

// Combining conditions -  && (pronounced “and”) and || (pronounced “or”) are used to combine conditions together
let x = 9
let y = 2

// &&
if (x > 1 && y > 1) {
    print("The two conditions are met")
}

// ||
if (x > 1 || y > 10) {
    print("One of the conditions is correct")
}

// Use case
let loggedIn = true
let authorized = false

if loggedIn && authorized {
    print("Welcome to Wakanda!")
}

Ternary operator - The ternary operator is a condition plus true or false blocks all in one, split up by a question mark and a colon, all of which which makes it rather hard to read.

let firstCard = 11
let secondCard = 10
// ternary operator
print(firstCard == secondCard ? "Cards are the same" : "Cards are different")

// This code is same as an if..else statement
if firstCard == secondCard {
    print("Cards are the same")
} else {
    print("Cards are different")
}

Switch - You write your condition once, then list all possible outcomes and what should happen for each of them.

let weather = "sunny"

switch weather {
case "rain":
    print("Bring an umbrella")
case "snow":
    print("Wrap up warm")
case "sunny":
    print("Wear sunscreen")
default:
    print("Enjoy your day!")
}

// If you want execution to continue on to the next case, use the fallthrough
switch weather {
case "rain":
    print("Bring an umbrella")
case "snow":
    print("Wrap up warm")
case "sunny":
    print("Wear sunscreen")
    fallthrough
    // the default case must be there to ensure all possible values are covered.
default:
    print("Enjoy your day!")
}

Range Operators - "The half-open range operator" ..< creates ranges up to but excluding the final value. "The closed range operator" ... creates ranges up to and including the final value.

let studResult = 85

switch studResult {
case 0..<50:
    print("You failed badly.")
case 50..<85:
    print("You did OK.")
default:
    print("You did great!")
}

for i in 1...100 {
   print("Currently on Day \(i)")
}

for i in 1..<8 {
   print("Currently on Day \(i)")
}

Thanks for reading🙏🏿.

You can find me on Twitter @RealKennyEdward

I'm on to Day4!

Day 2 of 100 Days of SwiftUI

Odewole Kehinde — Thu, 16 Jan 2020 22:16:14 +0000

Introduction

This is the second day of learning SwiftUI using Paul Hudson's 100 Days of SwiftUI challenge.
I wrote a summary of Day 1 here.

Today I learned about complex data-types such as

Arrays
Sets
Dictionaries
Tuples
and Enumerations (also called Enums)

Summary

Please find below a summary of my jottings on these topics

Arrays - It is a collection of values that are stored as a single value. Each value seperated by a comma. It starts and ends with a square bracket. Accesing values in the array is done by reference the array index number. Array numeric position starts its numbering from 0. Please note that If you're using Type Annotations, Array data-type is written in square brackets. Use case: When a set of values can contain duplicates and the order matters.

// Declaring a variable
let name = "Kehinde Odewole"
let tribe = "Yoruba"
let state = "Lagos"
let country = "Nigeria"
let continent = "Africa"

// Placing these variables in an Array
var userInfo = [name, tribe, state, country, continent]

// Array Type Annotation
var userInfo : [String] = [name, tribe, state, country, continent]

// Prints "Africa"
userInfo[4]

// Re-assigning the variable name 
userInfo[0] = "Taiwo"

// Swift is going to crash (Fatal error: Index out of range) if you attempt to access a value that is out of the array range
//userInfo[5]

// Creating an empty Array
let ages = [Int]()
// Or
let ages2 = Array<Int>()

Sets - Items listed in Sets cannot occur twice, that is all items listed are unique. Also, items are not index based like arrays. They are stored in an unorder manner (not neccessariy random order). Please note that to create a Set, an array must be passed as argument. Use case: When a set of values MUST be unique or you need to quickly check if an item exist. For example all handles on Twitter are unique.

// values are displayed in unorder manner
let daysOfWeek = Set(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])

// items listed cannot occur twice. Other occurences of 1 is discarded
// Randomly outputs {5, 1, 3, 4, 6}
let numbers = Set([1, 4, 6, 3, 5, 1, 1, 1])

// Creating an empty Set
let uniqueName = Set<String>()

Dictionaries - They store different values similar to arrays, but instaed of accessing item via the integer position, you can access them using the key. It uses a { key : value } format like JavaScript's object.

let statesCapital = [
    "Abia" : "Umuahia",
    "Lagos" : "Ikeja",
    "Adamawa" : "Yola"
]

// Prints out "Yola"
statesCapital["Adamawa"]

// Reading a value from a dictionary that doesn't exist returns nil.
statesCapital["Enugu"]

// However, you can return a default value if a key doesn't exist. It is called dictionary default values
statesCapital["Enugu", default: "Unknown"]

// to create an empty dictionary
let surnames = [String : String]()
// or
let surnames2 = Dictionary<Int, String>()

Arrays, Sets, and Dictionaries are called collections because they store different values.

Tuples - When a tuple is created, you cannot add or remove items from it. They are fixed in size. You can't change data types of items in a tuple. However, you can change or access an item in a tuple by its numerical index position or name like array. Use case: When you need a fixed collection of related values where each item has a precise position or name.

// Declaring a tuple
var fullName = (first : "Kehinde", middle : "Edward", last : "Odewole")

// Re-assigning the "first" key
fullName.first = "Taiwo"

// Re-assigning the "middle" key
fullName.1 = "Charles"

Enums - It is used to "group related values" that makes them usable easily. Use case: When you have a fixed sets of related values for a particular operation, it is suitable to use enum. For example there can only be 7 days in a week, genres of movies, suits in a deck of cards, months of the year.

// Declaring an enum
enum Result {
    case success
    case failure
}

// This always returns failure
let result = Result.failure

// Enums can also store associated values attached to each case. This lets us attach additional information to your enums so they can represent more meaningful data.
enum Activity {
    case bored
    case driving(destination : String)
    case singing(volume : Int)
}

let singing =  Activity.singing(volume: 50)

// Sometimes you need to assign values to enums so they have more meaning
// Swift will automatically assign each of those a number starting from 0, and you can use that number to create an instance of the appropriate enum case
enum Days_v1: Int {
    case Monday
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
    case Saturday
    case Sunday
}
// For example Prints Monday because Swift automagically assigns 0 to Monday.
let monday_v1 = Days_v1(rawValue: 0)

 // It’s not very natural for us to think of Monday as day 0, so you could re-write the Days enums like this:
// Now Swift will assign 1 to Monday and count upwards from there, meaning Sunday is the 7th day
enum Days_v2: Int {
    case Monday = 1
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
    case Saturday
    case Sunday
}

// Sunday is the seventh day. Yay!
let monday_v2 = Days_v2(rawValue: 7)

Thanks for reading🙏🏿.

You can find me on Twitter @RealKennyEdward

I'm on to Day3!

Day 1 of 100 Days of SwiftUI challenge

Odewole Kehinde — Wed, 15 Jan 2020 13:43:27 +0000

Introduction

Today I started learning SwiftUI using Paul Hudson's 100 Days of SwiftUI challenge.

I have attempted completing programming courses several times without any success. However, this time I'll be sticking with Paul's suggestion that posting one's progress can help get more motivation to scale through tough times.

Why Swift?

I set out to learn SwiftUI, but Paul stated that

"You can’t build software without having a programming language, so behind SwiftUI lies Swift itself: a powerful, flexible, and modern programming language that you’ll use for all your SwiftUI apps."

I am very optimistic I'll complete this challenge with this new approach.

Summary

Please find below a summary of my jottings on the first day of learning about Swift

Variables - It is used for storing program data. Its value can be changed in programs over time. Variables are created using the var keyword. Please note that Swift is a type-safe language, that is, every variable must be of one specific type.

// Declaring a variable
var language = "Objective-C"

// Changing the value of the variable
// You don't need to use "var" since the variable is already declared
language = "Swift"

Constants - When you need to set up a value once and never have to change it - you’ll use a constant. Constants are created using the let keyword. Please note that it’s preferable to use constants as often as possible.

// Declaring a constant
// If you attempt to change the value of a constant, you'll get a 
// "Cannot assign to value: 'constant_name' is a 'let' constant" error
let goldenRatio = 1.618

Type inference - Swift is able to infer the type of a variable based on how it was created.

// Swift automatically detects this is a String data type
var club = "Arsenal"

// Swift automatically detects this is a Constant data type
let gaussConstant = 0.835

Type annotations - Although Swift is able to infer the type of a variable, however, developers can specify the type of a variable themselves.

// Inform Swift this is a String data type
var club : String = "Arsenal"

// Inform Swift this is a Constant data type
let gaussConstant : Constant = 0.835

Integers - Its a data type used to store whole numbers. Please note that Swift also uses underscores as thousands separators which makes numbers in its millions easier to read. This doesn't change the value of the number itself.

let yearOfBirth = 1991

// You can explicitly declare its data type
var yearOfBirth : Int = 1991

// Thousand seperator feature
var amount = 500_000_000

Doubles - Double in Swift actually means "double-precision floating-point number". Its a data type used to store fractional number.

let total = 35_467.89

Booleans - Its a data type used to store true or false.

let isValid = true

Strings - Its a data type used to store string of letters. It starts and ends with double quotes.

let message = "Hello, Africa!"

String Interpolation - This is the ability to place variables, constants in strings to make it more useful. To place the variable/constant, you'll use a backslash and a bracket containing the variable/constant.

var balance = 7_000_000
var accountBalance = "Your account balance is \(balance)"

Thanks for reading🙏🏿.

You can find me on Twitter @RealKennyEdward