I hit the 15th and Denver QuikTrip for a late night snack. The new store is open. It’s huge and unbelievably nice. I was in awe, and so were the other customers at the time. I took a couple of photos.

They have a selection of about 8 or so iced teas and multiple choices for lemonades:

I believe they had to invent a dozen new Freezoni flavors for the frozen drink area:

The iced tea center is straight ahead in this view, the frozen drink theme park is to the left; beer is all the way back and to the right, the checkout counter is to the left (you can see the back of the line), and to the right is — I kid you not — the soft serve and coffee shop. You make your selection on a touchscreen kiosk. I don’t know if it’s open 24 hours, but it was definitely staffed at 12:30 AM tonight.

A view from the other side of the store. You can sorta make out the gigantic flat screens that are inset to the wall around the coffee shop counter for some reason.

This place is seriously epic.

Note: if my blog is running too slow, or you want to see some more photos from the build, check my flickr keezer set.

Inspired by Jester369’s post (among others) on HomeBrewTalk.com detailing their conversion of a chest freezer into a homebrew-appropriate kegerator (or “keezer”) I decided to follow suit. I bought an old, smallish chest freezer off of Craigslist, and eventually Evan (the boyfriend) and I started building it.

Here’s the old freezer, downstairs in the storage unit; photos cannot possibly capture the ugliness of the faux wood plastic lid:

Because the outside was old, unattractive, and the hinge mechanism was old and rusty, we decided to totally remove the top and replace it with a new one that we’d build. Gross, rusty hinges:

The replacement top would need to raise the top of the freezer to give enough clearance for proper operation of the kegs, which are tapped from the top. The common design idiom for this is to build a “collar” to elevate the lid.

Because we trashed the ugly lid and hinges, we opted to mount a mostly-permanent tall box (“coffin”) on the back to provide a mounting point for the faucets, then to put a countertop on the front, which can be lifted off to provide access. Below is an early concept sketch for the top, which gets the point across but doesn’t look a whole lot like the final product:

Sketch of the interface for the outside edges of the countertop to the collar:

This is almost exactly what we wound up doing, except that we decided to hold off on the weatherstripping until we determined it was needed to improve the seal. In fact, it turned out that the panel fit snugly enough onto the collar that the weatherstripping was unnecessary (so we skipped it); however, we did put some strips of felt where the countertop meets the coffin to provide some “give”.

Also, the part labeled “cutting board” reflects my original desire to use  butcher block for the countertop, though it wound up being orders of magnitude cheaper to go with tile.

One last sketch before the actual photos from the build; this one is my proof-of-concept in determining what, exactly, I could fit in the compartment. Ultimately I decided to fix the number of taps at 3, which provides some wiggle room to clean up spills and condensation, as well as providing room for several six-packs (or, in practice, anything else that overflows from our main refrigerator). One grid unit is one inch:

All right! On to the build. So the first thing we did was pack the thing in my hatchback, drive it to Evan’s work, and strip all the crap off: We removed the lid, the hinges, and the top layer of the paint:

Then it was black Rustoleum Appliance Epoxy to turn it the color we wanted:

a

Next, we learned the wrong way to build the collar: using right angle brackets and screws. The result was not quite square anywhere and, more importantly, not flat anywhere. Browsing other folks’ writeups of their builds, I found that I was not the first person to learn that this is the wrong way to build a collar. If you’re doing a build yourself, do not use angle brackets to square your collar.

What, you ask, is the correct way to build a collar? Glad you asked. It involves right-angle clamps (the link is to Amazon, though I got mine, a different brand, from Home Depot), which were a bit on the expensive side but easily the second most valuable tool in the entire process. I wish I’d bought eight of them instead of two.

This leads me into the most valuable tool in the entire process: the nail gun. The correct way to build the collar is to clamp the thing together, square and level, then nail or brad it together. After doing that, we used those angle brackets for reinforcement.

All the pieces, plus the fridge, crammed into the back of my little hatchback (VW Rabbit):

Here it is, clamped together for an in-progress glamor shot in the corner of the apartment for which it is ultimately destined:

Here’s a photo of the assembled “coffin” (where the faucets will live) — nailed together and soon-to-be bracket-reinforced, all with the aid of the right-angle clamp again.

Here’s the base for the countertop, assembled and stained; this is the part that will be removable for access to the fridge compartment; you’re seeing it from the top-down here:

Three screws in each corner of the plywood board so it’ll support all the glasses you’d ever want to fill:

Ignoring the mess in the visible area of the apartment, here’s the product of Evan’s first-ever tiling job, prior to removing the leftover grout. Not too shabby:

This interfaces to the collar in two ways; the 1×4 border rests on the top of the collar, and the board under the tile rests on a 1×2 support glued and screwed into the inside of the collar, pictured below:

Here’s a view of the assembled product so far; all we’re really missing is the faucets and insulation:

Since we removed the original lid and the plastic seal around the top, we needed a way to cover up the exposed insulation. I had some plexiglass sitting around and decided to cut it to size and seal it with silicone. Here’s one of the joints, in progress:

To provide extra insulation, we used three-quarters-inch styrofoam insulation, doubled-up in many places; we wrapped it in heavy-duty aluminum foil to keep it all together:

The top insulation piece (pictured below) is separate from the countertop piece; this makes opening the fridge a two-step procedure but reduces the risk of knocking the insulation off:

Okay, so now that the insulation’s out of the way, the only thing left is to attach the faucets. Evan insisted that we put some kind of design behind the faucets; I finally agreed (and am glad I did!). We found a little bit of spare sheet metal and cut it into three three-tiered designs, each of which looks a little bit like this (from behind):

