It's April. The past two weeks have brought spring's first glimmers, the frozen world turning to soggy mush as the 0C barrier is occasionally broken. The crisp-though-bareable air, the sky expanding like a blue cornfield across the prairies, the sun pouring through the windows, viscous, tangible... all that is out-of-doors hints at the promise of summer's decadence. To celebrate the upcoming onslaught of shineshineshineshineshine, it was decided the most decadent sandwich of them all, the Shooter's Sandwich, should be our fare for the day's main meal.

Shooter's Sandwich

Ingredients

• Two steaks. We went with two of The Co-Op's finest striploins.
• One round loaf of sourdough bread
• 500 grams of brown mushrooms
• 500 grams of shallots
• Extra spicy horseradish
• Dijon mustard
• 75 grams of butter (or, in our case, saved-up bacon grease)
• Bulb of garlic
• Pepper
• Salt
• Worcestershire sauce

After a morning at the grocery store

Preparation

First, have your lovely and beautiful sous chef deskin and chop up, without the help of a slapchop, the musrooms and shallots. Get them into a really fine diced consistency.

Deskinning the shallots

Next, pop a pan onto the burner, and get that thing all medium-sizzling. Toss in 75 grams (or, a few hearty spoonfuls) of hardened bacon fat. Let the fat liquefy, and toss in all the mushrooms and shallots. Add some salt and pepper in there and let the juices mingle and party.

While these are busy getting down, cut the top quarter of the loaf off.

Use your dirty paws to rip out most of the gushy inner sourdough from the loaf. Save the innards to make breadcrumbs, or alternatively, press into a mushy ball and throw at your annoyed sous chef.

By now (if now is like ten or fifteen minutes since you popped 'em into the frying pan), the mushrooms and shallots should know one another really well. Unfortunately for the shallots but fortunately for us, the shallots don't have enough flavour density to really fill out the sponge-like mushrooms. And by now, after all this partying, those shrooms are just ready to suck up some flavours and become little bits of epicurean dynamite. Have your forgiving sous chef finely grate some garlic and bring you your big ol' bottle of worcestershire sauce. Toss both those in the pan and stir a whole bunch. Then, set aside.

The supporting cast has their lines memorized and heavy applications of makeup. Now it's the star of the show's time. Get another pan dry and hot over the highest heat your burners can muster. You know the pan's ready when you look at it and the air above shimmers and swirls, air density increasing in eddies and currents like a desert wind in your kitchen. Season your steaks with some salt and pepper, and drop 'em in the pan.

Hey there beautiful...

Now, I'm the type of person who prefers his steak on the side nearer 'cow' than 'leather', and so the temptation is to give each steak side thirty seconds on ultra-high heat, no more, leaving it with a Michelson-endowed outer golden-black crust of flavour and the inside a more-red-than-blue oasis of tenderness, however, in the case of the Shooter's Sandwich, the prevailing wisdom is you want a little more doneness to your meat. Shoot for medium.

Also unlike when cooking steak for its own enjoyment, you don't want to let these steaks set at all. Once their done, take the pan straight from the heat and over the hollowed out loaf and plop the first one in.

Once you've rammed the first steak into its doughy new home, layer on all the mushrooms and shallots you've slaved over.

Onions and shallots on top

Now, put the second, final, steak on their. It'll take a bit of shuffling and fussing before the entire package will fit snugly in its bread container, but don't be afraid to manhandle the meat and adjust the mushroom paste a bit.

Now, load up the out-facing steak with horseradish and shellack the bottom of the hat with dijon mustard.

Pop the top back on, wrap the while affair in wax paper, and tie it up with some butcher string.

Now wrap the whole bundle again, this time in tin foil. The hardest part of the whole recipe is this next step. You must take a big cutting board and balance it atop the bundle of nutrition you've created. Atop this cutting board, you must place some heavy objects, about as heavy as a Quiet Deluxe 46 typewriter and a hardback copy of The Adventures of Lewis and Clarke. And now (the hard part), you must wait, six hours at least but overnight is best. Let the loaf and its contents compress and densify, more taste per cubic centimeter than you can imagine.

Once the wait of the millenias is over, unwrap your treasure, but leave the last layer of wax paper on. Cut as you would a cake. Enjoy pure decadence.

First, drool over your masterpiece. Then, devour with good friends.

[root@test /]# cat /etc/libmap.conf 
[mysqld]
libpthread.so.2 libthr.so.2
libpthread.so libthr.so

Typically when developing a Twilio application, there is an ugly and confusing separation between making REST requests to Twilio's API servers, and setting up the response handlers that reply back to Twilio with TwiML instructions. For example, when you POST to the /Calls resource in order to initiate an outgoing call, you specify a StatusCallback URL. When the call is answered, Twilio requests that StatusCallback URL. Your application then must respond back with valid TwiML, and Twilio executes your instructions.

In truth, this all is very straightforward no matter what library, language, or platform you're using to build your Twilio app. You make some REST requests, ensure there's some sensible and valid TwiML at the URLs you specify, and you're good to go.

Here's an example of what I mean, borrowed from the Python Twilio helper library:

# Instantiate a Twilio REST account object 
account = twilio.Account(SID, AUTH_TOKEN); 
# Call my parents req_data = { 
    'From': MY_CALLER_ID, 
    'To': '867-445-1795', 
    'Url': 'http://hostname/path/to/my/love/filled/parental/greeting.xml' 
} 
print account.request('/2010-04-01/Accounts/%s/Calls' % \ 
    ACCOUNT_SID, 'POST', req_data)

