Andrei Zmievski

Fermenting barleywine

I haven’t yet compiled a list of my top 10 beers, but if I did, Lost Abbey Angel’s Share would definitely be on it. I first tasted it at the 2010 Barleywine Festival at Toronado, and it was love from the first sip. The intense, rich maltiness, full body, and surprisingly dry finish — enhanced by the bourbon, oak, and vanilla character developed by aging it in Heaven Hill Wheat Whiskey barrels — make it a beer to savored and appreciated, especially at the end of the day in the company of good friends.

Here in California, we are sometimes lucky enough to find Angel’s Share on draft, and it might even be better than the bottled version. I even love the name, which refers to the portion (share) of a wine or spirit’s volume that is lost to evaporation during aging in the barrels.

Needless to say, I really want to brew a beer approaching this greatness.
The reason is not even economics. A small (375 ml) bottle of Angel’s Share goes
for around $16-18 locally, but I consider that a fair price, given the
ingredients, effort, and time that goes into its making. I would simply like to
extend my skills, learn, and, in the process, hopefully brew a great beer.

Now, there are a few obstacles. First, Lost Abbey does not release the base beer that goes into the bourbon barrels, and there is virtually no information on its composition, aside from a note on the website that it is “brewed with copious amounts of dark caramel malt.” Sources say that it is an English-style barleywine, an Imperial brown ale, or an American strong ale, so developing a clone recipe is a challenge. Second, I don’t have a bourbon barrel to age the beer in, and even if I did, the logistics of brewing 55 gallons of beer, fermenting, aging it a year, and then bottling over 300 bombers (22-oz bottles) are, shall we say, formidable. The closest thing a homebrewer can do to simulate this process is use oak cubes and then add some bourbon at bottling time.

Unable to find a clone recipe of the base beer, I decided to use the recipe from The Mad Fermentationist, who said that it was “inspired by, but not a clone of, Angel’s Share.” I am still learning how to craft beers from scratch, but I couldn’t stay away from tweaking his recipe anyway. I removed the Crystal 55L malt, cut the wheat malt by two thirds, added a good amount of Munich malt, and a bit of Carafa II Special. Whether that was a mistake or not will be shown by the end result. All of the hops I used were leftovers that I’ve been keeping in the fridge, so the alpha acid percentage had to be adjusted down, somewhat. A beer like this doesn’t really need much hop character, so a variety of hops can be used for bittering.

I also decided to brew a smaller batch, since the recipe is very experimental, and I don’t really need 5 gallons of 11% barleywine. An added bonus was that I could brew it on my stovetop, and ferment it in a 3-gallon Better Bottle.

Since this would be the biggest (highest ABV) beer I’ve ever brewed, I wanted to do it properly to ensure that the fermentation doesn’t get stuck halfway. To help with this, I made a 1.5 L starter from a very fresh vial of WLP001 yeast. I also followed the advice in How to brew a really BIG beer article, which suggests doing a long 146/149°F to 154/156°F step mash to make a very fermentable wort. For some reason, I thought that raising the mash temperature by decoction was a good idea. It wasn’t. The decoction boiled, but after adding it back to the main mash, the temperature hardly increased, so I had to improvise. More in the notes.

Given my recipe hacking and the troubles I encountered, I doubt this will be close to Angel’s Share, but I still hope it will be an enjoyable barleywine.

I’ve seen a lot of problems solved with regular expressions, but last Friday, thanks to Chris and Sean, I found out that one can use them to determine whether a given integer is a prime number. The original articles showed the following regular expression:

/^1?$|^(11+?)\1+$/

You don’t apply this to the integer itself. Instead, you create a string of repeating 1s, where the numbers of 1s is defined by the number you’re testing, and apply the regex to that. If it fails to match, the number is a prime. The regex relies on backtracking and thus would not work with a DFA-based engine, such as PHP’s (now deprecated) ereg* functions. But, it works just fine with the preg_* ones, or so I thought (more on that in a bit).

So, how does it work? It may seem like a brain buster, but it’s actually pretty simple. Ignore the portion before the alternation operator (|), because it’s just a short-circuit case for checking whether the input string is empty or has a single 1. (If the string is empty, it means the number being tested is 0. If the string is a single 1, it means the number being tested is 1. Neither of these are prime.) The portion after the pipe is where the real magic happens.

The (11+?) sub-pattern matches strings 11, 111, etc. The \1+ matches whatever the sub-pattern matched, one or more times. So on the first try, the engine will match 11 and then attempt to match the same thing one or more times in the rest of the string. If it succeeds, the number is not a prime. Why? Because it just proved that the length of the string is divisible by 2 (the length of 11), therefore the original number is divisible by 2. If the overall match fails, the engine backtracks to the beginning and tries to match 111 two or more times and so on successively. If the first sub-pattern gets long enough (n/2 basically), and the overall match still fails, the number is a prime. Beautiful, isn’t it?

Coincidentally, Sean recently created a code evaluation plugin for the Phergie-based IRC bot that runs in the channel we hang out in. The plugin is a simple proxy to ideone.com, but is helpful for doing quick code tests. We had fun experimenting with this regex pattern implemented in a PHP function that returns the next largest prime number after a given one. The trouble started when Sean fed it 99999999, and the code spit out 100000001. This didn’t seem right, and Wolfram Alpha confirmed; the answer we got was not a prime. (It factors into 17 * 5882353.)

A few similar tests also gave us numbers that were not prime. But, where was the problem? The PHP code was too simple to have a bug, many answers were correct, and the regex algorithm itself was sound. It was time for brute force. I quickly wrote some code to feed increasing odd integers into into regex pattern and check its answers against the normal sieve algorithm to see where it starts failing. The first number to fail was 22201; the regex said it was prime, but it’s actually a perfect square (149²). Past that, the failure rate increased.

It then dawned on me that the culprit might be the backtracking itself, specifically how it was implemented in PCRE, the library at the heart of PHP’s regular expressions. As I mention in my Regex Clinic talk, unbounded backtracking can dramatically slow down the matching and should be well-understood before attempting to write complex patterns. To manage the danger of runaway patterns, PCRE implemented the pcre.backtrack_limit setting a few years ago. In our case, backtracking is used to break up the string of 1s into successively larger chunks, and, with very long strings, the engine may run into this backtracking limit, which is set to 100000 by default. My guess was that with the 22201-character-long string, the default was not enough. Once the limit is reached, the match fails, and the number is declared prime.

I bumped the limit up to 200000, and voilà, 22201 was no longer declared prime. To fix the 100000001 match, the limit had to be raised dramatically, to around 250000000! And, the program took 14 seconds to deliver the verdict on my new i5 MacBook Pro. Needless to say, don’t use this prime determination algorithm for any sort of real-life stuff. Instead, just appreciate it for its elegance. I certainly did, and was glad that my bit of investigative work showed that abstract, pure, good ideas can still fail in the messy world of software and hardware.

About a year ago, I finally wisened up to the obvious: 1) losing data sucks, and 2) doing daily (or frequent) backups manually are a pain in the ass, especially for portables. 2) is why most people forgo backups in the first place, resulting in 1). I needed something that I could set up once and pretty much forget about. Thankfully, there was just the thing: Time Capsule  —  a single device that encapsulates both Airport Extreme base station and a huge hard drive, and can be used for automatic, transparent, wireless backups from any of your Mac devices via the Time Machine.

I purchased the 1 TB version, configured it, and have been using it ever since. It has already saved my butt a couple of times, when I accidentally deleted (rm -rf) a directory and had that familiar sinking feeling, but then remembered that the Time Machine was there ready to lend a hand.

However, I noticed recently that the hourly backups were taking longer and growing in size, sometimes up to 1GB or more. It didn’t seem like there was that much data changing on an hourly basis, so I set out to investigate. A quick look around revealed that the Time Machine itself will not reveal the backup details, but someone wrote a script called timedog that displays the files that the Time Machine backed up during its most recent run (or any of your choosing). The output of the script is something like this (abbreviated):

# cd /Volumes/Backup\ of\ foo/Backups.backupdb/foo
# timedog -d 5 -l
==> Comparing TM backup 2010-06-29-160846 to 2010-06-29-101853
     399B->     399B    [1] /Mac HD/Library/Application Support/CrashReporter/
