Introducing Billie, the smart invoice assistant on macOS

I’m very excited to introduce Billie, the smart invoice assistant on macOS.

Meet Billie, the smart invoice assistant for macOS!
After more than a decade of building iOS applications, it was time to get my feet wet and build something for macOS.
The past 3 months I’ve been working hard to release my first macOS application to make renaming & archiving invoices easy and quick, of course with a touch of machine learning (as you do nowadays).

Last week I’ve launched Billie on ProductHunt and at the end of the day, Billie ended as the #9 project of the day!

Continue reading Introducing Billie, the smart invoice assistant on macOS

Announcing Clockwise App

The past few weeks I have been working on a iOS application for kids to learn to read the clock. So today, I’m really excited to announce that Clockwise – Learn to read the clock is available in the App Store!

I already had the idea for a while to create an educational app for my 3 kids, but because of the Covid19 pandemic, I finally decided to have a go at it.

The game has been made in Swift 5.2 & Apple’s SpriteKit framework. The books of Paul Hudson ( were really helpful as I did not have any experience a few months ago with SpriteKit.

Go ahead, download Clockwise, and let me know what you think!

Streamlining lots of View Controller interactions with Swift enums.

What ‘problem’ am I trying to solve?

In most cases a View Controller shows one screen to a user, but the user can interact with the screen in multiple ways. Every one of these interactions is handled differently in code. This can be through delegation, target-action, notifications, callbacks, …

For example, take the Travelplanner screen of the Reisplanner Extra app I’m working on.

Overview actions on TravelPlanner screen

  1. A modal Location Picker is presented when the row is pressed
  2. From & To locations are switched when pressed
  3. A modal Location Picker is presented when the row is pressed
  4. A modal Date Picker is presented when the row is pressed
  5. The Now toggle button can be in an on/off/automatic state and changes the behavior of the time row
  6. A modal Travel Options screen is presented when the button is pressed
  7. 8. 9. 10. … more actions 🙂

As you can see, there are a lot of interactions (and there are actually even more interactions for different states of this screen), and all of these interactions need to be handled in code.

In most cases you’ll end up with all kinds of different methods handling these cases, but over time it can start to become unclear where to look when something needs to be changed or added inside your View Controller.

When a (new) team member has to work in the codebase that he has never touched before, it can take some time to find his/her way and know where to look. So how do I try to streamline this?

Swift Enums, your best friend.

Every interaction on the screen, triggers something, and I model all these interactions in a Swift enum called PerformAction .

The enum for the TravelPlanner screen looks like this:

enum PerformAction {
    case fromLocationRowPressed( location:Location? )
    case toLocationRowPressed( location:Location? )
    case switchLocationButtonPressed
    case departureArrivalRowPressed( queryType:TravelTimeQueryType, date:Date )
    case nowButtonPressed
    case travelOptionsButtonPressed
    case widgetDirectTo_optionsButtonPressed
    case widgetDirectTo_configureAddressButtonPressed
    case widgetDirectTo_selectLocation( location:Location )
    case widgetCiCo_optionsButtonPressed
    case nothing


This enum is added as a nested type inside the TravelPlannerViewController, so you can reuse the same PerformAction enum name across your files without getting name collisions.

class TravelPlanneViewController: UIViewController {

    enum PerformAction { ... }

If a new member starts reading through your codebase, he/she can check this enum and see at a glance what all the different actions are for this screen.

To react on these interactions, we create a property performedActionand add a didSet property observer.

var actionPerformed:PerformAction = .nothing {

    didSet {
        switch actionPerformed {
        case .fromLocationRowPressed( let location ):
            presentLocationPicker( location: location )
        case .toLocationRowPressed( let location ):
            presentLocationPicker( location: location )
        case .switchLocationButtonPressed:
        case .departureArrivalRowPressed( let queryType, let date ):
            presentDatePicker( queryType, date: date )



Now you have 1 point of entry to handle all your interactions and call your methods.

@IBAction func fromLocationPressed( _ sender: UIButton ) {
  actionPerformed = .fromLocationRowPressed( location: fromLocationRow.location )

@IBAction func switchButtonPressed( _ sender: UIButton ) {
  actionPerformed = .switchLocationButtonPressed

When using RxSwift I use a PublishSubject to keep track of changes.

// Create the subject to keep track of the performed actions
private let performedActionSubject = PublishSubject<PerformedAction>()
// Add a new action to the stream
performActionSubject.onNext( .travelOptionsButtonPressed )
// Get updates when an action has been performed
viewModel.outputs.actionPerformedObservable.subscribe(onNext: { [weak self] (performedAction) in
    switch performedAction {
        case ...

}).disposed( by: disposeBag )

Final thoughts

This is not a technique I use for a screen with only one or two actions. I tend to model it like this, if there are a lot of interactions.

The downside is you’ll get a bit of extra code, because you proxy your interaction handling to the PerformAction enum.

The benefits are

  1. See all the interactions in the enum at a glance
  2. Clarity of having one point where all the interactions are handled

For newcomers (or your future-you) it will be easier to get around the code.

If you enjoyed this post, follow me on Twitter @thenerd_be 

Swift Snippet : Map Bool values with Generics in Swift

My problem

It often occurs while writing code that you need to assign a value of a certain type, based on the value of Boolean. To do this there are multiple ways, but the 2 most known are

1. The let’s-write-a-lot-of-code approach

let isAWildBoolean = true

// Set the value of `offSet` to a value based on the Boolean
let offSet:Int

if isAWildBoolean {
    offSet = 10
} else {
    offSet = 20

I don’t like the first approach, because it creates a bloated codebase. A better way is to use the ternary operator (also known as the inline-if).

2. The one-line-star-developer (ternary operator) approach

You specify the Boolean you want to evaluate, add a question mark, followed by the value if the Boolean is true, followed by a colon, followed by the value if the Boolean is false.

Continue reading Swift Snippet : Map Bool values with Generics in Swift

TNInfoBubble – Prisma app info bubble component

I was using the Prisma app (like half of the world probably) and noticed the info bubble when you swipe with your fingers to adjust the strength of the effect.

This is my implementation (written in Swift) of this component, which comes with the Prisma look out of the box.

Continue reading TNInfoBubble – Prisma app info bubble component

Integrate Unity 5 in a native iOS app with Xcode 7

Integrate Unity 5 in a native iOS app

A few months back I published a blog post about how to integrate Unity3D within a native iOS application.  This tutorial was written for Xcode 6 & Unity 4 and in the comments there were a lot of requests for a new tutorial.

Tonight I found the time to make the video tutorial on how to integrate Unity 5 in a native iOS app with Xcode 7, so I hope you enjoy it!

Continue reading Integrate Unity 5 in a native iOS app with Xcode 7

3D touch peek and pop tutorial for your Swift application

3D Touch peek and pop tutorial

Apple added a touch-sensitive layer to the screen of the brand new iPhone 6s (plus).  With the coming of this new screen, they’ve added some new UI interactions like application shortcuts and peek and pop.

In this 3D touch peek and pop tutorial I will learn you how to implement this new way of interacting with your content by building a photo gallery.  When you press hard on the screen you’ll see a preview of the image and if you press really hard the preview will pop into a detail view.

At the end of this tutorial I’ll show you how to add preview actions. This way you can interact with the content without going to the detail view.  You can do this by swiping up while you are previewing the content.

Continue reading 3D touch peek and pop tutorial for your Swift application

Create a bootable USB drive for OSX El Capitan

Everytime when Apple releases new software, I can’t help it to format my computer. I just don’t seem to trust an update of a operating system. I like to create a bootable USB drive because it’s blazing fast to install the OS. For El Capitan, it took me +- 15 minutes with a USB3 stick.

Luckily it is fairly easy to create a bootable USB drive for OSX El Capitan!

Create a bootable USB drive

  • Have a USB stick ready (USB3 is really fast! :-))
  • Format it with the Disk Utility tool (Mac OSX extended format, give the drive the name Untitled)
  • Download OSX El Capitan from the Mac App Store, but quit the update application when it is downloaded.
  • Open Terminal
  • Use the following command
sudo /Applications/Install\ OS\ X\ El\ --volume /Volumes/Untitled --applicationpath /Applications/Install\ OS\ X\ El\ --nointeraction
  • Type in your password when asked
  • Wait a little while the files are being copied to your USB stick
  • Reboot your computer and hold the alt key
  • You’ll see a menu where you can choose to run the installer from the USB drive

Done 🙂