Before your request is POSTed to Twilio, this code assumes you've set up a webserver on your machine, and you've gone and put your TwiML (either statically or dynamically generated) in the path you've specified. The file probably looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<Response>
        <Say>
                Hey mom and dad! It's your baby boy! I love you!
        </Say>
</Response>

Granted, nothing above is really difficult (who can't configure nginx or apache and write some XML, after all?), but it still is pretty annoying to have separate controllers for your Twilio REST requests and your TwiML responses. Additionally, if your app includes lots of complex logic (suppose, for instance, you have various different responses you want to deliver based on an incoming caller's geographic location), it becomes a cumbersome and error-prone process to maintain all your different REST controllers and TwiML response generators.

Enter: Node-Twilio.

Node-Twilio is a Twilio helper library for Node.js. Now, Node-Twilio's not your average Twilio helper library; It doesn't simply provide you with a few simple method calls for making REST requests and a few functions to ensure you generate valid TwiML (but it does include both of those). Node-Twilio takes care of provisioning all the URLs you deliver to Twilio to deliver TwiML, and it exposes all of Twilio's functionality as EventEmitter objects.

Perhaps an example is in order. Again, let's call my parents (they're great, and I want to make sure they really know it), but this time, let's do it with Node-Twilio.

// First, we have to require TwilioClient and the TwiML helper
var TwilioClient = require('twilio/client'),
    Twiml = require('twilio/twiml');

// Now, let's instantiate our client with our credentials and hostname
var client = new TwilioClient(ACCOUNT_SID, AUTH_TOKEN, HOSTNAME);

// Ok, great! Now, let's get a new PhoneNumber object
// Note: We can pass in either a Twilio phone number
// associated with our account, or the SID of same.
var phone = client.getPhoneNumber('+16067777777');

