I learned a new programming language. On purpose.
For a long time, I wanted to write a client for Apples push notification system. APNS stands for 'Apple Push Notification System' and is responsible for delivering push notification to devices. The developers job is to aquire a device token from the device you want to push to and then send a request to APNS with the notification you want to push.

Last year, Apple introduces their second version of this API that replaced their binary interface in favor of HTTP2.

That is where Go-APNS comes into play: it lets you create and perform such a request easily.
I wrote detailed documentation on the project site but I want to highlight a few features here.

After you have created a Connection object by passing the path to your certificate as well as the keyphrase, you have completed the first step.

Now, the handy features of Go-APNS comes into play: it is very easy to construct the message you send to Apple. The documentation split it into two major parts: Header and Payload, which includes the Alert.

message := goapns.NewMessage().Title("Title").Body("A Test notification :)").Sound("Default").Badge(42)
message.Custom("customKey", "customValue")

Now you are ready to send them to APNS. Take the Connection you created in the first step and call conn.Push(message, tokens, responseChannel). You pass in the device token to which the notification should be sent to and a responseChannel which is a chan. Due to the fact, that the requests are performed asynchronously, the results are passed into this channel.
You get a Response object delivered in which a possible error is stored.

It was fun to learn a new language (Go) and tackle a problem that I wanted to address for a long time. Two weeks ago I started the beginner tutorial and now, I can release my first Golang project.
That beeing said, I invite you to try it out. As always, I appreciate every kind of feedback :)
Once again, here is the link to GitHub.

Here comes another open source project of mine: Async.

Async is a lightweight wrapper around Grand Central Dispatch that makes it easy to perform blocks on different threads and make them dependent on each other.

Lets say, you want to execute a request (for example on the file system or the network) on a background queue and afterwards update the UI.

let fetch = {
        self.birds = self.fetchLatestBirdsFromDisk()
}

let updateUI = {
        self.tableView.reloadData()
}

Now, you can use Async to chain those operations together:

Async.async(QOS: .Background, block: fetch).then(QOS: .Main, block: updateUI)

An alternative way to use Async is to call methods like .Main(...) or .Background(...).
These methods do exactly the same but with a different syntax. Feel free to chose the way you like better.
Therefore, the previous example could also be written as

Async.background(block:fetch).main(after: 2, block: updateUI)

In any case, you can specify a delay (in seconds) after which the block will be executed. The delay parameter is optional and nil (=0) by default.

It was one of my goal, to avoid nesting GCD call inside GCD call and thereby reduce the number of

})
            }

        })

    }

As usual, you can find the code on GitHub. Please let me know if you have any comments ☺️

It is time to submit my app to Apples WWDC scholarship program.

I have written about this project since I have started working and now it comes to an end.

I have prepared a video and uploaded it to YouTube.

The app is designed to be an interactive resume.
Therefore, everybody can get to know me by taking a look at this app. Additionally, the code is well documented and commented.
The point is to show my skills in designing and coding in the most approtiated form. I pay great attention to details and I want to show it in this app.

I put great efford and energy into this project and hope that you like it 🤗
After I have removed sensitive data, I upload the source code to GitHub.