• Learnings in Bread

    The past few months I’ve been baking various breads and enjoying the results. The taste has always been good (side note: when doesn’t bread taste good), but I hadn’t actually improved my skills in months.

    I’m mostly keen to improve the neatness of my loafs. To do this, there are two things I think I need to improve.

    • The height and ‘spring’ of my bread when cooked
    • The scoring of the bread.

    My reading materials in the past have been The Perfect Loaf, Dan Larn’s Site, Flour Water Salt Yeast by Ken Forkish and various other online tutorials.

    This week, I picked up three new things that got me really excited to bake more; three things that have already helped me bake what I think are the best breads I’ve ever made.

    The first is an ambient thermometer to give me a better understanding of the climate of my kitchen. I often find recipes recommending things like “if your kitchen is cooler (18-20°c) then use slightly warmer water” and I always think “how can 18-20 possibly be cool?!”. I always ended up sticking to the warmer waters, knowing that my flat is an ice box. However, I always just winged it with the warmer water and called it day.

    Now, by being able to monitor the temperature right next to my dough at all times, I’m feeling much more confident in adjusting recipes to suit my needs. I actually created a microclimate in my oven to simulate warmer temperatures by leaving a small bowl of water at the bottom of it and closing the door with my dough and starter inside. This worked perfectly and allowed me to bulk rise my dough in 3 hours at 26°C - something I imagine would have taken closer to 5 or 6 hours with the 15° ambient temperature I now know my kitchen rests at during this time of the year.

    The second thing I bought is a batard banneton. Before this, I only had boule bannetons and consequently baked round loaves. I think my favourite bread aesthetically is a well scored batard, I’ve always wanted to try and create a strong ‘ear’ using some good scoring. This new banneton will hopefully give me a shot at this. And, it’s not all about the looks - I think a banneton is the better shape for most situations. With a banneton you get more equally sized slices for the full length of the dough - as opposed to a boule where you have smaller pieces at the end and overly large pieces in the middle.

    The final thing I purchased - and what I consider to be one of the best purchases I’ve ever made - is the Tartine Bread book by Chad Robertson. I had considered picking up a copy of this for the last year or so but didn’t bite the bullet until I noticed that it’s available as a digital copy for only £3.79. As soon as I realised this I made the purchase and read it virtual cover to cover in one evening.

    In this book, Chad explains the perfect amount that you want to know about the classic country loaf of bread. He explains why how each period of rest works and how the product should look, smell and feel at each stage in a way that is scientific, yet approachable.

    The highlight for me was reading about how to correctly shape dough prior to proofing. Since I started baking bread almost a year ago I have had issues with the dough sticking to the proofing baskets. This was happening no matter how much flour I was using and how much tension I built in the dough. Through reading the descriptions in Tartine Bread, this is no longer an issue for me. I realised that I’ve been shaping my bread and then placing is seam side down into the baskets. This side has next to no tension no matter how much you create with nice folding. Now, I definitely could - and probably should - have noticed this through the other books and sites I’ve read, but the entire folding process makes so much more sense to me after reading Tartine. I have far fewer issues dealing with sticky dough, which often lead to me over flour-ing the worktop; I now let the dough rest and know that it’ll be easier to work with because of this rest; and I know where to put the flour and when, whilst keeping it to a minimum. Before, I would just ‘use as little as possible’ as most other recipes say, until I inevitably added more flour at some point once some horrible sticking started).

    It was great the learn how they bake a country loaf at Tartine, but another strength of the book is that it promotes baking ‘off piste’. Far too often when reading about sourdough and good breads, the author will say something to the effect of “adapt this as you like”. But they never explain what you could possibly adapt. The prescribe measurements to the 10th of a gram, warn you of a 15 minute window that you have to make and demand a preciseness of temperatures at all stages that expels all thoughts you had for ‘adapting the recipe to your needs’. Tartine on the other hand embraces adaptability and encourages experimentation to suit your needs. There is a whole section of the book dedicated to friends of the author who have each made their own adaptions to the original recipe in order to suit their schedule and their needs. In the past I had never baked a sourdough loaf during a work week as I thought my starter would not have time to mature and that I could never get a good enough rise in the short hours I have before bed. However, the day after I read Tartine, I mixed two loaves impromptu after work and baked them the next morning before heading to the office. They were the best loaves I had ever made.

    Prework bake

    Over the next few weeks I plan to bake a bunch more. I’m going to try a keep a short log of ambient temperatures and times that I used for each bake in order to find a method that works best for me.

  • My Favourite Albums of 2018

    Spotify recently released their 2018-Wrapped playlists for users. It’s a brilliant feature that I wish more services would implement. Twice in the past I’ve used Apple Music for a few months at a time. Both times I regretted it, and was then annoyed when my year-end stats missed my binge on a new album. It’s an ego-filling service whose greatest purpose is for enabling you to tell others about how good your music taste is. But, who doesn’t love to be told about a band that you never listen to until you discover them yourself.

    I thought I’d write a little about my favourite releases of this year.

    New Light (Single), John Mayer

    My first choice is only one song, but it’s a really great one. This song reminds of Los Angeles evenings, I think it’s got a very La La Land vibe but can’t quite place where I get that from.

    Leon Bridges, Good Thing

    This album is a significant departure from the first Leon Bridges’ early Rhythm and Blues style. I particularly like Bad Bad News and Mrs.

    Hill Climber, Vulfpeck

    Squeezing in at the very end of the year, I haven’t turned this off since it came out. It’s maybe too early days but I think it’s my favourite Vulfpeck album yet. It’s an album I’d highly recommend listening to from start to finish.

    Guide My Back Home (Live), City and Color

    I don’t usually like live albums much but this one is different. Dallas Green has developed so much as a musician that it’s amazing to hear songs that I grew up listening to (that now seem dated, for want of a better word) performed in a more mature and emotive set.

    Living Room, Lawrence

    Lawrence are a pop-funk band whose songs feel like a disney soundtrack. They are fronted by a brother-sister duo with amazing voices. I’m hoping they come across to the UK sometime as I’d love to see them live.

    Tom Misch, Geography

    Tom Misch has become my current guitar idol. Every song on this album is brilliant.

  • iPad Pro




  • Podcast List - November 2018

    A November edition of some podcasts that I’ve been listening to recently.


    Dirty John

    An interesting short series that best falls into the ‘true crime’ category. I don’t want to say too much about it but would recommend for people who like anything like “They Walk Among Us” or “Up and Vanished”.

    The Sourdough Podcast

    I first heard about this podcast when I Maurizio of The Perfect Loaf was on it. I wouldn’t say you learn a tonne from it but it’s pretty interesting for those who are into baking.

    Tools They Use

    A podcast that interviews people about their daily tech and daily workflows. I’m a sucker for any tech podcasts so this has become another to add to the pile.

    West Cork

    One of the best true crime podcast series I’ve heard. Sadly only available on Audible, however if you haven’t signed up before, you can get a free trial and cancel it after you’ve heard the podcast.

    Planet Money’s The Indicator

    A spin off show from my previously listed ‘Planet Money’, this is a podcast served in ~10 minute episodes that have short investigations of different parts of the economy - far more interesting than it sounds.

    Up and Vanished

    I had Up and Vanished in my first podcast list, however there is a second season available now that focuses on the disappearance of a woman from a hippie cult in Colorado. I don’t think it’s nearly as good as the first season, there’s far more fluff and filler, but it’s interesting nonetheless.

  • New Favicon

    Last week I sold my laptop and received delivery of the new iPad Pro. I’ve a bunch of posts I want to make about the iPad, but here’s a short one for now.

    I’ve been meaning to add a favicon for this blog for a while, but just never got round to it. So, this morning, whilst playing around in Procreate, I decided to draw one up. I wanted some depiction of a pizza, however all the references that I could find online were certainly not Neapolitan (the undisputed best form of pizza), so, I made my own. Here is the process as exported from Procreate - a really cool feature that lets you export a time lapse of your drawing.


  • Presenting a series of UIAlertControllers with RxSwift

    I was recently writing a helper application for work that would store a bunch of URL paths that we support as Deeplinks. The user can pick from one of these paths and will be prompted to input a value for any parameters (any part of the path that matched a specific regex). However, the app got pretty complex when having to deal with multiple capture groups in that regular expression.

    The problem was this - given an array of strings (capture groups from my regular expression), show an alert one after the other requesting a value that the user wishes to input for that ‘key’.

    Traditionally, I would have probably made some UIAlertController-controller that might look something like this.

    protocol AlertPresenting: class {
        func present(alert: UIViewController)
    protocol MultipleAlertControllerOutput: class {
        func didFinishDisplayingAlerts(withChoices choices: [(String, AlertViewModel)])
    class MultipleAlertController {
        private var iterations = 0
        private var viewModels = [AlertViewModel]()
        private var results = [(String, AlertViewModel)]()
        private weak var alertPresenter: AlertPresenting?
        weak var output: MultipleAlertControllerOutput?
        func display(alerts alertViewModels: [AlertViewModel]) {
            self.iterations = 0
            self.results = []
            self.viewModels = alertViewModels
        private func showNextAlert() {
            guard viewModels.indices.contains(self.iterations) else {
                self.output?.didFinishDisplayingAlerts(withChoices: self.results)
            self.display(alert: viewModels[self.iterations])
        private func display(alert: AlertViewModel) {
            // some stuff here showing alert, invoking show next alert after completion
            iterations += 1

    Now this isn’t necessarily bad, but having to keep track of or reset state can always lead to bugs - particularly in asynchronous situations. Instead I had an idea for doing this using RxSwift.

    import RxSwift
    func populateParameters(for alertViewModels: [AlertViewModel], presentingAlertFrom viewController: ViewControllerPresenting?) -> Observable<[RegexReplacement]> {
        return Observable
            .concatMap { alertViewModel -> Observable<(String, AlertViewModel)> in
                guard let vc = viewController else { return Observable.empty() }
                let textFieldResponse: Observable<String> = vc.show(textFieldAlertViewModel: alertViewModel)
                return textFieldResponse
                    .map { textInputValue in (textInputValue, alertViewModel) }
    // Helper method for Rx UIAlertControllers
    protocol ViewControllerPresenting: class {
        func present(viewController: UIViewController)
    extension ViewControllerPresenting {
        func show(textFieldAlertViewModel: AlertViewModel) -> Observable<String> {
            return Observable.create { [weak self] observer in
                let alert = UIAlertController(title: textFieldAlertViewModel.title,
                                              message: textFieldAlertViewModel.message,
                                              preferredStyle: .alert)
                alert.addAction(.init(title: "Cancel",
                                      style: .cancel,
                                      handler: { _ in
                                        observer.onCompleted() }))
                alert.addAction(.init(title: "Submit",
                                      style: .default,
                                      handler: { _ in
                                        observer.onNext(alert.textFields?.first?.text ?? "")
                                        observer.onCompleted() }))
                alert.addTextField(configurationHandler: { _ in })
                self?.present(viewController: alert)
                return Disposables.create {
                    alert.dismiss(animated: true, completion: nil)

    Now, this looks like a lot of code, but the lower part is simply a wrapping on UIAlertController with Rx. Something that can be re-used for any UIAlertController with a text field.

    Let’s break down the main bits.


    This little snippet takes an array an gives you an observable that emits each element of the array. In this example that will be an event for event match in the regular expression.

    .concatMap { alertViewModel -> Observable<(String, AlertViewModel)> in
                guard let vc = viewController else { return Observable.empty() }
                let textFieldResponse: Observable<String> = vc.show(textFieldAlertViewModel: alertViewModel)
                return textFieldResponse
                    .map { textInputValue in (textInputValue, alertViewModel) }

    Here we take the stream of matches for the regular expression and we compactMap an observable of the String that the user typed into a UIAlertController alongside the original AlertViewModel instance. The RxSwift method doing the heavy lifting is the compactMap. It waits for a completed event to be sent by the observable text field responses before invoking the next alert.

    The result of the compactMap is an Observable tuple of (String, AlertViewModel), which can be used by the consumer to populate the matches of the regex with the String values.

    We pipe this tuple Observable into a toArray which waits for a completed event - which happens automatically for us once every item in the array has had an alert shown.

    I’ve cut a bunch of corners in these examples in order to simplify flow and make these two approaches more comparable. You can see the full example in my deeplinking helper app here.