// Alright, we're ready to make a call
phone.makeCall('+18674451795', null, function(call) {
    // Call is an OutgoingCall object
    // It is an EventEmitter
    call.on('answered', function(callParams, response) {
        // callParams is simply a map of the POST vars
        // Twilio sends with its request.
        // response is a Twiml.Response object
        response.append(new Twiml.Say('Hey mom and dad! It's your baby boy! I love you!'));
        response.send();
    });
    
    call.on('ended', function(params) {
        console.log('Call ended');
        process.exit(0);
    });
});

Paste all that into a file called app.js, substitute in your credentials, and you're ready to call my parents.

Now, what about incoming calls (and SMS, too)? Well, they're just as simple to handle. The PhoneNumber object returned by the TwilioClient is also an EventEmitter. It emits 'incomingCall' and 'incomingSms' events. So, if you wanted to respond to SMS messages, you'd do something like this:

phone.on('incomingSms', function(smsParams, response) {
    // No matter what the incoming message is, respond back with a 
    // quote from your favourite recent novel (Adam Levin's The Instructions)
    response.append(new Twiml.Sms('We are on the side of damage!'));
    response.send();
});

Simple, isn't it? Node-Twilio makes developing Twilio apps simpler and more rapid than any other platform or application. In addition to providing a clear EventEmitter interface to Twilio's REST API, Node-Twilio includes wrapper methods for every one of the resources defined in the API, so if you want to get into the nitty-gritty, you're easily able to.

Interested in trying it out? Check out Node-Twilio on github, take a look at the documentation (which is still slightly in-progress), and give it a whirl!

My rating: 9.1/10

My rating: One kilogram of gold that happens to rend my heart

I've seen the Youtube shock videos that show in gruesome, gut-wrenching detail the evils perpetrated in factory farms. I've read the literature about the ethics of eating animals (including the especially awesome Consider the Lobster by DFW). I've seen the evidence of the atrocious health and environmental impact modern animal eating inflicts. Yet Eating Animals is the single best argument against eating animals I have ever encountered.

Perhaps the reason that this book is so convincing is that it comes without an agenda. Foer is a storyteller (one of incredible talent), not an animal rights activist, and Eating Animals is a story (a heavily researched story). He begins by telling the story of how the book came about: Foer was going to become a father, and he realized that in order to be able to do right by his son, he'd have to investigate his own dietary customs, those that he'd be passing on to his son.

As he tells us, this research project wasn't Foer's first foray into funny dietary restrictions--he'd been variously strictly vegetarian, kinda vegetarian, lapsed vegetarian, and back and forth between those states a bunch of times. In that sense, his path mirrors my own, stupid idealism leading at different times to veganism, vegetarianism, and back and forth between (all along with rare doses of grass fed 100% Canadian beef). At least for me, it was comforting that Foer's path mirrored my own to some degree. Being able to identify with him made the impact of his arguments all the greater, whereas when Jaquin Phoenix preaches at me about how evil I am, I am less able to identify (and a bit annoyed).

Eating Animals is effective not because it tells us about the evils of modern agribusiness, which it does with startling acuteness. It is effective because Foer attacks the problem not from on high, not looking to explain how eating animals is just plain wrong so don't do it, but rather he tells about all the problems that come for people who choose not to eat animals. He rightly points out that eating is a social act. Eating, maybe unlike any other regular social activity, binds us and brings us together. Gathering to break bread is a tradition that spans all cultures and peoples. It is also something that everybody (excepting those media-sickened teenagers who refuse) does on a daily basis. Since it's so regular and so social, the choice of what we eat matters more than just what we eat--we are identified by our food, and our society and environment are products of it.

The opening chapter of the book was especially enlightening. Before he delves into detailed descriptions and analyses of each of the major animals and how they are farmed in factories, Foer talks about factory farming at a higher level. He describes how until the 1950s, farming was an activity that sought a balance with nature. Farming was an activity that required care and patience, and a symbiosis between animals and us, the eating animals who ate animals. Foer eloquently points out that in stark contrast to traditional husbandry, "Factory farming considers nature an obstacle to be overcome."

The remainder of the book is a well-written description of various farms (not only factory farms, but also those which practice traditional husbandry--the latter becoming increasingly rare) and the perversions that daily happen within them. While reading, it becomes apparent that not only is factory farming inherently evil, it is totally unnecessary: We do not need such giantified farming operations to feed ourselves, and we are now eating more meat than ever before in history, and it is far cheaper per-pound than ever before.

It is very easy to forget the stories we know are true about our food. It is easy, and most young people these days are at least partly cognizant that unconscionably evil acts were required in order for them to buy that burger for $1.99. This forgetting is easy, and we all do it, every day we eat meat. That is the most important takeaway from this book: We can not consider ourselves conscientious or good if we daily provide money and support for organizations that commit atrocities, billions per year, all to bring us convenience and tastes we may prefer.

The author of this book as well as every single reviewer of it doesn't understand what it's about. Good to a Fault, they say, is about death. The big, heavy, subject of death. Ostensibly, they say, the book is about religion and its human value, the collateral damage caused by terminal illness, the burden of being elderly, and what it is that gives life meaning.