Starting from either the dried powder or small amount of (well broken-up) dough works about the same way, I basically followed these instructions, though I like to use a teacup for the small container and do a second small feeding around 8 - 12 hours in regardless of whether there is any apparent activity, then wait another 12 hours or so before moving it to a larger container and upping the volume.  Once you’ve increased it to a cup or more, it’s active and ready to start using.  (One thing to note: once this starter gets good and active, it smells rather like glue; dunno if it’s really producing toluene or just smells like it, but don’t worry, mine smells like that too and the bread comes out great.) There are at least as many suggestions for feeding, storage, frequency of use, quantity, etc as there are bakers; I’ve only been at this a few weeks, but here’s what I’ve been doing.

I like to keep about two cups active at a time in a wide mouth quart canning jar; I kinked the edges of the lid disc to keep it from sealing.  If there is more than two cups right after feeding, it will escape from a four cup jar; whatever you use to store it, never fill it more than half way. So far two cups is proving to be a pretty good quantity: it doesn’t take up much fridge space, and it means I can use fairly large amounts of starter which brings with it more flavor and tanginess.  I keep it about the consistency of thickish pancake batter, which keeps it easy to stir and pour.  

I’m not very particular about the precision with which I feed it: when it gets down to a cup or so, I add more water, stir it vigorously with a sturdy plastic chopstick, and start adding flour a little at a time until it’s back to the right consistency.  If it’s going back into the fridge, I give it an hour or so to get a little active and bubbly first.  I keep it in the fridge during the week, and sometime around friday night I take it out and stir it up so it will be good and active to do something with on saturday.  When it separates, I just stir the liquid back in; this should make it more sour, so you could discard the liquid and add a bit of water if you want.  I generally keep it out all weekend and cook with it as much as possible, and then put it back in the fridge sunday night.  The most important thing is don’t worry too much about it: keep some backup starter frozen and scratch your head at anyone who says sourdough is difficult.  It’s not, it really is very easy, so relax, have fun, experiment.  So what have I been experimenting with?  

Bread, of course, especially dinner rolls, which I’ve been baking in a cast-iron skillet over indirect heat in my Weber grill.  My latest creation is fresh basil and olive oil bread (shown above).

Pizzas: similar to bread, but you want to minimize the rise in the end (I’m a NYC-thin-crust pizza snob); I’ve been baking these in my Weber, too, and they’re a lot of fun.

Biscuits: there are a couple styles of sourdough biscuits I’ve tried.  My first attempt at using baking soda and the acidity of the starter was edible, but I need to work with the recipe quite a bit; my yeast-leavened ones (like rolls, but without kneeding) were tasty, but the crust was too hard (not sure why).  Both are sound ideas, just need the right recipe (suggestions welcome).

Pancakes: these, too, use the acidity of the starter to leaven with baking soda; I’ve found that adding a bit of baking powder for some double-action insurance is a good idea, and the batter needs a fair amount of sugar or they come out really cardboard-y

Wrapping up with the recipe for that basil bread (yes, I make bread by weight; in baker’s percentages, this bread is roughly 50% water (plus the starter), 7% olive oil, 2% salt [Update:] Next time, I’ll probably use a little less olive oil and salt):

The Sponge:

• 500g flour
• 500g water
• a generous 1/2 C starter
• at least 1/2 C chiffonade basil (a lot, the leaves of several healthy stalks)

Allow the sponge to ferment for at least five hours at room temperature

The Dough

• another 500g flour (or perhaps a little less), added incrementally
• 70g olive oil
• 20g salt

Mix the dough in a stand mixer with the dough hook, adding flour until the dough is smooth, elastic and only a little tacky.  Kneed a bit by hand, if only to enjoy just how satiny-smooth the dough is.  Form into a ball, coat lightly with olive oil and let rise in a warm place for 1-2 hours.  Fold, form into loaves and proof (final rise) for 1-2 hours (yeah, I let it go a little long).  Bake at 400°F-500°F until the internal temperature of the loaves reaches 190°F or more.  Slice, take some pretty pictures and enjoy!

Ok, really wrapping up: if anyone wants some starter, especially if you’re in the bay area, contact me through this site.

Apologies to Zappa this time.  The other day I bought a small LED dynamo flashlight; I was curious about the implementation details and how much power it actually generates.  Turns out the dynamo appears to be a very common sort of DC motor and, while it doesn’t appear to produce a lot of power, it does seem to be a usable amount for a variety of low-power applications.

First peek: it’s geared up quite a lot; speaking of quite a lot, there’s some silicone grease in there too…

The dynamo motor appears to be identical to the one that drives the tray mechanism of every CD or DVD drive I’ve ever taken apart. (Not just physically, I got similar voltages from finger-spinning each of them)

Starting from the left: a bridge rectifier so it doesn’t matter which way you turn the crank, the resistor that (I believe) limits the charging current into the battery, the flashlight / charge switch (yup, you gotta crank in the dark), the LEDs and their current-limiting resistor, and finally a cute little 3-cell NiMH battery pack.