Three of these attached to the front of the “coffin” look like this (after punching big holes in each of them, which, I’ll note, was a bit of a pain):

After the fact, we noticed (and were not bothered in the least) that we had basically ripped off our apartment complex’s logo (this design is on every elevator landing in the building):

A bottom-up view of the “coffin” piece with the bottom cut out, shanks and backing pieces attached, and insulation visible (plus the crown molding has been stained):

Here’s the completed view of the top of the keezer, with the default black plastic handles on each of the faucets. Note also the Reddit alien, which is just waiting for a hole to be drilled in the bottom to attach to the rightmost faucet, which is to dispense “/r/paleale”, my entry to the Reddit Homebrewing Competition in the American Pale Ale category.

Okay, so, all of that said; how am I to keep my chest freezer from turning my beer into slushies? With a new thermostat! I don’t need to replace any part of the freezer, of course, because it wants to take its contents down to 0°F. So I just kill the AC power to the freezer when it gets to the temperature I want it to be.

Lots of people use a “Johnson” for this. I thought $75 was a bit steep, so I built my own out of an Arduino Pro Mini (Sparkfun’s miniaturized, cheap Arduino variant), digital temperature sensor (that looks an awful lot like a transistor), and a relay control board for closer to $30.

Incidentally, I did accidentally slushify a keg of beer a couple of weeks ago; it was pretty much hilarious.

Here’s the assembled relay control board in an enclosure with AC in and out (on the right) and the VCC, ground, and control line for the relay (left):

Here’s the Arduino mounted on a piece of protoboard I had sitting around. The wires going toward the top connect to the temperature sensor. Not pictured (and still not connected, though it is built) is my display PCB.

That’s it! Here’s the finished product at the time of activation:

Plus a bonus photo of the completed /r/paleale handle:

I’ve just started posting code samples from the wonderful SpotTheVuln.com on the walls in our building on 11×17 cardstock behind thin plexiglass panes so they can be annotated with dry erase marker when people solve them or have comments:

I love the site but wanted to branch out a little bit into some samples outside of the PHP and Wordpress world. In my first attempt, I didn’t branch very far, and it’s a bit longer than I would have preferred, but here it is — from MoinMoin. Hopefully I included enough information to find the issue.

def getUserId(request, searchName):
    """
    Get the user ID for a specific user NAME.
 
    @param searchName: the user name to look up
    @rtype: string
    @return: the corresponding user ID or None
    """
    if not searchName:
        return None
    cfg = request.cfg
    try:
        _name2id = cfg._name2id
    except AttributeError:
        arena = 'user'
        key = 'name2id'
        cache = caching.CacheEntry(request, arena, key)
        try:
            _name2id = pickle.loads(cache.content())
        except (pickle.UnpicklingError, IOError, EOFError, ValueError):
            _name2id = {}
        cfg._name2id = _name2id
    id = _name2id.get(searchName, None)
    if id is None:
        for userid in getUserList(request):
            name = User(request, id=userid).name
            _name2id[name] = userid
        cfg._name2id = _name2id
        arena = 'user'
        key = 'name2id'
        cache = caching.CacheEntry(request, arena, key)
        cache.update(pickle.dumps(_name2id, PICKLE_PROTOCOL))
        id = _name2id.get(searchName, None)
    return id
 
class User:
    """A MoinMoin User"""
 
    def __init__(self, request, id=None, name="", password=None,
                 auth_username="", **kw):
        """ Initialize User object
 
        @param request: the request object
        @param id: (optional) user ID
        @param name: (optional) user name
        @param password: (optional) user password (unicode)
        @param auth_username: (optional) already authenticated user name
                              (e.g. when using http basic auth) (unicode)"""
        self._cfg = request.cfg
        self.valid = 0
        self.trusted = 0
        self.id = id
        self.auth_username = auth_username
        self.auth_method = kw.get('auth_method', 'internal')
        self.auth_attribs = kw.get('auth_attribs', ())
 
        # we got an already authenticated username:
        check_pass = 0
        if not self.id and self.auth_username:
            self.id = getUserId(request, self.auth_username)
            if not password is None:
                check_pass = 1
        if self.id:
            self.load_from_id(check_pass)
            if self.name == self.auth_username:
                self.trusted = 1
        elif self.name:
            self.id = getUserId(self._request, self.name)
            if self.id:
                self.load_from_id(1)
            else:
                self.id = self.make_id()
        else:
            self.id = self.make_id()
 
    def __filename(self):
        """ Get filename of the user's file on disk
        @rtype: string
        @return: full path and filename of user account file
        """
        return os.path.join(self._cfg.user_dir, self.id or "...NONE...")
 
    def save(self):
        """ Save user account data to user account file on disk.
 
        This saves all member variables, except "id" and "valid" and
        those starting with an underscore.
        """
        if not self.id:
            return
 
        user_dir = self._cfg.user_dir
        filesys.makeDirs(user_dir)
 
        self.last_saved = str(time.time())
 
        data = codecs.open(self.__filename(), "w", config.charset)
        data.write("# Data saved '%s' for id '%s'\n" % (
            time.strftime(self._cfg.datetime_fmt, time.localtime(time.time())),
            self.id))
        attrs = vars(self).items()
        attrs.sort()
        for key, value in attrs:
            if key not in self._cfg.user_transient_fields and key[0] != '_':
                # Encode list values
                if key in ['quicklinks', 'subscribed_pages']:
                    value = encodeList(value)
                line = u"%s=%s\n" % (key, unicode(value))
                data.write(line)
        data.close()
 
        if not self.disabled:
            self.valid = 1