I can’t get enough of this stuff:
It’s male. But what is it? A zonkey? A deebra? That’s the debate in Barbados since a zebra gave birth to a foal sired by a donkey.
Alex was born April 21, a milk-chocolate brown creature with the black stripes of a zebra on his ears and legs. His face looks more like a horse, with a distinctive black “V” patch on the forehead.
I am a fan of this hummus recipe on Epicurious. However, this makes a monstrously huge amount (and, in my opinion, doesn’t call for enough olive oil or garlic), so I like to adjust the proportions:
- 3 garlic cloves
- 1 teaspoon salt
- 2 cans TJ’s organic chick-peas, drained and rinsed
- 1/3 cup well stirred tahini
- 1/8 cup fresh lemon juice, or to taste
- 1/3 cup olive oil, or to taste
- 1 tablespoon pine nuts, toasted lightly
This is still rather large, but is easily cut in half if one desires.
Tonight I discovered an even easier way to make this, using “Tahini Sauce”. This is also found at my favorite store, TJ’s. The sauce already contains tahini, lemon juice, garlic, and olive oil (note that the sauce is pretty yummy on its own too, although I prefer hummus). You’ll still need to add a bit more of each of those ingredients yourself to get the taste just right. Here’s what I used tonight:
- 3 tablespoons Tahini Sauce
- 1 can TJ’s organic chick-peas
- 2 tablespoons olive oil
- 2 teaspoons lemon juice
- 1 tablespoon water
- 2 cloves of garlic
This came out pretty good, and was a reasonable amount for 2 people to actually finish in a few days. :)
This morning, Chris Anderson posted a good response to some of Dave Shea’s concerns/questions about Avalon. Both posts are worth a read – very educational in terms of understanding both Avalon itself and some of the initial impressions of the community.
Rob, Arik, Karsten, and Pablo are on Channel 9 talking about Avalon.
If you just want to see the pretty demos, skip to about 34 minutes in. Nathan is the design guru behind those. I suspect that seeing the demos will inspire you to watch the interview as well. :)
I promised that I would explain a little bit about what “Application Model” means, and more specifically what it means for Avalon. Before we can even get too far there, it’s interesting to ask a simple question: what do we mean by “application” in the first place?
A lot of application platforms don’t do a great job of answering that question. Take these two big categories of app development platforms as examples:
- Desktop Applications: In the traditional desktop app world, there hasn’t ever been a very good model for what an application actually is. Take Win32, for example — here an application is roughly a set of windows in the same process. Because there isn’t an entity representing the app itself, the traditional practice is to pump messages (WM_EXIT) to the main window’s wndproc. State management and manipulation isn’t as hard as it is on the Web, but it is left up to the developer.
In the Windows world, perhaps the best we’ve done so far in this area is with Windows Forms, which provides an Application class that starts and stops the message loop and receives system messages.
- Web Applications: There are some parallel issues in the Web development world. Traditionally, a Web “app” is roughly a set of pages hosted on the same server (usually) that are part of some interactive user activity. Most of the “application-ness” comes from communication with the server, which is done through post-back (and the user experience of post-back is of course sub-optimal, especially for users with slow connections). State management is hard, especially when passing data between pages because of the lack of structured data.
Today we have server-side scripting languages that make “application-ness” for Web apps easier to grok. ASP.Net, for example, provides application-level services for state and session management. Additionally, there have been advances in ASP.Net that enable more and more things to happen on the client side and thus reduce post-back.
With Avalon, we’ve learned some lessons from both of these app paradigms. We’ve defined an application in terms of an object that represents application-ness (which is a godsend for those of us who can’t help thinking in object-oriented terms most of the time), and provided object model there that lets our developers manage common application-related activities. Thus we are able to leverage some of the lessons we’ve learned from other app platforms by:
- Providing a well-defined entity for system interaction (the Application class).
- Enabling you to customize that entity by hanging any state off of it that you want.
- Enabling you to listen to app-wide events at the Application level.
- Providing simple object model around window management.
- Handling resource management for you, allowing you to refer to your application’s embedded resources (pages, images, etc.) using relative URIs (a lot more on this topic later).