The bottom of the circuit, showing the traces.

Sooner or later, I’m going to play with dynamos again, they seem like a great way to power small projects, need to learn more about battery charging first though.

Two of the things I love most about unix are learning new tools and tricks and teaching tools and tricks to others. One of unix’s real gems is uniq(1): “report or filter out repeated lines in a file”. Extremely simple and powerful, probably a page or two of easy code, but completely indispensable.  I usually use it to get the intersections or differences of lists using the -d and -u options. Intersection is pretty straightforward:

  cat list_one.txt list_two.txt | sort | uniq -d

Basically, cat the two lists together (incidentally creating the union, with duplicates), sort that (because uniq only checks adjacent lines, so duplicates have to be next to each other) then have uniq print only the duplicated lines (ok, yeah, you need to be sure neither list has any duplicates to start out with)

Getting a strict difference is a little tricker, you actually have to get the intersection first and then remove those elements using a second pass:

  cat list_one.txt list_two.txt | sort | uniq -d | cat list_one.txt - | sort | uniq -u

Will return the elements of ”list_one.txt” that do not appear in ”list_two.txt” (Note the - argument to the second cat, which signifies standard input and receives the | – cat is worthy of its own entry sometime, though)

some displays

some headers

a few protoboards

and a pile of other great stuff

I’m not telling what I added, I’m not even going to give hints (and only partly ‘cos I haven’t picked out what I’m adding yet) but I will say the next person is probably going to have to either take out more than they add or split the box into two; I have quite a lot of great junk!

Chicken thighs smoked over rosemary sprigs

I built myself a small ceramic smoker out of unglazed terra cotta flowerpots and have been using it frequently for several months now, it’s high time I wrote it up so others can enjoy the smokey goodness and continue to improve the design.

It is based on the smoker Alton Brown built in the Good Eats episode Q which has also been written up here, there and yonder, but I reworked it to use charcoal instead of an electric hot-plate.

At some point I’d like to write up a tutorial series, but this article belongs somewhere around lesson 4 or 5.  If you’re just starting out, you’re welcome to dive in here, just be aware that it’s not really intended as a first project.  I assume at least some familiarity with C, microcontroller concepts and schematics.  I comment my code quite liberally and intend that to provide detailed explanations; what follows here is meant to provide some high-level descriptions and references for the major facets of the project and I recommend opening the code and schematic files below and referring to them as you read this.

My copy of X11 got pooched so I sketched the schematic in Create: ThereAndBackSchematic.pdf (did I mention I desperately want a native Mac OS X schematic editor?); the code to drive it: ThereAndBack.c; helpers: bit_helpers.h, avrbuild, avrpush

The circuit is pretty straightforward: a couple of buttons, “Go” tells the servo to go to the other position, “Set” switches into or out of set-mode; a potentiometer acts as a variable voltage divider, feeding an analog-to-digital converter input a voltage between ~0 and ~Vcc (plus it has a couple of extra resistors to limit current at the extremes); some LEDs to display the approximate value being read by the ADC because blinky lights rock; and finally, a standard hobby servo, I’m using a Futaba S3003 because it’s cheap and reasonably strong.  I have been powering the circuit from a USB port via my (patched) USBtinyISP or with 3 AA batteries, but I have not been putting any load on the servo; note that the stall current is pretty close to the 500ma USB spec, so the batteries are the (slightly) safer alternative.

The code depends on a collection of bit manipulation convenience macros I’ve accumulated into bit_helpers.h.  The switches are debounced with a vertical stack counter (thanks, Bill!)  Both the ADC and timer are flexible but complex peripherals, requiring a fair amount of setup and configuration to have them do what you want. This page helped me a lot with understanding and using timers for pulse-width modulation and servos, the ADC I mostly had to piece together from the datasheet.  Fortunately, both can be really easy to use once you have their 10-or-so lines of setup: just set the right OCR register to adjust the width of the pulse that controls the servo or read the ADCH register to get the most recent converted value.  Finally, to make it remember the set positions even if it loses power, I followed this tutorial for the use of EEMEM / eeprom_read_byte, though it kinda glosses over loading the initial values into the chip.  The first step is to copy the eeprom data out of the .elf file with another avr-objcopy step: 

avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex $ElfFile $EepFile

and push it to the chip with an extra -U to avrdude: 

-U eeprom:w:$EepFile

 I added those lines to the shell scripts I use to build avr projects and push them through to the chips (linked above.)

Finally, a couple notes on using it: when it powers on or goes into set-mode, it always starts in position A. When setting a new pair of positions, if the potentiometer is still where you left it after programming position B last time, the servo will move to that position, nevertheless it is setting position A. Also, when setting the positions the “Go” button still simply switches to the other position; in general, you want to hit “Set”, dial in position A, hit “Go”, dial in position B, then hit “Set” again (if you hit “Go” again after setting position B, you’re back to setting position A which will immediately get the current value from the ADC.)