[..skip..]
   52.6KB->   53.0KB        /Mac HD/Users/andrei/.dbshell
     863B->     866B        /Mac HD/Users/andrei/.lesshst
   11.0KB->   15.1KB        /Mac HD/Users/andrei/.viminfo
   10.4KB->   30.7KB        /Mac HD/Users/andrei/.zsh_hist
    6.7MB->    6.7MB        /Mac HD/Users/andrei/.dropbox/dropbox.db
    3.9MB->    3.9MB        /Mac HD/Users/andrei/.dropbox/migrate.db
   25.2MB->   50.3MB   [10] /Mac HD/Users/andrei/.dropbox/cache/
   21.0KB->   21.0KB    [1] /Mac HD/Users/andrei/Desktop/
  120.0MB->  120.4MB    [1] /Mac HD/Users/andrei/Documents/Linkinus 2 Logs/
  142.8MB->  146.2MB  [156] /Mac HD/Users/andrei/Library/Application Support/
[..skip..]
  608.0MB->  608.0MB    [5] /Mac HD/private/var/data/mongodb/
[..skip..]
==> Total Backup: 967 changed files/directories, 1.88GB

Looking at this, a couple of offenders are immediately obvious. Linkinus (an IRC client) keeps all the conversation logs in one single file, and since I’m frequently on IRC, that file grows and gets backed up every hour. The data files for MongoDB that I use for development are also fairly large and change often. Finally, there is something in Library/Application Support, but it wasn’t shown because of the depth limit I set. After increasing the depth to 7, I discovered that it was the Google Chrome cache and history.

Conversation logs and Chrome stuff are not important enough for me to back up hourly, and MongoDB data I can copy periodically to an off-site server. By excluding these 3 items from the backup process via Time Machine Preferences I was able to reduce the size of the hourlies to 50 MB or less.

This brings up an important point though: while Time Machine is great for doing automated backups over your local network, you should have a separate copy of the data off-site, for redundancy. How and when to do the off-site backups varies according to everyone’s needs, but I would suggest something like CrashPlan, which does unlimited online backups for about $5/month. Once again, it’s automatic and hands-off, which is how you want it.

Tools I found useful while investigating this Time Machine issue:

• timedog – the script used above
• Time Machine Buddy – a Dashboard widget that organises and displays the backup logs
• Time Machine Scheduler – in case you want to change how often the backups are done

As mentioned in the Brewing Résumé post, I once attempted a clone of Dieu du Ciel’s Aphrodisiaque stout, brewed with cocoa and vanilla. While the result was decent, if not very close to the original, it was popular enough that I am now left with only a single bottle of it. Various people have strongly hinted that they would like some more of this beer, so I was obliged to re-brew it.

Chocolate stout split into secondaries

After tasting Firestone Walker’s Velvet Merkin and similar beers, I decided to base the recipe on an oatmeal stout rather than a foreign extra stout as before. Oats are high in beta-glucans, provide a nice body and silkiness, and help with head retention. The recipe was based on the oatmeal stout from Brewing Classic Styles, with a couple of modifications. To avoid doing a cereal mash, I used regular flaked oats instead of old-fashioned, rolled ones. I also baked them in the oven until they turned golden and had a nice toasty smell and flavor. The Victory malt was reduced a bit to avoid saturating the beer with its biscuity taste, and I upped the roasted barley a tad and added a bit of Carafa II Special malt — a dehusked version of normal Carafa — to intensify the aroma and color without adding astringency. A portion of East Kent Goldings hops used for bittering was replaced with Willamette and the EKG was moved 30 min to give a bit of hop flavor.

There are various ways to add chocolate flavor to beer, including raw cocoa nibs, cocoa powder, chocolate syrup, or even just chocolate malt. Cocoa nibs are supposed to give a more integrated taste, but they require the beer to be on them for a couple of months, so I just went with what I used last time with good results — cocoa powder added at the last minute of the boil. Some advocate adding cocoa powder to secondary, and I might try that approach in the future. The vanilla flavor will come from organic vanilla beans. (I picked up 2 Indonesian beans at Whole Foods for the low, low price of $11 #sarcasm.)

San Francisco water is really soft, so I added some baking soda to keep the mash pH from falling too much due to the presence of dark malts.

Vanilla bean in vodka and oak cubes in bourbon

While working on the recipe, I happened upon the Breakfast Stout Riffs post on The Mad Fermentationist blog, which I’ve been reading a lot lately. Mike, the author, brewed an imperial stout and split the batch into different secondary fermenters to experiment with various additional ingredients. I was inspired by his approach, and decided to split my 5-gallon batch as well. The first two variations were easy: 2 gallons would go on top of medium-plus toast American oak cubes soaked in bourbon and some vanilla bean, and 1 gallon would have regular medium toast Hungarian oak cubes and some vanilla as well. After some hard thinking about the third variation, I simply stole the recipe from Mike — a half each of dried ancho and guajillo chile peppers, vanilla bean, and a bit of cinnamon. The final gallon was a complete gamble: sour cherries and dregs from a couple of bottles of Orval (basically adding Brettanomyces and some funky bacteria). I’ve never used fruit or Brett in beer before, so it will be interesting to see how this portion turns out (a few months from now, since Brett works fairly slowly).

I’m going to post a brewing/fermentation log, similar to how The Mad Fermentationist does it, and see if it’s helpful or not. The log will be updated as the beer progresses through fermentation, finishing, and tasting. (Feedback is appreciated.)

A month ago I decided to stop using Firefox as my main browser, because I was becoming frustrated with its sluggishness and general stability issues. I wanted to give a new, modern browser a chance and Google Chrome seemed like the most fitting choice. I’ve been using it diligently and exclusively since then and wanted to share some good and not so good things that I found out after a month of daily usage. The caveat is that I’ve only used it on the Mac platform, so my findings may differ for Windows/Linux users.

1. It’s fast and stable. Pages load quite a bit faster, if only perceptually. And while the memory usage is not that much lower than FF’s – after all, those DOM trees and images have to go somewhere – I have never had to force-quit (or even just quit) Chrome the way I had to with FF after a couple of days. This is a big win in my book.
2. The built-in developer tools are nice, but are not quite as good as Firebug, it seems. I will have to try them out on a project before I can say this with certainty.
3. There is a lack of integration with 3rd-party tools and websites I used with FF, mainly 1Password and Delicious. Yes, there are Chrome alpha/beta extensions for both, but I miss the full functionality the FF versions offered. Hope the vendors hurry up and bring them up to feature parity.
4. I miss the quick search engine access that FF has in the upper right corner. That’s how I searched Amazon, Wordreference.com, and several other sites. I can’t find an equivalent in Chrome.
5. There is no way to configure proxy settings through Chrome itself. You have to use a command-line parameter (who does that on a Mac though?), an extension, or do it through OS X’s System Preferences.
6. It’s from Google. So it’s just what I’ve come to expect from their products – great engine and features combined with some usability problems and a lack of polish.

Overall, I’m pleased with Chrome and will continue using it as my main browser unti something better comes along.

Update: As the comments below indicate, it is possible to configure and use various search engines from the “omnibox”, aka the search bar. Right click and select Edit Search Engines.

My first brew

I ventured into homebrewing in October 2008, and judging by my brewing logs, I’ve made 16 batches since then, which is somewhat less often than once a month. I’m glad I kept the logs from the very start (using Beer Alchemy), because it allowed me to go back and look at the recipes as well as the notes I kept for each batch.

My first kit was an English-style Best Bitter ale from MoreBeer, and boy was I nervous when reading all the steps to be followed during cleaning, sanitizing, steeping, boiling, cooling, fermenting, and bottling. Being a perfectionist, I didn’t want to screw any of it up, but my good friend Sean Coates — a much more experienced brewer — told me, “Relax, beer wants to be made.” What he meant is that even if I did screw something up, the end result would most likely still be beer. This brings to mind another saying in the homebrewing world that was popularized by Charlie Papazian, “Relax, don’t worry, have a homebrew,” or RDWHAHB.

Well, my first beer turned out to be drinkable and actually pretty good. Encouraged by that success and the approach of the holidays, I bought another kit, a Christmas Ale. Brewed together with Gene X, it also came out well, and so I was off. Over the next few months, I scoured homebrewing boards for advice and recipes, and I brewed everything from Dunkelweizen (Tim’s favorite) to Rye IPA (Jordan’s favorite) to a smoked porter (no one’s favorite, but still good). I also migrated from using extract with steeping grains to doing partial mashes.

In March of 2009, I was in Montréal for a PHP conference and was introduced to the local brewing scene by Sean. I especially liked the Dieu du Ciel brewery. The second time we visited it, I tried their Aphrodisiaque stout, and, rumor has it, exclaimed, “This is delicious! I dub it The Panty Peeler, and I’ll have to brew a clone of it.” A few weeks later, I did just that, and while I didn’t quite clone it, the result was immensely popular with the female contingent.

Fermenting beer

Jamil’s Amber-Red Ale was my last partial mash beer, but also my most winning one, since it got 3rd place in the American Amber category at the 2009 Puget Sound Pro-Am competition. After that, I switched to all-grain brewing and haven’t looked back.

My friends Joe, Laura, and a few other local geeks from Michigan, are huge fans of Bell’s Oberon, an American wheat ale. Seeing as Oberon is not available west of the Rockies, I decided to try to clone it as well. The challenge was that Bell’s uses a unique yeast for fermentation, but since they also bottle condition with it, I was able to culture a starter from a single bottle of the beer. With that yeast and a supposedly authentic recipe for Oberon, I made the batch and the result was quite good, if not quite Oberon-like.

My next challenge was Berliner Weiße, an authentic German beer with a sour, refreshing, low-alcohol profile. I wanted to make it with the traditional sour mash technique (instead of using Lactobacillus culture). This involves keeping the mash at 100°F for a couple of days while it sours due to deliberate contamination by bacteria living on the surface of barley. Towards the end, the mash smelled like old gym socks filled with stinky cheese, but it tasted great. After a quick boil and fermentation, I had some really delicious sour beer that would be excellent for summer.

I developed a taste for saisons, so I wanted to try my hand at making one. My version involved a recipe from Brewing Classic Styles, a pinch of spices, and the newly acquired FermWrap heater. Well, my creation was not as dry and spicy as saisons should be, but the aroma and taste were excellent. I entered it in the World Cup of Beer competition as a Belgian Pale Ale, and it scored 34.6 out of 50, lacking just 0.4 points for a 3rd place finish. Better luck next time.

Lacking a refrigeration unit, I hadn’t made lagers yet, but I really enjoy Baltic Porters, so I brewed a batch from BCS again, and asked Brien to ferment it in his temp-controlled freezer. Recently — after a month in the primary, and 10 weeks of lagering — the porter was bottled. Preliminary tasting shows a bit of fusel alcohols, but hopefully that’ll mellow out with some aging.

And finally, my last batch was Hopcode Cache Rye IPA, a recipe from Sean. The name is a play on words. I dry hopped it with Amarillo (one of my favorite hops), and it turned out great, so I entered it into the Alameda County Fair competition. The judging is expected to happen on June 12.

What comes next? Well, that’s a topic for another post. But here’s my brewing résumé so far, in chronological order (recipes in Beer Alchemy format).

• MB Best Bitter.html (recipe)
• MB Christmas Ale.html (recipe)
• Vanilla Cream Ale.html (recipe)
• Deathbrewer’s Dunkelweizen.html (recipe)
• Jamil’s Scottish 60 Shilling (recipe)
• Bee Cave Brewery Rye IPA.html (recipe)
• Loon Lake Smoked Porter.html (recipe)
• Aphrodisiaque clone.html (recipe)
• Jamil’s Amber-Red Ale.html (recipe)
• Cloneberon.html (recipe)
• Belgian Pale Ale (Tweaked from BCS and HBT).html (recipe)
• Berliner Weiße.html (recipe)
• Flossmoor Station Pullman Brown.html (recipe)
• Saison.html (recipe)
• Baltic Porter.html (recipe)
• Hopcode Cache.html (recipe)

A few years ago, I was considering what proposal to submit to the Vancouver PHP Conference. The usual slate of “how to do this and that in PHP” was becoming a bit tired, so I decided to submit a talk about an essential skill that PHP (and other language) developers might need: using the Vim editor.

By that time I knew that I was firmly in the Vim camp (as opposed to Emacs or IDEs). Of course, writing a 45 minute talk about Vim is like trying to explain Mulholland Drive during an elevator ride, but I rose to the challenge and put together the first version of the slide deck. When I later received the feedback about the talk, I realized that it was the most highly rated one of the conference, above even Rasmus’s perennial PHP keynote. Clearly, I was onto something.

Since then I’ve expanded and adjusted the talk to fit the 45-60 minute slot, but I still usually run out of time due to the wealth of material. So I published the slides on Slideshare and created a Github repo for my time-tested Vim settings and plugins, so feel free to fork it and submit pull requests. And in general, go forth and Vim.

• Slideshare
• Github repo

“Beer is living proof that God loves
us and wants us to be happy.”
— Benjamin Franklin

Hi, my name is Andrei and I am a beer enthusiast.

To some of you this may not be news, but beer is something that has become a significant part of my life during the last couple of years. That is not to say that I didn’t drink beer before – I did, but somewhat indiscriminately and without paying much attention to the actual product. And while I do enjoy other fine adult beverages, such as wine, bourbon, whisky, gin, and well-crafted cocktails, beer is what I feel passionate about and I finally want to start writing a bit about it, on this blog, for now.

Beer is the world’s oldest and most widely consumed alcoholic beverage and the third most popular drink overall after water and tea. Many anthropologists and historians believe that beer is what made early hunter-gatherers finally settle down and become sedentary farmers, because well, they needed barley to brew it, so one can say that beer was one of the driving forces behind the rise of civilization. Moreover, most fresh water wasn’t exactly safe to drink back then and beer provided both hydration and sustenance.

Beer has more styles and varieties than any other alcoholic beverage, and though almost all beer is made using the same 4 ingredients (water, barley, hops, and yeast), the sheer number of additional ingredients that can be used to brew beer and the creativity that goes into the process can put almost everything else to shame. Despite this, there is still a widely spread perception that beer is that pale, cold, “subtly flavored” beverage that is marketed by the giant companies collectively known in the brewing circles as BMC. I’ll let you guess what that stands for. Thankfully, there is a thriving craft brewing industry both in the United States and abroad now, and beer is finally starting to be treated with respect.

About a year and half ago I got into homebrewing, thanks to the efforts of Brien Wankel and especially Sean Coates, who has been instrumental in answering a bajillion questions I had when getting started. I never thought that I could actually make beer myself, but after reading the online version of How to Brew by John Palmer, I was immediately fascinated by how easy and yet how sophisiticated the brewing process can be. The more advanced part of it has to deal with biochemistry, thermodynamics, fluid dynamics, and even metallurgy and this appealed to the geek in me. I bought the starter kit from MoreBeer and made my first batch, which was a Best Bitter English-style ale. When I opened a bottle 4 weeks later and found that not only was it not bad, but actually pretty drinkable, I knew that I was hooked. Since then I’ve brewed about once a month, exploring various techniques and styles. I’ve also sent some of my beers to competitions and even won a 3rd place in the American Amber category at Puget Sound Pro-Am last year.

Crafting a beverage that can be enjoyed by yourself and others is a great feeling, and I hope to share more about it in the coming posts. Additionally, I plan to review various beers and write about the beer industry, events, places to find good beer and hopefully much more.

Cheers!

Back in 2004, I submitted a proposal to the only PHP conference ever to have taken place aboard a cruise ship. Yes, the infamous PHP Cruise (“Do we all know each other?”). The talk was about regular expressions and their usage in PHP. I wrote the original version in PowerPoint, but when I boarded the ship and saw Keynote 1.0 on someone’s Powerbook, I was hooked and had to port all the slides to Keynote right then and there.

Well, the talk – and the cruise – went well, and since then Andrei’s Regex Clinic has grown and shrunk in size depending on which conference I was giving it at and how much time was allotted. I considered retiring the talk several times, because surely people should know how to use regular expressions by now, but whenever I give it there is a roomful of people wanting to know what (?>=foo) does. And as much as I try, I always run out of time trying to cover everything from the basics to more advanced usage.

I feel that the slides are pretty polished by now and it’s better if people can read them at a comfortable pace, so the whole tutorial-sized presentation is now available on Slideshare. I omitted the section that covers PHP’s regular expression API, because it already has great online documentation. Otherwise, go forth and read about look-ahead assertions and recursive matching.

Please Start From The Beginning is a video series that explores the career paths and experiences of web industry professionals. I was honored to be interviewed for the series along with such interesting people as Eric Meyer, Joe Stump, and Elliot Jay Stocks. If you to hear about how the heck I started in Web development, this is a video for you.