Shipping a Personal Project

I've been working on a personal project over the last few months that's far enough along now that I've started agonizing about how to release it. It has been too easy to get caught up in all the imagined "must do" steps, and in irrational fears of both failure and success. I was just about fed up with myself when I found Amy Hoy and Alex Hillman's new e-book, Just Fucking Ship.

There's lots of great advice in the book, it's definitely worth reading if you're in a similar struggle to finish and ship personal projects or full-blown products. The biggest lesson I'm taking from it is that I don't need to have a perfect "one shot" launch. Aiming to have everything in place for a magical moment is only making it less likely that I'll ship my work at all. Shipping, then iterating, is just fine.

I'm going to take that advice (perhaps too far), and flip my project's source repo to be public. It's a re-implementation of some of the UI from the iOS SpringBoard.app, written in Swift... so I'm calling it SwiftBoard. Check it out on GitHub, or here's a little screencast:

There's some missing features, and there's plenty of room for improvement in the code. I need to write up a blog post or two about what I've learned about Swift and iOS development, and maybe I'll pitch a conference talk. But I'm hopeful that treating the next steps as iterations is going to be way more productive than fretting over the "big launch". Fingers crossed.

White Chili with Chicken

As the cold and rainy season has returned to Vancouver, I have been craving the comfort of braises and stews. In the last few years, I have relied on a couple of recipes from Michael Symon's cookbook Live to CookPork Cheek and Black-Eyed Pea Chili and Braised Short Ribs With Pickled Green Tomatoes. They're both great, I'll make them again this winter, but this week I decided to try something new.

After browsing my favourite recipe sites (also an excellent cold weather activity), I picked out J. Kenji López-Alt's The Best White Chili With Chicken. With beans and gooey cheese, it looked like the kind of comfort food I was craving. And I suspected that its richness would be nicely balanced by the fresh chilis, lime juice, pickled jalapeño brine, and cilantro. I was also intrigued by his technique of roasting the chilis then peeling them in the recipe's chicken broth, so that no chili flavour is wasted.

Almost everything went according to plan — the chili purée tasted amazing, the poached chicken stayed juicy, and there wasn't too much of a mess in the kitchen. Unfortunately, I was foiled by the beans. I followed the recipe's suggestion of using dried beans, soaked overnight in salted water. But after two and a half hours of cooking they were still crunchy. I did some research and the likely culprit was that I bought old beans. Bummer. I fished the crunchy beans out of the chili then I ordered a pizza.

The next night, I used canned navy beans to finish the recipe. It turned out well, it was definitely tasty, though I suspect that I lost a little freshness by cooking it so long the night before in the futile effort to soften the old beans. I'll definitely cook this recipe again, but I think I'll go with canned beans until I find a reliable source for dried beans.

Trying Out MVVM

Last week, I wrote that I was jumping from strategy to strategy, hoping to find the inspiration that I needed to break through my coder’s block. The eureka moment hadn’t arrived by the start of this week, so I decided to cross my fingers and start refactoring to an architecture that seemed like it could plausibly work.

Earlier in the year, I learned about Model-View-ViewModel architecture (MVVM) on episode 3 of Justin Williams’ CocoaRadio podcast. I was in the late stages of building my first iOS app at that time, so it was too late for a major architectural re-think. But I did take some inspiration from MVVM by creating a few classes that presented model information in a view-convenient format.

I hadn’t thought about MVVM much since then, but in my research late last week, I read lots more about it. Here’s a few of my favourite links:

Many of the stated benefits of MVVM, like greater testability, serialization and code re-use, don’t really apply to my current project — but I was struggling with managing state — so I decided that implementing MVVM was worth a shot.

It’s still a little early to declare victory, but I’m happy with how the refactoring effort is going. I now have a view model layer that contains all of the dynamic state for my views and the actions to manipulate that state. Each view model defines a delegate protocol, so a view can register to be notified when the state changes. It feels like a very practical separation of concerns — it’s way easier to reason about state and state transitions when I’m not being distracted by how the views need to be updated to match the new state.

I've reached feature parity with what I had working on my old architecture, and a couple of new features fell out naturally after the refactoring work. That's a great sign. I’m hopeful that the rest will fall into place over the next week or so, then I’ll start polishing the UI and code for release. That’s both exciting and scary! Check in again next week for another update...