Photo by <a href="https://unsplash.com/@ashkfor121?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Ashkan Forouzani</a> on <a href="https://unsplash.com/s/photos/puzzle-pieces?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>

# Exploring The Composable Architecture (TCA) - Part 1

In this series of posts, I'll be exploring the [Composable Architecture](https://github.com/pointfreeco/swift-composable-architecture) by building some apps. To start, let's build the simple todos app —Explained in detail in [these episodes](https://www.pointfree.co/collections/composable-architecture/a-tour-of-the-composable-architecture) by the creators—

The [Composable Architecture](https://github.com/pointfreeco/swift-composable-architecture) (TCA, for short) is a library for building applications consistently and understandably, with composition, testing, and ergonomics in mind. It can be used in SwiftUI, UIKit, and more, and on any Apple platform (iOS, macOS, tvOS, and watchOS).

Think of each screen as a small app, that can be run, tested, and debugged on its own, while at the end being able to compose it with other screens to form a full complex app.

## TCA building blocks

I noticed many similarities with TCA and Redux for React, the idea is each screen should have the following building blocks which can be later composed in larger units that form a complex app.

### State

A type that holds the current state of the application. usually represented as a struct.

### Action

A type that holds all possible actions that cause the state of the application to change. usually represented as an enum which —in combination with a switch— breaks in build time if one of the cases is not handled.

### Effect

A type that encapsulates a unit of work that can be run in the outside world, and can feed data back to the Store. such as network requests, saving/loading from disk, creating timers, etc.

### Environment

A type that holds all dependencies needed to produce Effects, such as API clients, analytics clients, random number generators, etc.

### Reducer

Think of the reducer as the brain that describes how to evolve the current state of an application to the next state, given some action, and describes what effects should be executed later by the store —if any—.

### Store

A store represents the runtime that powers the application. It is the object that you will pass around to views that need to interact with the application.

---

Back to our todos app, the app is a one-screen app, but could be divided into two main pieces:
1. Todo: the logic for interacting with a single todo item
2. Todos: the logic for interacting with a list of todo items.


## 1. Todo

> The state for a single todo item is a simple struct that represents what a todo is.

```swift
struct Todo: Equatable, Identifiable {
  var id: UUID
  var description = ""
  var isComplete = false
}
```

---

> The action is an enum representing all actions that can be performed on a single todo item.

```swift
enum TodoAction: Equatable {
  case checkBoxToggled
  case textFieldChanged(String)
}
```

---

> The environment is a place that stores all external dependencies required to create a todo, for now, it's going to be an empty struct.

```swift
struct TodoEnvironment {}
```

---

> The reducer is the brain that contains all business logic for manipulating the state, it takes an `inout` state, an action to perform, and an environment to get external dependencies from.
>
> The reducer can then emit effects when an action is performed, in this case, both actions do not emit any effects.

```swift
let todoReducer = Reducer<Todo, TodoAction, TodoEnvironment> { state, action, env in
  switch action {
  case .checkBoxToggled:
    state.isComplete.toggle()
    return .none
  case .textFieldChanged(let description):
    state.description = description
    return .none
  }
}
```

---

> The view needs a store to get state from and perform actions on. notice how the UI is wrapped in a `WithViewStore` wrapper, this ensures the view is only updated when there is a state change and provides a `viewStore` property that can be used to get state and send actions to the store to perform.
> 
> Unlike plain SwiftUI with Combine, **all state changes should be handled by the store**, so to provide a binding string to the text field, TCA comes with a `binding` method that defines a getter and setter for a given value.

<img src="https://media.graphcms.com/o9g7CLXuS1KMsLCcvqga" alt="Todo cell" width="400"/>

```swift
struct TodoView: View {
  let store: Store<Todo, TodoAction>

  var body: some View {
    WithViewStore(store) { viewStore in
      HStack {
        Button(action: { viewStore.send(.checkBoxToggled) }) {
          Image(systemName: viewStore.isComplete ? "checkmark.square" : "square")
        }
        .buttonStyle(.plain)

        TextField(
          "Untitled Todo",
          text: viewStore.binding(
            get: \.description,
            send: TodoAction.textFieldChanged
          )
        )
      }
      .foregroundColor(viewStore.isComplete ? .gray : nil)
    }
  }
}
```

---

## 2. Todos

> The model for the todos screen is a struct that has an `IdentifiedArray` of `Todo` items, this helps the view to loop over all items and connect them to a list, more on this later.

```swift
struct TodosState: Equatable {
  var todos: IdentifiedArrayOf<Todo> = []
}
```

---

> Like before, the action is an enum representing all actions that can be performed in the todos screen.
Notice how the last one takes an id for a todo and a **single todo action** to perform on it!

```swift
enum TodosAction: Equatable {
  case addTodoButtonTapped
  case delete(IndexSet)
  case sortCompletedTodos
  case todo(id: Todo.ID, action: TodoAction)
}
```

---

> This is an amazing feature of TCA, the environment provides two things:
> 1. a closure that is responsible for creating a UUID, we will create different closures for production and test, more on this later.
> 2. a scheduler that we'll use to delay sorting the checked todos, think of this as a `DispatchQueue` that we will be able to swap in tests with a test scheduler, the environment enables us to control time!

<img src="https://media.graphcms.com/lx7OJg3QdiQAepRsXMz6" alt="Moving todo rows all together" height ="600"/>

```swift
struct TodosEnvironment {
  var uuid: () -> UUID
  var scheduler: AnySchedulerOf<DispatchQueue>
}
```

---

> The reducer is a combination of two reducers here:
>
> 1. The single todo reducer *pulled back* to work on each item on the todos list. Notice the `\TodosAction.todo`, it's a [case path](https://github.com/pointfreeco/swift-case-paths), think of it as a key path but to enums.
>
> 2. a new reducer that handles all other actions in the screen, however, we're also handling the`.todo(.checkBoxToggled)` case here to emit an effect to wait 1 second after the last checkbox is toggled and sort the todos all at once for a better user experience.

> While we could have used a simple string for the debounced id here, using a private `Hashable` type ensures that the effect can not be mixed with other debounced effects throughout the app.

```swift
let todosReducer = Reducer<TodosState, TodosAction, TodosEnvironment>.combine(
  todoReducer.forEach(
    state: \.todos,
    action: /TodosAction.todo,
    environment: { _ in TodoEnvironment() }
  ),
  .init { state, action, env in
    switch action {
    case .addTodoButtonTapped:
      state.todos.insert(Todo(id: env.uuid()), at: 0)
      return .none

    case .delete(let indexSet):
      state.todos.remove(atOffsets: indexSet)
      return .none

    case .sortCompletedTodos:
      state.todos.sort { !$0.isComplete && $1.isComplete }
      return .none

    case .todo(let id, action: .checkBoxToggled):
      struct TodoCompletionId: Hashable {}
      return Effect(value: .sortCompletedTodos)
        .debounce(id: TodoCompletionId(), for: 1, scheduler: env.scheduler)

    case .todo:
      return .none
    }
  }
)
```

---

> Like the `TodoView`, the view needs a store to get state from and perform actions on.
>
> Notice how the list uses a `ForEachStore` that *scopes* the store to a sub-store for each todo item providing it with a single todo state, and *pulling back* its action to the `TodosAction.todo` case!

```swift
struct TodosView: View {
  let store: Store<TodosState, TodosAction>

  var body: some View {
    NavigationView {
      WithViewStore(store) { viewStore in
        List {
          ForEachStore(
            store.scope(state: \.todos, action: TodosAction.todo),
            content: TodoView.init
          )
          .onDelete { viewStore.send(.delete($0)) }
        }
        .navigationTitle("Todos")
        .toolbar {
          Button("Add Todo") { viewStore.send(.addTodoButtonTapped) }
        }
      }
    }
  }
}
```

---

## Putting everything together

Stating the app becomes as easy as creating a store and passing it to the `TodosView`!

```swift
@main
struct TodosApp: App {
  let store = Store(
    initialState: TodosState(),
    reducer: todosReducer,
    environment: TodosEnvironment(
      scheduler: .main,
      uuid: UUID.init
    )
  )

  var body: some Scene {
    WindowGroup {
      TodosView(store: store)
    }
  }
}
```

One nice thing we have here is replacing the entry point for the app with the single todo screen can be done effortlessly by changing the store with a single todo store, and passing it to a `TodoView` instead, this also enables us to create slices of the app and distribute it easily in more complex apps.

---

## Chained Reducers

We saw before how we combined two reducers in the todos screen, TCA promotes combining many reducers into a single one by running each one on the state in order and merging all of the effects.

This enables endless use cases like the `debug` reducer that comes with TCA, which prints debug messages describing all received actions and state mutations, simple by chaining it to any reducer!

Chaining it with the `todoReducer` will print the following debug messages in the console

```swift
todoReducer
  .debug()
```

```text
[!copy]
received action:
  TodoAction.checkBoxToggled
  Todo(
    id: UUID(54BA9336-DBFE-42BF-8C8A-25AB430611FC),
    description: "Buy milk",
-   isComplete: false
+   isComplete: true
  )
```

You can create a reducer that logs data, cache responses, send analytics events! Let's create a reducer that caches the state after each update, so when we restart the app we get it right back where it was before quitting!

### Building a reducer to persist app state

To start we will make both `Todo` and `TodosState` conform to `Codable`.

```swift
struct Todo: Equatable, Identifiable, Codable {
  // ...
}

struct TodosState: Equatable, Codable {
  // ...
}
```

Next, let's define a `Caching` protocol that represents an object that can save `Codable` objects with a given key.

```swift
protocol Caching {
  var key: String { get }
  func save<Value: Encodable>(_ value: Value)
  func load<Value: Decodable>() -> Value?
}
```

We can then create a `UserDefaultsCache` which saves the state to `UserDefaults`

```swift
final class UserDefaultsCache: Caching {
  init(
    key: String,
    decoder: JSONDecoder = .init(),
    encoder: JSONEncoder = .init()
  ) {
    guard let userDefaults = UserDefaults(suiteName: key) else {
      fatalError("Unable to create store with key: \(key)")
    }
    self.key = key
    self.userDefaults = userDefaults
    self.decoder = decoder
    self.encoder = encoder
  }

  let key: String
  let decoder: JSONDecoder
  let encoder: JSONEncoder
  let userDefaults: UserDefaults

  func save<Value: Encodable>(_ value: Value) {
    guard let data = try? encoder.encode(value) else { return }
    userDefaults.set(data, forKey: key)
  }

  func load<Value: Decodable>() -> Value? {
    guard let data = userDefaults.data(forKey: key) else { return nil }
    return try? decoder.decode(Value.self, from: data)
  }
}
```

Or a `DocumentsCache` that saves the state to the documents directory

```swift
final class DocumentsCache: Caching {
  init(
    key: String,
    fileManager: FileManager = .default,
    decoder: JSONDecoder = .init(),
    encoder: JSONEncoder = .init()
  ) {
    self.key = key
    self.decoder = decoder
    self.encoder = encoder

    self.fileUrl = fileManager
      .urls(for: .documentDirectory, in: .userDomainMask)[0]
      .appendingPathComponent("\(key).json")
  }

  let key: String
  let decoder: JSONDecoder
  let encoder: JSONEncoder
  let fileUrl: URL

  func save<Value: Encodable>(_ value: Value) {
    let data = try? encoder.encode(value)
    try? data?.write(to: fileUrl)
  }

  func load<Value: Decodable>() -> Value? {
    guard let data = try? Data(contentsOf: fileUrl) else { return nil }
    return try? decoder.decode(Value.self, from: data)
  }
}
```

Or another one that saves it to a CoreData or realm database ...

> See how the reducer is generic enough that can be used on any `Codable` state!

### Creating the `caching` Reducer

We can extend the `Reducer` where its `State` conforms to `Codable`, and provide a `caching(cache:)` function that takes any `Caching` store and uses it to save the state every time it changes.

Using the `fireAndForget`, we're asking the reducer to fire an effect in the background, where we don't care about getting the result back to the store.

```swift
extension Reducer where State: Codable {
  func caching(cache: Caching) -> Reducer {
    return .init { state, action, environment in
      let effects = self.run(&state, action, environment)
      let state = state
      return .merge(
        .fireAndForget {
          cache.save(state)
        },
        effects
      )
    }
  }
}
```

Even nicer we can provide an optional `isDuplicate` closure that compares the state before and after performing an action and save the state only when it changes!

```swift
extension Reducer where State: Codable {
  func caching(
    cache: Caching,
    ignoreCachingDuplicates isDuplicate: ((State, State) -> Bool)? = nil
  ) -> Reducer {
    return .init { state, action, environment in
      let previousState = state
      let effects = self.run(&state, action, environment)
      let nextState = state

      if isDuplicate?(previousState, nextState) == true {
        return effects
      }

      return .merge(
        .fireAndForget {
          cache.save(nextState)
        },
        effects
      )
    }
  }
}
```

> Imagine we have many more properties in the `TodosState` and all we care about is the todos list, this will ignore caching state changes that do not affect the todos list.

```swift
todosReducer
  .caching(
    cache: DocumentsCache(key: "todos"),
    ignoreCachingDuplicates: { $0.todos == $1.todos }
  )
```

We're almost done, all we need to do is to load the state from the cache and pass it to the store's initial state, and make sure the same cache is chained to the store's reducer!

```swift
@main
struct TodosApp: App {
  func createStore() -> Store<TodosState, TodosAction> {
    let cache = DocumentsCache(key: "todos")
    return .init(
      initialState: cache.load() ?? TodosState(),
      reducer: todosReducer.caching(
        cache: cache,
        ignoreCachingDuplicates: { $0.todos == $1.todos }
      ),
      environment: TodosEnvironment(
        scheduler: .main,
        uuid: UUID.init
      )
    )
  }

  var body: some Scene {
    WindowGroup {
      TodosView(store: createStore())
    }
  }
}
```

---

## Testing

Great testability is one of TCA's great features! Since all state mutations are happening in reducers, it is easy to test almost everything in the app with simple unit tests!

Those Environment objects provide a quick way to swap production dependencies with test ones.

To start, let's create a deterministic, auto-incrementing "UUID" generator for testing.

```swift
extension UUID {
  static var incrementing: () -> UUID {
    var uuid = 0
    return {
      defer { uuid += 1 }
      return UUID(uuidString: "00000000-0000-0000-0000-\(String(format: "%012x", uuid))")!
    }
  }
}
```

Here is an example of how to test adding a new todo item

TCA comes with a `TestStore` class that has a closure in its `send` method that can be used to verify state changes.

```swift
func testAddTodo() {
  let state = TodosState()
  let store = TestStore(
    initialState: state,
    reducer: todosReducer,
    environment: TodosEnvironment(
      scheduler: DispatchQueue.test.eraseToAnyScheduler(),
      uuid: UUID.incrementing
    )
  )

  store.send(.addTodoButtonTapped) {
    $0.todos.insert(
      Todo(
        id: UUID(uuidString: "00000000-0000-0000-0000-000000000000")!,
        description: "",
        isComplete: false
      ),
      at: 0
    )
  }
}
```

---

## What's Next?

TCA looks very promising, I enjoyed working with it 😊 and can't wait to use it in more complex apps to see how it plays with more advanced topics like navigation and UIKit.

The code above is a simpler version of the full Todos app with some bells and whistles and more tests available on [Github](https://github.com/omaralbeik/swift-composable-architecture-todos).

That’s it for now. If you have any questions, suggestions, or feedback, please let me know via [Twitter](https://twitter.com/omaralbeik) 👋

Exploring the Swift Composable Architecture by building a simple todos app with SwiftUI, then adding caching and other bells and whistles to it!

Exploring The Composable Architecture

I recently immigrated to Amsterdam with my family. It was a life-changing decision. In this post, I’ll try to share my experience from the moment we took the decision to leave Turkey up until this moment, and some tips and resources to bring you some insights if you are considering relocating.

## Why Amsterdam?

It was January 2019 when my wife and I took the decision to say goodbye to Istanbul, it was time for our next adventure. We wanted to move to a place with a higher quality of life and a better education system since our kids are growing quickly.

Before setting our mind on Amsterdam we had other options on our list including London, Berlin, Dublin, Stockholm, and Helsinki.

While each of these destinations is beautiful and unique in a different way, we favorited Amsterdam for the following reasons:

### Europe’s Rising Tech Hub

Amsterdam is rapidly developing into one of the most significant technology hubs of Europe and the world.

Inventions like Python, Vim, Blender, Compact Cassette, Compact Disc, and [more computer science inventions](https://en.wikipedia.org/wiki/List_of_Dutch_inventions_and_innovations#Computer_science_and_information_technology) have been invented here. It is simply, one of the best places on Earth if you are working in tech!

### Very International

The Netherlands has the [second highest](https://en.wikipedia.org/wiki/EF_English_Proficiency_Index) English as a second language proficiency in the world, nine out of ten Dutch people speak English fluently!

You don’t have to learn Dutch to live in the Netherlands, I have met many people who have been here for years and they don’t speak Dutch.

Amsterdam itself is formed of a wonderful multicultural mix of more than 180 nationalities, in fact, half of the population is not Dutch.

No matter where are you coming from, what is your ethnicity or religion, it is easy to find communities and cultural events for you, so far it was super easy for me and my family to fit in.

### Happy Place

The country has been in the top 10 worlds happiest countries [report](https://en.wikipedia.org/wiki/World_Happiness_Report) for a few years now.

In comparison with Istanbul, where there is a lot of stress everywhere; people here are happier, more open-minded, and relaxed. It is mainly because Amsterdam has an excellent quality of life. It’s clean and safe. It has a lovely environment, with little traffic or pollution and beautiful canals that give the city a special ambiance.

### Family and Child-Friendly

Although many people think of it as the sin city of Europe, Amsterdam is a wonderful place to raise kids and have a family, from activities for kids, to one of the best education systems in the world.

It is also because work-life balance here is very good, I get to spend more time with my family, I drop my son to school every morning, I feel it is a nice way to start my day by having a conversation about the school, life and things about the future from a young boy’s perspective.

### Perfect Size

Amsterdam is just the perfect size, it is not a huge city, but not a small one. Its impressive network of public transportation including ferries, trains, buses, trams, and metros is very reliable and accurate.

Amsterdam is also well known for its bike-friendly streets.

### Easy immigration process

The Netherlands has a relatively easy and fast immigration process for highly skilled migrants, the process takes 1~2 months.

---

## How to Move?

The easiest way to move to Amsterdam is to find a job, your employer then will initiate the immigration process for you.

To make the migration process faster make sure the employer is a [registered IND sponsor](https://ind.nl/en/Documents/Public_Register_Regular_Labour_and_Highly_Skilled_Migrants.pdf).

There are some websites to search for jobs in the Netherlands, however, Linkedin, Glassdoor, Stackoverflow, and relocate.me are familiar and have thousands of open positions in tech 😉

The immigration as a highly-skilled migrant in the Netherlands has a simple 3 steps

### 1. TEV applications

> 2~3 weeks

Your company will file your and your family’s entry and residence applications as a highly-skilled migrant with the Dutch immigration authorities in the Netherlands (IND).


### 2. MVV consular process

> ~1 week

Once your TEV application has been approved, you will need to apply for a long term Dutch entry visa (MVV visa) at the Dutch embassy/consulate in your home country or the country where you have legal residence.


### 3. Visiting the Expat Center

> ~1 day

Once you and your family have arrived in the Netherlands with the MVVs, you will be allowed to start working for your employer directly.

Several days later your employer will arrange a visit to the expat center where you will receive your residence permit card, BSN (social security) number, and finalize your migration process.

---

It is not an easy decision to move to a new country, especially if you have a family. I hope I tried to make things a little bit clearer in this post 😃

Read more about various aspects of the Netherlands in the links below, and let me know on [Twitter](https://twitter.com/omaralbeik) if you have any questions.

---

## Resources and Helpful websites

### Immigration and Visas

- [Netherlands and you](https://www.netherlandsandyou.nl/)
- [Immigration and Naturalisation Service (IND)](https://ind.nl/)

### Cost of living, income, and taxes

- [Cost of Living Estimator](https://www.numbeo.com/cost-of-living/city-estimator/in/Amsterdam)
- [Dutch Income Tax Calculator](https://thetax.nl)

### Finding an apartment

- [Funda](https://www.funda.nl/en/)
- [Pararius](https://www.pararius.com/english)
- [Huurwoning](https://www.huurwoningen.nl/in/amsterdam/)
- [TenantHub](https://tenanthub.nl/)
- [RentSlam](https://rentslam.com/en/amsterdam/)
- [!WOON | English information and support for tenants](https://www.wooninfo.nl/english/)

### Moving around

- [OV-chipkaart](https://www.ov-chipkaart.nl/home-1.htm)
- [NS](https://ns.nl/en)

### Shopping

- [Marktplaats](https://www.marktplaats.nl/)
- [bol.com](https://www.bol.com/nl/)
- [Coolblue](https://www.coolblue.nl/en/)


### Misc

- [The ultimate guide to moving to Amsterdam](http://blog.honeypot.io/moving-to-amsterdam-infographic/)
- [I Amsterdam - Your guide to visit, enjoy, live, work & invest in Amsterdam](https://www.iamsterdam.com/en)
- [IN Amsterdam - Official services for international newcomers](https://www.iamsterdam.com/en/our-network/in-amsterdam)
- [I am Expat | For expats of all colors, shapes & sizes](https://www.iamexpat.nl/)
- [My First Month booklet](https://www.iamsterdam.com/en/living/move-to-amsterdam/expat-resources/my-first-month-booklet)

### Communities
- [Expat-related groups and clubs in Amsterdam](https://www.iamexpat.nl/lifestyle/international-community/groups-clubs/expats/amsterdam)
- [InterNations | Community for expatriates & global minds](https://www.internations.org/)
- [Amsterdam Culture Club | I amsterdam](https://www.iamsterdam.com/en/living/feel-at-home-in-amsterdam/amsterdam-culture-club#aboutus)

My experience from the moment I took the decision to immigrate to Amsterdam until this moment, and some tips and resources to bring some insights if you are considering relocating.

Relocating to Amsterdam

When you use HTTPS, you need to authenticate (supply a username and password) each time you take an action that communicates with the remote server. Let’s see how we can use SSH (secure shell) to communicate with git websites like Github or Bitbucket and avoid having to manually type a password.

However, when using SSH, you create a key pair that contains a private key (saved to your local computer) and a public key (uploaded to your git website). The website then uses the key pair to authenticate anything the associated account can access.
This two-way mechanism makes performing git operations on your computer easier and prevents man-in-the-middle attacks.

In this quick tutorial, we will see how to generate keys, add them to your git website, and enforce the system to use SSH for all git operations. Let’s start!

---

## Generate the SSH keys

First things first, we need to generate a new SSH key.

Move to your `~/.ssh` directory —create a new folder if you don’t have it already—, and use the following command to create a new ssh key pair

```sh
ssh-keygen
```

Choose a key name that is easy for you to remember, example `personal-github` or `work-bitbucket`, …

---

## Add the public key to your git account

Copy the contents of your **.pub** key and add it to your git account, it is usually under **Settings** → **SSH**

- [Adding a new SSH key to GitHub](https://help.github.com/en/articles/adding-a-new-ssh-key-to-your-github-account)
- [Adding a new SSH key to Gitlab](https://docs.gitlab.com/ee/ssh/README.html#adding-an-ssh-key-to-your-gitlab-account) 
- [Adding a new SSH key to Bitbucket](https://confluence.atlassian.com/bitbucket/set-up-an-ssh-key-728138079.html)

---

## Enforce your system to use SSH instead of Http

Now that the key is added to your git account, we need to tell the system to use SSH instead of HTTPS for all requests to that website.

#### In your `~/.gitconfig` file:

```
# Enforce SSH instead of Http for git websites

## Github
[url "ssh://git@github.com/"]
  insteadOf = https://github.com/

## Gitlab
[url "ssh://git@gitlab.com/"]
  insteadOf = https://gitlab.com/

## Bitbucket
[url "ssh://git@bitbucket.org/"]
  insteadOf = https://bitbucket.org/
``` 

---

## Tell your system which key to use for each git website

In the previous step, we enforced the system to replace any HTTPS request with SSH for the git website, however, we need to specify which key to use as well, otherwise, git requests will fail.

#### In your `~/.ssh/config` file:

```
# Specify SSH key for each Git website

## Github
Host github.com
    User git
    IdentityFile ~/.ssh/<YOUR_SSH_KEY_NAME>

## Gitlab
Host gitlab.com
    User git
    IdentityFile ~/.ssh/<YOUR_SSH_KEY_NAME>

## Bitbucket
Host bitbucket.org
    User git
    IdentityFile ~/.ssh/<YOUR_SSH_KEY_NAME>
```

With the above setup, the system will use SSH automatically when performing git operations like `clone`, `fetch`, `pull`, …

Note that this will work for git operations other packages perform like Cocoapods!

---

That’s it for now. If you have any questions, suggestions, or feedback, please let me know via [Twitter](https://twitter.com/omaralbeik) 👋

Learn how to generate SSH keys, add them to your git website, and enforce the system to use SSH for all git operations.

Enforce SSH instead of HTTP for Git Operations

## TL;DR

A simple Swift extension to initialize `UIColor` from a hex string taking into consideration edge cases and hex representation variations


---


If you’re using an API to get colors to use them in your UIKit app, it is very likely that you’re getting them in hex format.

Representing colors with a [hexadecimal number](https://www.mathsisfun.com/hexadecimal-decimal-colors.html) is the industry standard and widely used everywhere, which keeps me wondering **why on earth doesn't Apple offer a built-in initializer to create a `UIColor` object from a hex value!**

While many answers on [Stack Overflow](https://stackoverflow.com/questions/1560081/how-can-i-create-a-uicolor-from-a-hex-string) works just fine, they ignore the problem that the same color might be represented in many ways using hexadecimal format.

> A quick search on Github or cocoapods.org will return many libraries to create `UIColor` from a hex string. Please don't add another dependency to your project just for this, it is just a few lines of code!

---

## Edge Cases

#### 1. Optional `#` Prefix

The hex string might -or might not- start with the `#` prefix, so `FF6347` and `#FF6347` are both valid representation for tomato color.

---

#### 2. Optional `0x` Prefix

The hex string might -or might not- start with the `0x` prefix, so `FF6347` and `0xFF6347` are both valid representation for tomato color.

---

#### 3. Representation Length

The standard length for a color representation in hex format is 6 (2 digits for each channel: red, green, and blue)

- `#000000`: black
- `#FFFFFF`: white
- `#FF0000`: red
- `#00FF00`: green
- `#0000ff`: blue

Other representations might add another two digits to the end to represent the alpha channel (transparency).

- `#FF000080` is the color red with 50% transparency - where 80 is the hex representation for 128 in decimal, (approximately 255/2).

Both above representations can be shorthanded to 3 and 4 digits respectively when each adjacent pair of digits are the same

- `#FF0000` becomes `#F00`
- `#AA00BBCC` becomes `#A0BC`

---

#### 4. Invalid Input

The string might be completely invalid

- `##FF0000`: contains more than # in prefix
- `AAFFNJ`: not a valid hex number
- `Lorem Ipsum`: normal string
- `#00FF00FF00FF`: completely valid hex number but does not have a valid length for a color representation

---

Here is a simple extension to `UIColor`  that takes care of all above edge cases, the initializer is failable to avoid crashes when the hex string is invalid

```swift
extension UIColor {
    convenience init?(hex: String) {
        var hexString = hex
        if hexString.hasPrefix("#") { // Remove the '#' prefix if added.
            let start = hexString.index(hexString.startIndex, offsetBy: 1)
            hexString = String(hexString[start...])
        }
        if hexString.lowercased().hasPrefix("0x") { // Remove the '0x' prefix if added.
            let start = hexString.index(hexString.startIndex, offsetBy: 2)
            hexString = String(hexString[start...])
        }

        let r, g, b, a: CGFloat
        let scanner = Scanner(string: hexString)
        var hexNumber: UInt64 = 0
        guard scanner.scanHexInt64(&hexNumber) else { return nil } // Make sure the string is a hex code.
        switch hexString.count {
        case 3, 4: // Color is in short hex format
            var updatedHexString = ""
            hexString.forEach { updatedHexString.append(String(repeating: String($0), count: 2)) }
            hexString = updatedHexString
            self.init(hex: hexString)

        case 6: // Color is in hex format without alpha.
            r = CGFloat((hexNumber & 0xFF0000) >> 16) / 255.0
            g = CGFloat((hexNumber & 0x00FF00) >> 8) / 255.0
            b = CGFloat(hexNumber & 0x0000FF) / 255.0
            a = 1.0
            self.init(red: r, green: g, blue: b, alpha: a)

        case 8: // Color is in hex format with alpha.
            r = CGFloat((hexNumber & 0xFF000000) >> 24) / 255.0
            g = CGFloat((hexNumber & 0x00FF0000) >> 16) / 255.0
            b = CGFloat((hexNumber & 0x0000FF00) >> 8) / 255.0
            a = CGFloat(hexNumber & 0x000000FF) / 255.0
            self.init(red: r, green: g, blue: b, alpha: a)

        default: // Invalid format.
            return nil
        }
    }
}
```

---

Using this extension is as easy as

```swift
let red = UIColor(hex: "#ff0000")
let tomato = UIColor(hex: "FF6347")
let silver = UIColor(hex: "C0C0C0")
```

A simple Swift extension to initialize UIColor from a hex string taking into consideration edge cases and hex representation variations

UIColor from HEX that Works!

Extensions are without any doubt one of Swift’s awesome features, they can be used to add new functionality to existing classes, structures, enumeration or even protocol types.

When I first started learning Swift I was fascinated by how powerful this can be, infect back then I created [SwifterSwift](https://github.com/swifterswift/swifterswift) an open source library for extensions that expanded quickly to have more than 500 extensions!

The more extensions we started to accept from contributors, the more conflicts we started to face, well, chances are if you have a nice extension, someone else has also thought about it as well and added it to their library!

To explain the problem in code; let’s assume we have two modules **A**, and **B**, **B** is the one we’re developing and **A** is a popular framework that everyone uses.

We’re super excited about this new extension that tells if a `Date` object is within today or not, so we’re adding it as a public variable in an extension in our framework.

#### Module A (the popular framework)

```swift
extension Date {
  public var isToday: Bool { ... }
}
```

#### Module B (our new framework)

```swift
extension Date {
  public var isToday: Bool { ... }
}
```

#### Using the extension from module B

```swift
Date().isToday
```

The above code will yield the error `Ambiguous use of ‘isToday’ with A`, that says both modules have the same extension (or at least 2 extensions with the same name), and the Swift compiler is confused which one to use 🤔

This is quite a situation here 😅! We can’t ask people not to use the module A, I mean common, it is very popular and in use everywhere. at the same time, we want people to start using our extension in their projects.

Wouldn’t it be great if we can have our extension grouped in one place and not conflicting with others?

Well, this is exactly what we're going to discuss here!

---

## Enter Protocol Extensions

The idea is simple, instead of extending types, create a wrapper struct with a base generic type, and extend your wrapper when the base is the type you want to extend

If you’ve used  [RxCocoa](https://github.com/ReactiveX/RxSwift/tree/master/RxCocoa), [Kingfisher](https://github.com/onevcat/Kingfisher), or [SnapKit](https://github.com/SnapKit/SnapKit)  you’ll probably understand what I mean here, it is that `rx`, `kf`, or `snp` extension that you use to access library's extensions so you don’t end up having conflicts with extensions from other libraries.

Let's talk some code shall we

### The Wrapper struct

```swift
public struct ExtensionsWrapper<Base> {
  // 1
  public var base: Base

  // 2
  public init(_ base: Base) {
    self.base = base
  }
}
```

1. The base object to extend
2. An initializer to creates extensions with the base object.

### The Compatible protocol

```swift
public protocol ExtensionsCompatible {
  // 1
  associatedtype CompatibleType
  // 2
  static var ext: ExtensionsWrapper<CompatibleType>.Type { get set }
  // 3
  var ext: ExtensionsWrapper<CompatibleType> { get set }
}
```

```swift
extension ExtensionsCompatible {
  public var ext: ExtensionsWrapper<Self> {
    get {
      return ExtensionsWrapper(self)
    }
    set {
      // 4
    }
  }

  public static var ext: ExtensionsWrapper<Self>.Type {
    get {
      return ExtensionsWrapper<Self>.self
    }
    set {
      // 4
    }
  }
}
```

1. The type of base object to extend
2. A static namespace holder for our extensions compatible types.
3. A namespace holder for our extensions compatible types.
4. An empty setter will enable using `ExtensionsWrapper ` to mutate base type

- - - -

### Example

Let's say we have this cool extension for `UILabel` that returns the trimmed text only if it has 1 or more non-whitespace or newline character in it

```swift
// 1
extension UILabel: ExtensionsCompatible {}

// 2
extension ExtensionsWrapper where Base: UILabel {
  public var trimmedText: String? {
    let aText = base.text?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
    if aText.isEmpty { return nil }
    return aText
  }
}
```

1.  Make `UILabel` conform to `ExtensionsCompatible`, this will add the `ext` extension to All `UILabel` types.
2.  Instead of extending `UILabel` directly extend `ExtensionsWrapper` explicitly when the `Base` is `UILabel`.


```swift
let label = UILabel()
label.text = "   hello world!  \n\n"
print(label.text) // prints "   hello world!  \n\n"
print(label.ext.trimmedText) // prints "hello world!"
```

---

## Summary

Of course, there are some cases that require types to be extended directly, however, my suggestion is to consider creating a wrapper type to hold your extensions before publishing your next project.

Not only this will minimize the number of conflicts with other extensions, but will offer a starting point to extend almost every type by conforming to your compatible protocol and extending the wrapper struct!

That's it for now. If you have any suggestions or feedback, please let me know via [Twitter](https://twitter.com/omaralbeik)!

Use the power of protocols and generic types to avoid extension conflicts

Protocol Oriented Extensions

In this post, I'll try to add some useful extensions to make working with the Codable protocol easier and more practical. Let's start!

### 1. Decode `Bool` from `Int` or `String`
Because, you know, sometimes the backend guys send us a `1` or `TRUE` and expect us to map it to native `Bool` object, well, they are kinda right, it shouldn't matter that much:

```swift
public extension KeyedDecodingContainer where Key: CodingKey {
  /// Try to decode a Bool as Int then String before decoding as Bool.
  ///
  /// - Parameter key: Key.
  /// - Returns: Decoded Bool value.
  /// - Throws: Decoding error.
 func decodeBoolAsIntOrString(forKey key: K) throws -> Bool {
    if let bool = try? decode(Bool.self, forKey: key) {
      return bool
    }
    if let bool = try? decode(String.self, forKey: key) {
      return bool == "1"
    }
    let int = try decode(Int.self, forKey: key)
    return int == 1
  }

  /// Try to decode a Bool as Int then String before decoding as Bool if present.
  ///
  /// - Parameter key: Key.
  /// - Returns: Decoded Bool value.
  /// - Throws: Decoding error.
 func decodeBoolAsIntOrStringIfPresent(forKey key: K) throws -> Bool? {
    if let bool = try? decodeIfPresent(Bool.self, forKey: key) {
      return bool
    }
    if let bool = try? decodeIfPresent(String.self, forKey: key) {
      return bool == "1"
    }
    if let int = try? decodeIfPresent(Int.self, forKey: key) {
      return int == 1
    }
    return nil
  }
}
```

## 2. Decode `URL` by adding a path to a base URL
Useful when the URL is just a path that is required to be added to a base URL to form the full URL

```swift
public extension KeyedDecodingContainer where Key: CodingKey {
  /// Decode a URL path with appending an optional base URL.
  ///
  /// - Parameters:
  ///   - baseUrl: Base URL
  ///   - key: Key
  /// - Returns: Decoded URL.
  /// - Throws: Decoding error.
  func decodeURL(baseUrl: URL?, forKey key: K) throws -> URL? {
    let path = try decode(String.self, forKey: key)
    return baseUrl?.appendingPathComponent(path)
  }

  /// Decode a URL path with appending an optional base URL (if URL present).
  ///
  /// - Parameters:
  ///   - baseUrl: Base URL
  ///   - key: Key
  /// - Returns: Decoded URL.
  /// - Throws: Decoding error.
  func decodeURLIfPresent(baseUrl: URL?, forKey key: K) throws -> URL? {
    guard let path = try decodeIfPresent(String.self, forKey: key) else { return nil }
    return baseUrl?.appendingPathComponent(path)
  }
}

public extension KeyedEncodingContainer where Key: CodingKey {
  /// Encode URL if present and move the Base URL from it.
  ///
  /// - Parameters:
  ///   - url: Optional URL.
  ///   - baseUrl: Base URL.
  ///   - key: Key.
  /// - Throws: Encoding error.
  mutating func encodeURLIfPresent(_ url: URL?, baseUrl: URL?, forKey key: K) throws {
    guard var string = url?.absoluteString else { return }
    guard let baseString = baseUrl?.absoluteString else { return }
    string.removeFirst(baseString.count)
    try encodeIfPresent(string, forKey: key)
  }
}


```

## 3. Save and retrieve `Codable` objects to `UserDefaults`
Because why not 😂

```swift
public extension UserDefaults {
  /// Retrieves a Codable object from UserDefaults.
  ///
  /// - Parameters:
  ///   - type: Class that conforms to the Codable protocol.
  ///   - key: Identifier of the object.
  ///   - decoder: Custom JSONDecoder instance. Defaults to `JSONDecoder()`.
  /// - Returns: Codable object for key (if exists).
  func object<T: Codable>(_ type: T.Type, with key: String, usingDecoder decoder: JSONDecoder = JSONDecoder()) -> T? {
    guard let data = value(forKey: key) as? Data else { return nil }
    return try? decoder.decode(type.self, from: data)
  }

  /// Allows storing of Codable objects to UserDefaults.
  ///
  /// - Parameters:
  ///   - object: Codable object to store.
  ///   - key: Identifier of the object.
  ///   - encoder: Custom JSONEncoder instance. Defaults to `JSONEncoder()`.
  func set<T: Codable>(object: T, forKey key: String, usingEncoder encoder: JSONEncoder = JSONEncoder()) {
    let data = try? encoder.encode(object)
    set(data, forKey: key)
  }
}

```

---

## Example

Let's say we have an object called `Image` that has an id, url, and a boolean property indicating whether is it a gif or not, with the following JSON:

```json
{
    "id": "test",
    "url": "test.png",
    "is_gif": 0
}
```

Here is how we can use the above extensions to map the object, even more, save, and retrieve it from UserDefaults:

```swift
struct Image: Codable {
  let id: String
  let url: URL?
  let isGif: Bool

  enum CodingKeys: String, CodingKey {
    case id
    case url
    case is_gif
  }

  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)

    id = try container.decode(String.self, forKey: .id)

    let baseUrl = URL(string: "your base url")!
    url = try container.decodeURL(baseUrl: baseUrl, forKey: .url)
    isGif = try container.decodeBoolAsIntOrString(forKey: .is_gif)
  }

  func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(id, forKey: .id)
    let baseUrl = URL(string: "your base url")!
    try container.encodeURLIfPresent(url, baseUrl: baseUrl, forKey: .url)
    try container.encode(isGif, forKey: .is_gif)
  }

  static func save(_ image: Image) {
    UserDefaults.standard.set(object: self, forKey: image.id)
  }

  static func image(for id: String) -> Image? {
    return UserDefaults.standard.object(Image.self, with: id)
  }
}
```

---

That's it for now. I'll be adding more extensions here, feel free to save this page and come back from time to time if you like the above extensions!

If you know other useful extensions or tips for using the Codable protocol, please let me know via [Twitter](https://twitter.com/omaralbeik)!

Some extensions to make working with Codable easier!

Codable + Extensions

An awesome list is a list of awesome things curated by the community. There are awesome lists about everything from CLI applications to fantasy books. The main repository serves as a curated list of awesome lists. Yes, [an awesome list of awesome lists](https://github.com/sindresorhus/awesome) :)

I have been using awesome lists throughout my career as a quick and rich source for curated apps and frameworks for many years now. Lately, I started to think, how can I take the idea and move it to the next level?

While awesome lists serve their purpose well, they fall short in some areas:

### Poor Visual Design
Usually, awesome lists are formatted as a markdown document; they lack visual design, which makes it hard to browse and scan quickly for a specific item due to the lack of icons.

### No Install instruction
All that most awesome lists provide is a name, link, and short description. Further information about installing the item is in the item's website or README page.

### Not able to install many items at once
There is no "Add to my list" option, where you can select many items and install them at once.

---

## Meet MaxItUp

![MaxItUp](https://media.graphcms.com/RNFPijqTQlOqse0FN8nm)

[MaxItUp](https://max-itup.github.io/mac/) is not only an awesome list for MacOS apps and packages. It is a tool to create a setup script for newly formatted Mac devices as well that contains apps, packages, system preferences and more…

Just start selecting items from the list and watch how the setup script is updating!
After downloading the setup script, move to your download directory and use your Terminal to run the script and install selected apps and packages by running

```bash
sh setup.sh
```

Your all set, your Terminal will inform you about the progress of the install and when the setup process is done.

---

The project is 100% open source and consists of two main repositories

### [/contents repo](https://github.com/max-itup/content)
The JSON file contains two arrays, one for categories and another for items, changing this file will change the content in the website. Adding your contribution is just a pull request away!

### [/mac repo](https://github.com/max-itup/mac)
Contains the source code for mac website, built using React, Redux, CSS flexboxes, and other cool technologies.

---

## Visit the website
[MaxItUp](https://max-itup.github.io/mac/)

---

MaxItUp is still in its early stages, and your feedback and support is very important. If you have a suggestion please open an issue, or if you like the project please give it a star on [Github](https://github.com/max-itup/mac/stargazers) and share it on [Twitter](https://twitter.com/home?status=Check%20out%20MaxItUp,%20the%20new%20way%20to%20set%20up%20your%20newly%20formatted%20Mac!%20by%20@omaralbeik%0Ahttps://max-itup.github.io/mac/) to let others know about it.

## Thanks
- [Bashar Ghadanfar](https://github.com/lionbytes) for coming up with the name **MaxItUp!** and designing the project's visual identity.
- [Max Howell](https://twitter.com/mxcl) for creating [Homebrew](https://brew.sh/), without him, MaxItUp would not exist.

Meet MaxItUp, the new awesome list for MacOS apps, packages and more!

Rethinking Awesome Lists

We **love** using [CocoaPods](https://cocoapods.org/) to manage dependencies in all our iOS projects, it enables us to create a project and start working in literally few minutes!

However I started having some hard times keeping my iOS projects in sync with what the amazing Swift community is doing, not only the language is changing fast, but projects as well, new projects are born and old ones are being refactored and replaced quickly.

In this tutorial, I’ll explain a suggested workflow for managing 3rd party dependencies and how to make the `Podfile`, well, a little bit more interesting 😉

Let’s assume that we’re working on version 1.0.0 of a project that has the codename **Apollo**

> A codename is a something we use at my company to identify our project publicly while in development without disclosing much information about them.  

> [Semantic Versioning](https://semver.org/) is what we use for versioning.  

Let's also assume that the following dependencies have to be used to build the project

- [RxSwift](https://github.com/ReactiveX/RxSwift)
- [Moya](https://github.com/Moya/Moya)
- [Kingfisher](https://github.com/onevcat/Kingfisher)


For each project from the dependencies above:

1. Fork the dependency to our [GitHub](https://github.com/) organization account
	- If the project is already forked, make sure to sync the fork with upstream to get the latest updates before proceeding, [more here](https://help.github.com/articles/syncing-a-fork/).
2. Create a new branch — from wherever the current stable release is — with the name `{codename}-{version}`, for our example it will be `apollo-1.0.0`
3. Use the following template to add dependencies to our `Podfile`:
```ruby
platform :ios, '9.0'

# Global variables
REPO = 'https://github.com/GITHUB_ORGANIZATION_NAME'
BRANCH = 'CODENAME-VERSION'

target 'TARGET_NAME' do
	use_frameworks!

	## Dependencies
	pod 'LIBRARY_1', git: "#{REPO}/LIBRARY_1", branch: "#{BRANCH}"
	pod 'LIBRARY_2', git: "#{REPO}/LIBRARY_2", branch: "#{BRANCH}"
  # ...

end
```

For our example:
```ruby
platform :ios, '9.0'

REPO = 'https://github.com/GITHUB_ORGANIZATION_NAME'
BRANCH = 'apollo-1.0.0'

target 'Apollo' do
	use_frameworks!
	pod 'RxSwift', git: "#{REPO}/RxSwift", branch: "#{BRANCH}"
	pod 'Moya', git: "#{REPO}/Moya", branch: "#{BRANCH}"
	pod 'Kingfisher', git: "#{REPO}/Kingfisher", branch: "#{BRANCH}"

end
```

## Benefits

- Have all 3rd party dependencies versions used in a specific version of our app is now grouped by a single keyword, say it is 1 year later, the current version for project Apollo is 4.3.0 and we want to debug something in version 1.7.0, all we have to do is just update the version number in Podfile, and perform a quick `pod update`.
- We **own** a copy of any open-source dependency we use, if the maintainer decided to shutdown the project, well, at least we have more time to evaluate other options, or if it is important enough, maybe continue developing our fork.
- Cherry-picking code from a dependency becomes as easy as creating a branch and update the code to keep only what we need, and remove what we don’t.
- Fix bugs faster than dependencies maintainers sometimes.
- Hopefully this will help other developers in our team to contribute back as soon as they fix any bug, We’re not sure, let’s see how this will go for a while :)


> We’re now working on a script to update our forks, create new branches, update the `Podfile` and automate the whole process.  


If you have any questions or suggestions, don’t hesitate to reach out to me on [Twitter](https://twitter.com/omaralbeik).

Suggested workflow for managing 3rd party dependencies and how to make the Podfile, well, a little bit more interesting!

Using Cocoapods in Large Scale Apps

It was April 20th, 10:32 pm when I received an email from Apple with the subject **You’ve won a WWDC18 Scholarship**.
I was extremely excited as Apple offered me not only the opportunity to attend WWDC18, but agreed to pay for my travel and lodging expenses for the week as well 😃
I arrived in San Jose on Saturday, June 2nd, two days before the conference after a long flight; 13 hours from Istanbul and stayed for an amazing 8 days!

In this article, I’ll share my experience throughout the week, what I learned, and some tips for future attendees.


## The new Apple Park is simply mind-blowing!

![Apple Park](https://media.graphcms.com/lXHd1ECGSy6MC1yHPLTg)

A day before the conference, Apple took all 350 scholarship winners to an orientation at the Apple Park; their new campus, we had an open buffet at Caffe Macs, the food was delicious with many options, then asked if we’re ready to walk to the secret location where the orientation will occur, it was the Steve Jobs Theater, and Oh my god! it is an art masterpiece, where you see clearly how art and architecture mix in a very unique way!

[Esther Hare](https://twitter.com/eehare) and [Tim Isted](https://twitter.com/timisted) welcomed us and gave a presentation about diversity, accessibility, environmental responsibility, and how we can have an impact on the world and make it a better place.
[Tim Cook](https://twitter.com/tim_cook) appeared and congratulated us, we took a group photo with him, and I was lucky to get my selfie with him 😎

Apple staff gave us a pair of AirPods each 🤩, we spent some time at the [Visitor Center](https://www.apple.com/retail/appleparkvisitorcenter/) enjoying some fine coffee and exploring the campus using AR!

![WWDC '18 Orientation](https://media.graphcms.com/dujuseTxTCu563c8jTta)

## It is never too late, (or too early)

![Anyone can code](https://media.graphcms.com/02F25776TuKIlTBr93Zv)

While waiting in the line for the opening keynote next day I got to meet many developers of a very wide range of ages. [Niall Kehoe](https://twitter.com/KehoeGames) who is just 14 and yet this was his second time to WWDC! and others who were over 60 years.
If you are not sure if it is the right time to start — or continue — learning programming, well, you are wrong, you should start right now!


## Apple’s ecosystem is very healthy right now

![Ecosystem](https://media.graphcms.com/97lKZMBHRmwdpMPs9oif)

While Apple released software updates to iOS, tvOS, macOS, and watchOS which impressive performance improvements and new features at the opening keynote, what caught my attention the most, was how their ecosystem is very healthy, iOS 11 install base is over 85%, this enabled them to become the largest [Augmented Reality](https://developer.apple.com/arkit/) platform in the world in less than 2 years!

## A different approach to Machine Learning

![A different approach to Machine Learning](https://media.graphcms.com/fBiiDTZKRmalu58a2DV6)

While Google, Amazon, and others are leading the AI revolution, Apple is not resting on their laurels, instead, they have a very different approach, their strategy is focused on running machine learning locally instead of sending users data to the cloud. Advanced tasks like face detection, image processing, and natural language processing are run offline on the device without the need for an internet connection. This sets Apple away from the competition and sets a new benchmark for how user privacy should be respected and not compromised!


## Swift is growing rapidly, but ObjC will not die anytime soon

![ObjC](https://media.graphcms.com/DAwd4E9qSx1dvbXEbOQy)

Swift is one of the fastest-growing programming languages out there, but Objective-C is still very popular, I met many developers who are not only maintaining existing Objective-C codebases, but starting new projects using it as well. The fact that Apple uses Objective-C heavily in their operating systems and apps makes it a very important language.

Apple stated that 350,000 apps on the AppStore are now written in Swift, but keep in mind that there are still 1,850,000 apps in Objective-C.

It never hurts to learn some Objective-C beside Swift, I guess that will be one of my goals for 2019 😉


## Planning to attend WWDC19, here are some tips

- You’re at WWDC for a few days, come prepared with questions for Apple engineers, ask for feedback on your code.
- Sessions are great, they have tons of knowledge, but remember they are available online, you can watch them later, focus more on labs, ask questions and meet Apple engineers.
- You have thousands of smart, talented and diverse people in one place, this is a great opportunity to make new friends. Talk to people, listen and show interest.
- Lyft and Uber are great ways to move around quickly, however, 🛴 were much cooler!
- California is awesome, have fun and enjoy the week!
- Follow me on [Twitter](https://twitter.com/omaralbeik), I’ll post more tips before WWDC19 😁


## Finally

Attending WWDC was an exceptional experience, it was an experience of a lifetime, I learned new skills and met amazingly brilliant people.
I am very grateful to Apple for their support and wish to see you all again at WWDC19!

![Scolars](https://media.graphcms.com/p4iSg3QuTnG7UROPc5ja)

My experience throughout WWDC '18, what I learned, and some tips for future attendees.

My WWDC18 Scholarship Experience

In my [previous post](https://www.omaralbeik.com/blog/make-mvc-great-again-1), I suggested a way to make MVC great again using Generics, extensions, and Protocols. Today we will build on top of that to handle keyboard events :)


## The problem
Update UIView layout and adapt to system keyboard event notifications.


## The Solution
We will introduce two new protocols and an extension.


### The `KeyboardObserving` Protocol
Conform to this protocol in a view controller to register to, unregister from keyboard events and pass notifications to its view
```swift
protocol KeyboardObserving: AnyObject

	func keyboardWillShow(_ notification: Notification)
	func keyboardDidShow(_ notification: Notification)
	func keyboardWillHide(_ notification: Notification)
	func keyboardDidHide(_ notification: Notification)
	func keyboardWillChangeFrame(_ notification: Notification)
	func keyboardDidChangeFrame(_ notification: Notification)
	func registerForKeyboardEvents()
	func unregisterFromKeyboardEvents()

}
```
We will extend the `KeyboardObserving` protocol with a default implementation, this will make its methods optional as well


### The `KeyboardControllable` Protocol
Conform to this protocol in a view to respond to keyboard events
```swift
protocol KeyboardControllable: AnyObject {

	func handleKeyboardWillShow(_ notification: Notification)
	func handleKeyboardDidShow(_ notification: Notification)
	func handleKeyboardWillHide(_ notification: Notification)
	func handleKeyboardDidHide(_ notification: Notification)
	func handleKeyboardWillChangeFrame(_ notification: Notification)
	func handleKeyboardDidChangeFrame(_ notification: Notification)
	
}
```
Again we will extend the KeyboardControllable protocol with a default empty implementation, this will make its methods optional as well

### `Notification` Extensions
`keyboardSize` and `keyboardAnimationDuration` properties will give us an easy way to get keyboard info from the system notification
```swift
extension Notification {

	var keyboardSize: CGSize? {
		return (userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue.size
	}

	var keyboardAnimationDuration: Double? {
		return userInfo?[UIKeyboardAnimationDurationUserInfoKey] as? Double
	}

}
```


## Example
Let’s update the same example from my [previous tutorial](https://www.omaralbeik.com/blog/make-mvc-great-again-1) to push up text fields in `LoginView` when the keyboard is presented and center them back when the keyboard is hidden.


#### `LoginView.swift`

```swift
// 1. conform to KeyboardControllable protocol
class LoginView: View, KeyboardControllable {

	...

	// 2. handle keyboard will show
	func handleKeyboardWillShow(_ notification: Notification) {
		// 3. get keyboard height from received notification
		let keyboardSize = notification.keyboardSize
		let keyboardHeight = keyboardSize?.height ?? 250
		// 4. update stackView constrains based on keyboard height
		stackView.snp.updateConstraints {
			$0.bottom.equalToSuperview().inset(40 + keyboardHeight)
		}
		layoutIfNeeded()
	}

	// 5. handle keyboard will hide
	func handleKeyboardWillHide(_ notification: Notification) {
		stackView.snp.updateConstraints {
			$0.bottom.equalToSuperview().inset(40)
		}
		layoutIfNeeded()
	}

	...

}
```


#### `LoginViewController.swift`

```swift
// 1. conform to KeyboardObserving protocol
class LoginViewController: ViewController<LoginView>, KeyboardObserving {

	override func viewDidLoad() {

		...

		// 2. register for keyboard event notifications
		registerForKeyboardEvents()
	}

	// 3. observe keyboardWillShow
	func keyboardWillShow(_ notification: Notification) {
		customView.handleKeyboardWillShow(notification)
	}

	// 4. observe keyboardWillHide
	func keyboardWillHide(_ notification: Notification) {
		customView.handleKeyboardWillHide(notification)
	}

	...

	deinit {
		// 5. unregister from keyboard notifications
		// to avoid memory leaks
		unregisterFromKeyboardEvents()
	}

}
```


## Where to go from here?
- See the example Xcode project on [Github](https://github.com/omaralbeik/making-mvc-great-again/tree/2-handling-keyboard)
- If you have any questions or suggestions, don’t hesitate to reach out to me on [Twitter](https://twitter.com/omaralbeik).

Keyboard Events Handling using Protocols in Swift

[Model-View-Controller](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) is a very common software structure for creating applications in the Apple ecosystem.

Although MVC is a straightforward concept, developers most often miss use it and turn it into MVC; standing for “Massive View Controller” structure.

In this post, we will see how we can make MVC great again by using some simple techniques like generics, protocols, extensions, convenience initializers, and more, so let’s start!

Our app is a very simple app with one screen: login screen where users will be able to enter their email and password and the app will print them in the console.

First, we will start by getting rid of the source of all evil, Storyboards 😈

## What is wrong with Storyboards?
While Apple promotes Storyboard as the standard way to develop user interfaces for its ecosystem, Storyboards have major problems like:

- Slow performance and compile time.
- They are not git friendly, they make working in a team harder due to their XML nature.
- Storyboards fail at runtime, not at compile time which makes them a huge source of unknown bugs and problems.
- And [more problems in this gist …](https://gist.github.com/iraycd/01b45c5e1be7ef6957b7)

Personally, I find myself facing scalability issues every time I use storyboards or xib files in a project.
however, when I tried to write my UI code programmatically, view controllers got even bigger and harder to maintain which defeated the entire purpose of fighting Massive View Controllers 😭

## The solution

1. Subclassing `UIView` and `UIViewController`
2. Move all UI and layout code away from view controllers.
3. Use extensions to organize view controllers
4. Use convenience initializers to initialize and set common UI elements in one line.

### Subclassing `UIView`:
We’ll create a new base class called `View` that we will subclass and use from now on, instead of `UIView`

```swift
class View: UIView {

	override init(frame: CGRect) {
		super.init(frame: frame)
		setViews()
		layoutViews()
	}

	required init?(coder aDecoder: NSCoder) {
		super.init(coder: aDecoder)
		setViews()
		layoutViews()
	}

	/// Set your view and its subviews here.
	func setViews() {
		backgroundColor = .white
	}

	/// Layout your subviews here.
	func layoutViews() {}
	
}
```

### Subclassing `UIViewController`:
As we did with `View` we’ll create another new base class called `ViewController` that we will subclass and use from now on, instead of `UIViewController`

```swift
class ViewController<V: View>: UIViewController {

	override func loadView() {
		view = V()
	}

	var customView: V {
		return view as! V
	}

}
```

- - - -

### All together in the login example
#### `LoginView.swift`
```swift
protocol LoginViewDelegate: class {
	func loginView(_ view: LoginView, didTapLoginButton button: UIButton)
}

class LoginView: View {

	weak var delegate: LoginViewDelegate?

	var emailAddress: String {
		return emailTextField.text?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
	}

	var password: String {
		return passwordTextField.text ?? ""
	}

	private lazy var emailTextField: UITextField = {
		let textField = UITextField()
		textField.placeholder = "Email Address"
		textField.keyboardType = .emailAddress
		return textField
	}()

	private lazy var passwordTextField: UITextField = {
		let textField = UITextField()
		textField.placeholder = "Password"
		textField.isSecureTextEntry = true
		return textField
	}()

	private lazy var loginButton: UIButton = {
		let button = UIButton(type: .system)
		button.setTitle("Login", for: .normal)
		return button
	}()

	override func setViews() {
		super.setViews()
		addSubview(emailTextField)
		addSubview(passwordTextField)
		addSubview(loginButton)
		loginButton.addTarget(self, action: #selector(didTapLoginButton(_:)), for: .touchUpInside)
	}

	override func layoutViews() {
		// layout your subviews here, consider using SnapKit, it is amazing!
	}

}

// MARK: - Actions
private extension LoginView {

	@objc
	func didTapLoginButton(_ button: UIButton) {
		delegate?.loginView(self, didTapLoginButton: button)
	}

}
```

#### `LoginViewController.swift`
```swift
class LoginViewController: ViewController<LoginView> {
	
	override func viewDidLoad() {
		super.viewDidLoad()
		customView.delegate = self
	}
	
}

// MARK: - LoginViewDelegate
extension LoginViewController: LoginViewDelegate {
	
	func loginView(_ view: LoginView, didTapLoginButton button: UIButton) {
		print("Email Address: \(customView.emailAddress)")
		print("Password: \(customView.password)")
	}
	
}
```


### Bonus
Use `convenience init` to stop writing the same code again and again:

```swift
extension UITextField {

	convenience init(placeholder: String, keyboardType: UIKeyboardType = .default, isSecureTextEntry: Bool = false) {
		self.init()

		self.placeholder = placeholder
		self.keyboardType = keyboardType
		self.isSecureTextEntry = isSecureTextEntry
	}

}

extension UIButton {

	convenience init(type: UIButtonType = .system, title: String?, image: UIImage?) {
		self.init(type: type)

		self.setTitle(title, for: .normal)
		self.setImage(image, for: .normal)
	}

}
```

### The new `LoginView`

```swift
protocol LoginViewDelegate: class {
	func loginView(_ view: LoginView, didTapLoginButton button: UIButton)
}

class LoginView: View {

	weak var delegate: LoginViewDelegate?

	var emailAddress: String {
		return emailTextField.text?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
	}

	var password: String {
		return passwordTextField.text ?? ""
	}

	private lazy var emailTextField: UITextField = {
		return UITextField(placeholder: "Email Address", keyboardType: .emailAddress)
	}()

	private lazy var passwordTextField: UITextField = {
		return UITextField(placeholder: "Password", isSecureTextEntry: true)
	}()

	private lazy var loginButton: UIButton = {
		return UIButton(title: "Login", image: nil)
	}()

	override func setViews() {
		super.setViews()
		addSubview(emailTextField)
		addSubview(passwordTextField)
		addSubview(loginButton)
		loginButton.addTarget(self, action: #selector(didTapLoginButton(_:)), for: .touchUpInside)
	}

	override func layoutViews() { ... }

}
```

## Conclusion
1. Keep your layout code **AWAY** from the view controller
2. Use `private` to keep your UI code inaccessible from view controllers unless there is a very good reason not to do so.
3. Create base `UIView` and `UIViewController` subclasses and use generics and protocols, to keep that damn `viewDidLoad` method clean!
4. Use convenience initializers to initialize UI elements and set their properties in one line.


## Where to go from here?
- Continue to [part 2](https://www.omaralbeik.com/blog/make-mvc-great-again-2) where we will build on top of this to handle keyboard events.
- See the example Xcode project on [Github](https://github.com/omaralbeik/making-mvc-great-again/tree/1-base)
- If you have any questions or suggestions, don’t hesitate to reach out to me on [Twitter](https://twitter.com/omaralbeik).

Use generics, protocols, and extensions to get rid of massive view controllers

Making MVC Great Again!

Articles about Swift, iOS development, open-source, and other software-related topics.

Blog