Want a crystal clear code, ahem, beer, that’s bug-free and appreciated by your friends?
Here are five software engineering principles you can re-use when thinking about making your own Homebrew.
#1. Configure your environment
Having the right tools only gets you so far, calibrating and configuring them to your needs makes you a superstar.
To get the most out of your toolkit, you need to know its capabilities, quirks, and limitations. Software quirks tend to come in the form of incompatibilities between dependencies, and these tend to be more noticeable as requirements are more niche.
Making beer is somewhat a similar story as your extract batches quickly turn to all-grain brew days. Adding complexity reveals the character in brewing equipment, so its important to test out, calibrate and adjust your brew plan accordingly. That “banana, coriander and lye-chee milkshake IPA” that your friends have been egging you on to make doesn’t have to be daunting.
#2. Be consistent — too many variables can be a bad thing.
Whether its the functionality in software or the IBUs in an ale, being able to concentrate solely on the crucial details only happens with consistency.
Much like when software syntax is sporadic in spacing, naming conventions and organisation, having a brew day that is forever changing doesn’t promote progress. From both perspectives, even changes to the environment itself can have adverse effects.
Be consistent in your approach before adding details.
#3. Sanitise your inputs
Personally, this is my number one principle when creating any software, and should be yours when brewing beer.
Sanitisation is pretty much self-explanatory in food terms. Anything that will come into contact with your chilled wort needs to be clean, and not just covered with a layer of sanitiser either. Any visible soil/dirt should be removed entirely from all equipment and from you.
Wash your hands regularly, and don’t dip your beard into the code.
#4. Measure and Log Everything
Brewing beer is a lifetime performance improvement and debugging exercise. Just as we try to squeeze as much performance out of a software application, we try to achieve the best efficiency from our recipes and equipment.
We can only do this if we create key performance indicators, measure regularly and log down everything that we do. For example, instead of measuring OG, measure OG, wort temperature, cooling time, room temperature, weather, your mood. Anything that you would look back on in the future to paint a clearer picture of the situation.
We can’t repeat the past, and in some circumstances, we probably don’t want to, but if we can’t learn from it, then what is its purpose.
#5 Pitching Yeast is a Promise
A promise is a declaration that a particular thing will happen. In software terms, a Promise is an asynchronous contract that when something has finished processing, a result will be returned, allowing the rest of the code to deal with the result later.
When you pitch yeast into your fermentation vessel, you’re essentially creating a promise. You can then go about daily life or sit staring at your brewing beer for the next few days; it’s your choice.
The result of the promise is guaranteed; the outcome of beer, however, is not. Your yeast may flocculate too early, or something else may produce an off-taste in your resultant brew. Whatever happens, it’s good to be prepared and know to handle the situation beforehand.
If god forbid your batch is infected and therefore dumped down the sink, then the only thing you can do is rinse and repeat the process.
In Summary
There are many similarities between creating software and perfecting beer. It’s an iterative process, only improved by consistency and application. For anyone who read this post expecting a tutorial on Homebrew, I apologise.
To all my fellow coders, engineers, homebrewers and beer lovers. Cheers!