Georgia hackerspace Freeside Atlanta needed countertops, so they made their own with chicken wire and concrete, while referencing this instructable.
Freeside is a great space, but our kitchen could be charitably described as “needs work”. The countertops are old, difficult to keep clean, and just generally bad. What the heck, we’re a hacker space, right? Lets hack some countertops.
My book: Clever Algorithms: Nature-Inspired Programming Recipes launched just over one month ago on January 26th 2011. I thought I would briefly summarize what happened, and some findings and lessons I've realized over that time.Purchase Clever Algorithms: Nature-Inspired Programming Recipes with 15% off using the coupon code IDES305 (offer ends March 3rd 2011)
I’ve never been to New Orleans, but my first Seattle roommate was a recent transplant who plunged me headfirst into its culture. With rabid enthusiasm he’d leap out of his chair, yank the needle off whatever album was playing at the time, and plop another record in its place.
‘You’ve never heard The Wild Tchoupitoulas?’ he’d cry. ‘Man that was the Neville Brothers at their best. It just wouldn’t be N’awlins without them!’ The room would swell with that Cajun rhythm, and before long we’d be dancing around the room. It was that good.
He also turned me on to Creole food. Jambalaya, gumbo, ‘Po’boy’ sandwiches and crawfish that were spiced to his demanding palate. And Red Beans and Rice, cooked long and slow to develop the flavor. Made with that trinity of Creole cooking: celery, green pepper and onion. Mm, Mmmm.
Of course, Chuck’s Red Beans would always have ham hocks in them; I’ve chosen to leave them out. Either way, these tasty beans are just what the doctor ordered. In fact, it wouldn’t be Mardi Gras without them!
Vegetarian Red Beans and rice
Enough for 6 hungry people
2 cups dry Small Red Beans, soaked overnight
2 medium yellow onions
4 sticks celery with leaves
1 green bell pepper
4 Tablespoons olive oil
6 cups water
2 teaspoons of salt
½ teaspoon of freshly ground black pepper
1 ½ teaspoons of dry thyme
1 ½ teaspoons of oregano
¾ teaspoon cayenne pepper
3 cloves garlic, pressed or finely chopped
8 ounces of tomato sauce
Cooked rice
Soak the beans: In a large pot, cover beans with enough cold water to submerge them by 2″. Cover the pot tightly and let the beans soak for 8 hours or overnight.
Make the trinity: Remove outer skin, trim ends and chop the onion. Rinse and chop the celery with its leaves. Remove seeds and stem and chop the green pepper.
Heat 4 Tablespoons of oil in a 12” skillet. Sauté the onion, celery and green pepper over medium-high heat for 5 minutes, turning occasionally with a spatula. Veggies are done when the pepper lightens in color and the onion is translucent. For best flavor, do not brown.
Put it all together in a pot: Drain the beans. In a large oven-proof casserole or dutch oven, put the beans and 6 cups of cold water and stir in the sautéed veggies. Now add the salt, black pepper, oregano, thyme, cayenne pepper and garlic.
Bake in a conventional oven: Preheat oven to 325°. Put beans on the center rack and bake for 2 ½ hours covered, stirring every half hour or so. After 2 ½ hours, add the tomato sauce and remove the lid from the bean pot. Cook for a further hour, until beans are tender.
Bake in a woodfired oven: This kind of cooking is great for the day after you’ve had your oven hot for pizza or bread, still warm with residual heat. Build a small fire to one side and, after about 45 minutes, put the beans on the other side. Add small to medium branches to keep the fire low and put the door in place to keep the flame down, leaving a 2” crack on one edge of the door as a vent. At this low heat, you can use an oven thermometer to check that your oven heat is as close to 325° as possible.
Bake for 2 ½ hours covered, stirring every half hour or so and turning the bean pot around each time. After 2 ½ hours, add the tomato sauce and remove the lid. Cook for a further hour, until beans are tender.
Time to celebrate: Make a pile of rice according to package directions. Put a scoop or two of rice in a bowl and top with Red Beans. Now get out your favorite Neville Brothers music and prepare to PARTY! It’s Mardi Gras after all!
Meatatarian note: For a meaty version of this dish, add 2 pounds of smoked ham hock to the pot and cut back on the olive oil. On the other hand, this vegetarian version makes a great side dish to Seattle Smoked Country Style Ribs, which I’ll be cookin’ up for Mardi Gras as well. It’s all good!
The bean pot in with the fire
If you have a little time and a lot of nostalgia for crackling candy, learn to make your own Pop Rocks with this Instructable from chickflix. Most of the ingredients are easy to find, and you’ll need a blunt object such as a hammer to break them up into pebbles. Enjoy your freshly-made candy while sharing urban legends about the dangers of eating Pop Rocks with carbonated beverages.
I am snow-crazy tonight and it awakens dirty dirty thoughts…
Eilen Jewell is a good accompanist.
The first iteration of the public front end of the Australian Dress Register went live a few weeks back. This release makes visible much of the long data gathering process with regional communities that began in 2008 and continues as more garments are added to the Register over time.
The ADR is a good example of a distributed collection – brought together through regional partnerships. Many of the garments on the site are held by small regional museums or, in some cases, private collectors and families. It is only through their rigorous documentation and then aggregation that it becomes possible to tell the national stories that relate to changes in clothing over the last 200 years.
The ADR extends the standard collection metadata schema that we use for documentation at the Powerhouse with a large range of specific data fields for garment measurements and the quality of preservation. These have been added to allow costume and social history researchers to explore the data in greater detail and granularity. A good way to see the extra level of detail in the ADR is to compare a record on ADR with the same object record in the host institution’s own collection (where it is available online).
Here’s the child’s fancy dress costume from 1938 on the Powerhouse site, side by side with the same object on the ADR. (Click to view the full records)
The Resources section of the site provides volunteers and contributors without the capacity of the major capital city museums to better understand the best practice methods of preserving, documenting and digitising their garments along with a range of simple how-to videos.
The Browse and Search uses Solr on the backend and offers extensive faceting (Here’s just the discoloured garments with buttons). There are multiple views for search results with configurable list and grid views, and relevance, recency and alphabetical result ordering.
The Timeline is one of the visual highlights of the site, along with being rather cool from a technical perspective too. As the collection grows the Timeline and Browsing features will become more valuable to traverse the rich content.
There’s a lot more to go with this site and you’ll be seeing many more records contributed from around the country over the coming months.
In the 19th century, three ancient Egyptian obelisks made of solid granite—each weighing north of 200 tons—were shipped from Egypt to London, Paris, and New York. Postcolonial-era questions about whether ancient Egyptian obelisks shouldn’t perhaps be left in Egypt aside, how it was done is quite an interesting story. This, BTW, is just the first of what I expect will be many gems from my newly-discovered treasure trove, No Tech Magazine, a sister publication to kris de kecker’s Low Tech Magazine, which we rave about here all the time.
More:
Since yesterday was both Easter and Worldwide Pinhole Photography Day, it inspired Francesco Capponi to attempt a project he’d been thinking about for years, converting an egg into a single-use camera obscura:
The purpose was to sacrifice the camera in the process of photo creation – I wanted the camera to become the photograph. To let you understand, the process from the camera to the photograph is the same that ties the baby bird to the egg: the bird grows protected from the shell and when it’s ready breaks it and comes out. This is why I decided to create the Pinhegg – An Egg Pinhole Camera.
Francesco shared his photos in the MAKE Flickr pool and posted full instructions on how to create your own, but because of the fragility of the camera body, it’s not an easy process. In order to create four good photographs, Francesco destroyed fifty eggs.
Picking locks is one of my favorite skills. It can be one of yours as well with the Beginners Lock-Picking Blend Set from the Maker Shed. Learn about the inner workings of the mortise and cylinder lock, first developed by the Egyptians over 4000 years ago. Each set contains 8 tools hand-picked by TOOOL (The Open Organization Of Lock-pickers) that will get you on your way to opening a variety of different locks.
I was having lunch with a colleague the other day when his phone rang with the distinctive office ringtone. Rolling his eyes, he excused himself to take the call. It was just a run-of-the mill workplace emergency, but there was one thing he said that I couldn’t help overhearing: “fine! I guess we’ll just do a new release for QA.”
It stood out like nails on a chalkboard. “Huh, what do you mean?” he responded when I asked him about it, “they were trying to fix the build, but I dunno, they couldn’t, so I said to do a new release.”
My palm immediately met my forehead. Don’t get me wrong, this guy is an incredibly talented lead developer, but his team’s mangled processes caused more calamities than a cadre of cheap, kerbleckistanian coders. It was no wonder the testing and QA cycle was always fraught with failure.
That got me thinking. Developers – whether rock-star or rock-bottom – don’t really know the process, either. It’s as if we’re all accountants who think that debits and credits refer to the money withdrawn from or deposited to a bank account. It’s actually a lot more complicated than that, as are the concepts of releases and builds.
In fact, it took me quite a few years as a developer – and a bit of time working on BuildMaster – to realize that not only is this a process, but a whole discipline. This discipline – which, for lack of a better term, I’ll call Release Management – sits outside the realms of computer science (“solving problems with software”) and software engineering (“sanely structuring software”), but is equally important in creating and maintaining quality software.
It doesn’t matter how great the code is (nor how well it’s documented or tested) when there are production problems amidst a dozen different-but-related applications that are maintained by various teams and released on various schedules. While these problems are eventually solved after a blame game between developers, project managers, analysts, and even the poor fellow who moved the files, the real culprit is the process. Or more specifically, the lack thereof.
The nouns “release” and “build” are words we’ve obviously all heard before, and most certainly even used. But like debits and credits in accounting, they’re often misunderstood to kinda/sorta mean their commonplace definitions. In my colleague’s case, releases and builds were basically the same thing, except a build turned into a release after it was sent to QA, and only patches were allowed to be made to releases.
Following are the actual definitions for this context.
When they’re used incorrectly and/or interchangeably, the important conceptual differences become blurred, and unnecessary challenges start to rear their ugly head. Though seemingly subtle, it’s an important distinction, not unlike like that of classes and interfaces, and virtual and abstract methods.
Here’s a quick diagram to illustrate not only the differences, but the process.
It’s a universal process, and regardless of the size or scope of a release, they’ll all run through the same steps.
With the rules of this process defined, we can derive quite few patterns and anti-patterns.
We’ve all heard stories around broken builds, or more specifically, the consequences surrounding one: dunce cap, buying beer, and even scathing insults. But as discussed earlier, there’s a “build” (binary output of a compilation process), and a “build” (snapshot of an application that attempts to implement changes for a release) – “breaking the build” refers to the former, more commonplace definition.
While somewhat related (a build is often comprised of compiled binaries), they’re as different as orange (the color) and orange (the flavor). For example, a build of a PHP application could contain a directory of source files (it’s an interpreted language), a database upgrade script, and the results of a PHPUnit test run.
As such, a build (in the context of releases and builds) can’t really be “broken” if it can’t be built in the first place. And if a build is determined to be broken (i.e. defective), it cannot be fixed – a new build must be created.
To expand a bit further on that last point, one of the most important considerations with a build is that it must be immutable. Whatever is deployed to the first environment (“development”) should be exactly what’s deployed to the final environment (“production”). If it’s absolutely necessary to recompile code after the first environment (perhaps to remove DEBUG symbols), then the codefiles used to recompile should be identical and put through equally rigorous testing. Of course, this does not preclude the use of environment-specific configuration files or other data-driven components, but managing those is a whole a separate soapbox.
It’s also important that a Build is deployed in its entirety, and not piecemeal. That’s not to say that a directory synchronizing tool should be avoided, but more that every change represented in a build must be deployed. If, for example, a build contains four files that changed, then all four files must be deployed. If one of the changes isn’t “ready” to be deployed, then it never should have been included in the build.
While a whole lot of builds may be created for a given release, only one build will ever be released. This is especially obvious in the case of shipped software (customers aren’t given two different builds to pick from), but for in-house applications it’s not as clear.
Once a build has been deployed to production, the application has changed and will require a new release to be changed again, even if it’s a simple, one-line fix. This “patch” release can follow a different testing workflow (straight from source control to production), is still a new release.
The concept of a “version” is to uniquely identify an application at a particular point in time, and no two versions can be the same. With releases and builds, the version number simply becomes a concatenation of the release and build numbers. For example, Build 4 of Release 2.3 is version 2.3.4.
Of course, since there can only be one (final) build per release, it’s entirely acceptable to use only the release number after shipping (e.g. for marketing purposes). Version 2.3 refers to the released build of Release 2.3.
Just as you can makes changes to code without using an issue tracking system (though this is unadvisable even in the most agile of environments), applications can be released without a formal process. But this is just as unadvisable, as it leads to an unnecessary chaos.
Since a release will occur regardless, you may as well do some sort of release planning. It could be as simple as using a whiteboard to write down some release numbers and each release’s target date. Or you could use a spreadsheet. Or a wiki. Or a platform like BuildMaster. It really doesn't take much.
Once releases are formally defined, you can easily associate changes with a given release. Nearly all issue tracking systems will have a field for this, whether they’ve called it version, iteration, target, or release. Those that lack a field generally allow you to define your own fields.
Although it’s likely that most changes will simply go in the “active” release (i.e. the next one to be deployed), following this rule allows better planning and organization, even if the changes will be shifted or moved into further out releases. It’s a much better system than trying to overload a “status” field with values like “this version” and “next version.”
When changes are associated with builds (thereby making them mutable), or when they’re deployed piecemeal, the “Jenga Pattern” will start to emerge. Named after the popular game where players rearrange wooden blocks on a tower and avoid collapsing it, the Jenga Pattern introduces untested application changes that can lead to application failure.
When a build is a complete, immutable, and fully deployed, it can be thought of as a nicely stacked, undisturbed Jenga tower, with each block in the tower representing a code file, a library file, or module. While this tower may be unsuitable in and of itself, the simple act of moving it through different testing environments will not cause it to collapse.
However, if the blocks are rearranged between different environments, it will nearly be impossible to know if a defect is a result of the code or deployment of the code. As more blocks are rearranged between environments, the risk of collapse will increase. While you can try to judge whether a block rearrangement will trigger a collapse, no one can do so with perfect accuracy.
Consider this overly-simplified example.
// MathLibrary.lib
class Math {
const PI = 3.14159265; //fixed (used to be 3.0)
function add(a, b) { return a - b; }
}
// Application.lib
class FunFact {
function print() {
writeline("Pi is " + Math.PI);
}
}
If a build contains these two library files, a simple test would reveal that MathLibrary.lib is defective because the add() method is broken. However, Application.lib will test just fine, as it relies on the recently-changed PI constant, which works just fine. However, deploying only Application.lib would introduce a new problem: FunFact.print() will no longer function as it did during earlier testing, since the code for PI had not been deployed. Obviously, this would be easily spotted in this example, but imagine “crunch time” in a real application: it’s not so easy to spot subtle deployment problems, especially when the application consists of a front end website, middle-tier webservices, and a database backend.
Up to this point, I’ve avoiding using the word “promotion” altogether. But it’s a vital part of the release management process – perhaps equally as much as releases and builds.
Whereas a release identifies changes to an application and a build implements those changes, a promotion delivers the changes. More specifically, a promotion is an indication that a given build has been approved for deployment to a certain environment. This approval can require form 27B-6 to be filled out in triplicate, or it can axiomatically occur as a result of someone deciding to just go and deploy a build.
Just as a release may have many builds, a build may have several promotions. As the commonplace definition implies, promotions occur in a linear direction towards production (e.g. “integration”, “testing”, “staging”, “production”), and an environment-specific promotion can occur once per build.
It also stands to reason that a build cannot be “demoted”. If a build is determined to be inadequate for a particular stage/environment, then it will always be inadequate as builds cannot change. An inadequate build must be rejected.
While they cannot be demoted, builds are generally superseded as the result of another build’s promotion. For example, if two builds cannot share an environment (as is often the case), when Build 12 is promoted to the staging environment, Build 11 is axiomatically rejected.
It’s important that promotions are treated as a distinct concept, and not as an attribute of a build. For example, if you had a screen that represented a build, having a dropdown list called “environment” with the values “integration”, “testing”, “staging”, and “production”, is not nearly sufficient, as it does not convey when the build passed through each environment, and who was responsible for doing that.
After I explained the concepts of releases, builds, and promotions to my colleague, I could tell that something clicked. And not just because I’m a keen observer of subtle facial patterns – he actually said, “wow, that makes all kind of sense.” I had a similar reaction myself after many years of doing release management the wrong way.
I suspect there are a lot of reasons why release management is such an underdeveloped discipline – the relatively new nature of non-mainframe development for business systems, the “recent” introduction of agile practices, and the drastically decreasing cost of hardware (thereby allowing multiple testing instances for applications) – but it’s a discipline that needs more attention, especially as we move towards greater complexity and more frequent changes.
For example, something as daunting as cross-application dependencies (e.g. the MobileApprove application requires the WHS Web Services application), can be solved with a simple application of this process. When a build of a dependent application is created, simply noteing which builds of which applications it depends upon. When it comes time for deployment, it’s simply a matter of verifying that the depended-upon build has already been promoted to target environment.
Fully deploying your complete and immutable build will significantly reduce the risk of deployment-related “bugs”. And, by defining changes at the release level and using promotions, it’s no longer a question of what’s deployed where and when.
Of course, as important as it is to define the process, the process must also be followed. It doesn’t take much, and unlike other disciplines (source control, for example), you can start with nothing more than a whiteboard. Eventually, more groups– project managers, developers, analysts, network operations, executives, etc – will start to catch on and even use the terms to communicate with each other. A little bit of process will go a long way to help solve a multitude of problems and, at the end of the day, let you get back to development (or whatever it is you do).
Additional Tools - there are plenty of ways to facilitate this process, including whiteboards and a simple spreadsheet. <shameless_plug>BuildMaster, a product I’ve been working on at the day job, was also designed from the ground-up to automate and facilitate this entire process.</shameless_plug>
Only recently did I find out that you can develop negative film with instant coffee, vitamin C, and washing soda. This homebrew developer has become known as “caffenol” and there are plenty of photographers out there who have used this method in the darkroom. I read up on a few different recipes and tried my hand at developing my own snapshots with caffenol. As you can see from the video, it took a couple tries, but I did eventually get it right. As a matter of fact, I was impressed with the results:
If you’re interested in trying this out yourself and are looking for more resources, the recipe that I used is based on a how-to at Photojojo and I found a lot of great advice from the discussion forums in the Caffenol group on Flickr. There’s also a great blog dedicated to the art of processing negatives with caffenol. If you do try it out, post your favorite caffenol photos in the MAKE Flickr pool!
Subscribe to the MAKE Podcast in iTunes, download the m4v video directly, or watch it on YouTube and Vimeo.
Having lived my entire life in Minnesota, my ability to handle spicy food is lacking. Although I love it, it does not love me and the way I feel the day following a spicy meal is bad enough to make it not worth the bother.
However, I am interested in the way individual growers manipulate peppers genetically, a la Mendel, to come up with ever-more piquant peppers. (BTW: MAKE Volume 07 had a nice section in it called “Hack Your Plants.”) I have a Google alert set to alert me when new developments on the hot pepper front occur, and lately, there has been a flurry of activity.
A couple years ago, I blogged about the Bhut Jolokia, an ultra spicy pepper grown in areas of India and Pakistan. This thing is freakishly hot; it’s so high in capsaicin that it was used as elephant repellent.
But the Ghost pepper (“bhut” means ghost in Hindi) has fallen from the top, apparently. Earlier this year, Australian pepper grower Marcel de Wit unveiled a super pepper, called the Trinidad Scorpion Butch T, which tested hotter. Just two weeks ago came news reports that a Taiwanese farmer, Yeh Wu Shun, claimed his new cultivar is even hotter, scoring 1.5 million units on the Scoville scale of pepper hotness. (By comparison, a really hot jalapeno scores around 8,000 units.)
Yeh planned to debut his chilli at a chilli-eating contest in Taipei. “The person who will eat the most of this hot chilli will win my antique Jaguar,” he said.
Clever food-safe trick to make glow-in-the-blacklight Jell-O that is, nonetheless, edible. At least in theory. I have seen this trick in a couple places, but Instructables user cluracon has the best instructions and photography of the bunch. [Thanks, Chelsea!]
More:
Randy Sarafan shows you how to mod your digicam to take infrared pics, then solder up a big ol’ infrared LED light that mounts to your cameras tripod threading. Randy writes, “this special camera captures even the most difficult shots in low-to-no light photographic brilliance.”
Do you want to build some sweet projects in next-to-no time, over the weekend? Of course you do. Look no further than the new Weekend Projects section of Make: Projects, brought to you by RadioShack and The Great Create. Each week over the coming months we’ll be building clever, fun, mostly beginner-friendly, electronics projects. Using recommended parts sourced from RadioShack — along with other parts and tools you may already have in your shop or studio — we’ll be detailing projects you can build in a weekend — this weekend! We’re excited to get things rolling with this webcam-enabled microscope hack.
Within a few hours work, you’ll graft a webcam onto a microscope and be able to see, up close on your monitor, everything from microfibers in currency to trichome (hairs) on plants from your garden. This hack also allows you to utilize webcam software to capture screenshots or record video.
Sign up for the Weekend Projects Newsletter below to access the projects before anybody else does, get tips, see other makers’ builds, and more. And please email us your project build notes, images, stories, and your own mods. You may end up in a future newsletter!
Name:
Email:
Google has long been obsessed with speed. It’s paramount in pretty much everything they do. Which is why the launch of Google+ with some — gasp — attention paid to design is even more surprising. But a new service Google is launching this evening very much puts the focus back on speed — an obsessive amount of focus, one might say.
Page Speed Service is the latest tool in Google’s arsenal to help speed up the web. This service is also their most ambitious yet. When you sign up and point your site’s DNS entry to Google, they’ll enable the tool which will fetch your content from your servers, rewrite your webpages, and serve them up from Google’s own servers around the world. Yes, you read all of that correctly.
“Your users will continue to access your site just as they did before, only with faster load times,” Google notes. They say that applying web performance best practices across these pages should improve speed by 25 to 60 percent. Google will allow you to test out how much they’ll be able to speed up your site before you commit to it, apparently.
“Now you don’t have to worry about concatenating CSS, compressing images, caching, gzipping resources,” Google says. Okay, but isn’t that a little freaky, giving Google the ability to re-write and serve your pages on the fly? Perhaps. But if they really can deliver on the results they’re promising, it may be worth it.
Google says that Page Speed Service will be offered for free to a limited set of testers right now. Eventually, they will charge for it, and pricing will be “competitive”.
On the Ibuildings techPortal today there's a new post from Marcello Duarte following up on his previous post looking at behavior driven development (here) with a look at PHPSpec, a port of RSpec that is the first PHP BDD framework.
PHPSpec is the first ever PHP BDD framework. It is a port of RSpec to PHP created back in 2007 by Padraic Brady and Travis Swicegood. Development in this framework stopped for a while and was reignited last August (2010).
He goes over how to get it installed via PEAR and how to write some sample tests following along the topic from his previous post (handing videos and reviews). He gets into a bit more detail by describing how MVC is handled with PHPSpec and how the Zend Framework command line tool can be used to create a controller that satisfies the test.
Until a few years ago, there were basically two tools you could use to generate API documentation in PHP: phpDocumentor and Doxygen. phpDocumentor was long considered the standard, with Doxygen getting notice when more advanced features such as inheritance diagrams are required. However, phpDocumentor is practically unsupported at this time (though a small group of developers is working on a new version), and Doxygen has never had PHP as its primary concern. As such, a number of new projects are starting to emerge as replacements.
One of these is DocBlox. I am well aware there are several others -- and indeed, I've tried several of them. This post is not here to debate the merits or demerits of this or other solutions; the intention is to introduce you to DocBlox so that you can evaluate it yourself.
Use WiFi2HiFi to turn your iPhone into a wireless audio receiver for your stereo system or sound-dock. Combined with the desktop app WiFi2HiFi Station you can listen to whatever audio program is playing on your computer. WiFi2HiFi Station acts like an additional audio output on your computer. This allows the application to provide streaming support for all popular audio programs on the Mac and PC.
The growth of online mapping – as seen by the excellent London Mapping website, which collects some of the best digital maps around – has not meant the end of paper maps.
I’ve mentioned Herb Lester‘s lovely themed maps before with reference to their 1960s map of London’s West End, Wish You Were There, and they continue to add new maps to their range, branching into different cities and themes while maintaining an impeccable eye for design. Untamed London, for nature-lovers, is their latest offering.
I’ve also finally got my hands on the Museum of London’s Londonium map and it is hugely impressive. This has been produced by MOLAS, the Museum of London Archeological Service, and is a huge map of the City, with the Roman topography superimposed over a plan of the contemporary city – a little like a paper version of the technology used for the Time Travel Explorer app.
Key Roman finds are listed, with an explanation of what they are and how they can be accessed, while the reverse side has a potted history of Roman London, with many illustrations. The map is printed on good thick paper so won’t tear easily (a constant problem for frequently folded paper maps), and works beautifully as both a decorative item and a practical plan for hunting down the existing remains of Londonium.
It costs just £6.25 and should it prove to be a big seller – which I imagine it will – I hope the Museum can persuade their friends at MOLA to produce more maps along the same lines.
One for the Olympic Park at around this time next year, perhaps?
This run-though of some vi and Vim essentials has been doing the rounds over the last couple of days—well worth reading if you’ve taken either editor for a spin and ended up confused or frustrated (which is usually what happens when anyone tries vi/m for the first time!).
The section on the insane flexibility of copy ‘n’ paste in the two editors is particularly good—the moment I came across that stuff in Vim’s :help was the moment I stopped using other text editors.
Joris Peels and Artur Tchoukanov, both former i.materialise employees, have started Origo, a company which aims to develop a 3D printer for kids.
Artur thought, “what would a 3D printer that would work in the home look like? What if we could make it easy enough so that kids could use it? What if it could recycle its own material? What if it was affordable and easy to use? What if it would just work, all the time. What if we could start from scratch and create a true home 3D printer, a 3D printer for kids. If someone wanted to make the “first on the desktop” for every kid in the world, what would that 3D printer look like and how would it work?
The Origo is still in development, but I like what I see so far. Good luck, guys!
Harrison, with whom she shared her life for many years. In the same year appeared the book which has gained her a cult following. Lud in the Mist has been described by Neil Gaiman as ‘one of the greatest fantasy novels ever written ‘ and also a ‘reconciliation of the fantastic and the mundane’. Others have compared it to Susanna Clarke’s Jonathan Strange and Mr Norrell, and more pointedly to the work of Tolkien, who may well have been influenced by it - there are definite similarities in style and characterisation. There are themes—notably relating to how imagination is related to reality-- that resound more strongly in today’s climate than they did in Mirrlees’s own era. Its reprinting ( without the author’s consent) in 1970 introduced it to the Flower-Power generation and its popularity has slowly increased ever since. At present, copies of the novel in paperback are easy to find online at sensible prices, though no copy of the first 1926 English edition is presently on ABE. There are, however a few copies of the first American edition ranging in price from $500 to $1,200.
Sometimes we are inspired by an idea. Burrata at its best is a thin skin of mozzarella stretched over a mixture of soft chese curds and heavy cream. It is often served drizzled with extra virgin olive oil, sea salt and freshly ground pepper. Burrata is delicate with a range of textures and flavors that unfold in your mouth. It is a singular taste sensation. As we discussed ideas for dessert preparations we were talking about pudding versus custard. In particular the smooth, creamy mouthfeel of pudding and the delicate texture of perfectly baked custard cups and how to bring them together. Our solution was this banana burrata. Although meant to be a dessert course, the burrata is dressed with lemon olive oil, fleur de sel and cracked black pepper. We found that these savory accents really showcased the banana's sweet, soft intensity. Now that we have the technique we can exprapolate flavors and see what evolves next. As always please remember that the better your ingredients, the better your finished dish.
Banana Burrata
900 grams half and half
600 grams sliced banana
400 grams maple syrup
200 grams banana chips
5.2 grams salt
6.4 grams agar agar
0.7 grams locust bean gum
Put the half and half, sliced banana, maple syrup, banana chips and salt into a medium saucepot. Bring the mixture to a simmer and turn off the heat and cover the pot. Let the mixture steep for 10 minutes and then strain the mixture, discarding the solids. Transfer the banana base to a blender and turn onto low. When a vortex forms in the mixture sprinkle in the agar and the locust bean gum and blend for 15 seconds to disperse the powders. Transfer the banana mixture into a clean pot and bring to a simmer. Adjust the heat to maintain a slow boil and cook the banana mixture for 5 minutes and then pour the base into a Pyrex baking dish to cool.
Divide the banana gel into 3 equal parts. Reserve the first part in the refrigerator. Put the second part of banana base into the blender and puree until it is silky smooth. Pour it into a medium bowl. Put the third part of the banana base on a cutting board and chop into fine irregular pieces that resemble the curds of cottage cheese. Add the chopped banana puree to the bowl with the puree and mix gently with a spatula to combine. It should look like soft cottage cheese. Cut 16 10-by-10-cm pieces of plastic wrap and lay them flat on the counter. Put 2 tablespoons of the banana mixture in the center of each square. Pull the corners of the plastic up around the mixture so that it is completely encased and then twist the plastic wrap so the banana is encased in a small parcel. Use a small piece of butchers twine to tie the end of the parcel so the banana remains tightly wrapped in an oval shape. Put these parcels on a flat tray and put them in the freezer to solidify, at least 3 hours. Any left over mixed banana may be reserved with the banana gel in the refrigerator.
Remove the parcels from the freezer and remove the plastic wrap. Put them back on the tray and return them to the freezer. Put the reserved banana gel in a small, deep pot and slowly warm it up so that it becomes liquid. Keep it over a low flame and stir occasionally. When it is completely melted, remove half of the frozen banana pieces from the freezer. Have a second clean tray nearby. Use a fine metal skewer to pierce one of the the frozen banana pieces and dip it into the melted banana mixture. Completely submerge the frozen banana in the melted mixture and then pull out. A skin of banana should have formed on the outside of the frozen banana. Dip the banana again into the melted mixture to add a second layer to the exterior. Once it is out of the hot mixture, gently place the coated banana on the clean tray, carefully removing the skewer. If the skewer hole does not close when the skewer is removed, use a small spoon to apply a drop of banana over the hole and to seal the skin. Repeat this procedure with the other pieces of frozen banana and move on to the second set of frozen banana. When all the banana is dipped and coated, cover loosely with plastic wrap and place the banana burrata into the refrigerator to continue thawing overnight. When thawed, the interior will be soft and creamy while the exterior will keep the banana encased.
Years Past: