Cherry Ripe Cheesecake

IMG_20130826_194201

I’m having trouble getting good photos of my desserts… they keep being eaten! Here’s another hard-to-photograph success; Cherry Ripe Cheesecake!

Cherry Ripe Cheesecake

Makes a 25cm dia cheesecake

Base

A: 375g good-quality chocolate biscuits
B: 125g butter, melted
C: 3tbsp cocoa (for chocoholics)

Process biscuits in a food processor until very fine. Mix in cocoa.
Add melted butter and stir together.
Line a spring-form tin with paper and press the mixture into the base and sides of the tin.
TIP: Pour about 2/3rds of the mixture in, and make the sides first! Then pour the rest in and flatten out a base.
Place in the fridge to set.

 Filling

A: 200g dark chocolate
B: 4 large cherry ripe bars
C: 1 tin black cherries, drained
D: 750g cream cheese, at room temperature
E: 100g caster sugar
F: 3 eggs

Chop up chocolate and cherry ripe bars, place in a double boiler to melt.
Beat cream cheese and sugar together until smooth. Beat in eggs, one at a time.
Once chocolate has melted take it off the heat, and ensure it’s not too hot.
Beat in the chocolate mixture and cherries.
Pour the filling into the springform tin, and smooth out the top.
Bake at 180°C for 50 minutes.
Switch off the heat and prop the door very slightly ajar, let cool for 45 minutes.
Refrigerate for at least 3 hours.

Topping

A: 300g cherry jam
B: Cherry ripe bars, to decorate

Microwave jam in a heatproof bowl until liquid.
Pour evenly over cheesecake.
Chop or slice cherry ripe bars as desired, decorate top.
Place back in fridge for at least 5 minutes before serving.

IMG_20130825_153008

Almost ready to eat!

 

IMG_20130825_211133

And almost gone!

 

Eagle: Text Silkscreen Width

Thanks to Hackvana, I’m making teeny tiny circuit boards!
No matter how good a board house’s process, there are some fundamental limits to how small things a board and the design on it can be.

A PCB is much easier to understand with a silkscreen! However, you can’t draw silkscreen lines narrower than a certain width, often about 5 mils. (Or 4 mils if you’re really lucky) So you’d better make sure none of your silkscreen is smaller, or lines will be spotty and text will be unreadable.

(Huh? What’s a mil? / One thousandth of an inch. / Okay. What’s an inch? / …)

With Eagle able to display line widths in mils, it’s not too difficult to check your lines.
What about text?
(How do I get mils? / Click on the eagle_grid_button Grid button in the upper left, and change the grid units to mils. You can change it back later)

Bad Text

silk_2005

Text Settings: Size: 20, Ratio: 5%. NO.

Here is the text “ISP”, and the text attributes dialog.

  • Note that font has been set to vector. Keep your text in vector mode, it will ensure that the Gerber files you output are likely to match what you see inside Eagle.
  • The grid size in these examples has been set to 10 mils
  • There are two important settings – Size and Ratio.

Size is the height of one row of text.
Ratio is the text’s line width, as a percentage of size.

  • For the above image, the line width is 5% of 20mils – only 1mil! That definitely won’t work!
  • Remember; SIZE x RATIO > 5 mils

 But I Want Small Text!

That’s fine. You’ll just need to make it thicker.

silk_2010

Size: 20, Ratio: 10% : 2 mil thickness. NO.

Size: 20, Ratio: 20% : 4 mil thickness

Size: 20, Ratio: 20% : 4 mil thickness. NO.

These are still a bit small…

Size: 20, Ratio: 25% : 5 mil thickness

Size: 20, Ratio: 25% : 5 mil thickness. JUST…

This one is probably juuust thick enough. But the text is only half a millimetre high!

Okay, I’ll be sensible…

Good. 50 mils (1.27mm) or larger text is probably more sensible. If size is 50, and we need at least 5 mil silkscreen, then the ratio should be higher than 10%. Easy!

Size: 50, Ratio: 5% : 2.5 mil thickness. NO.

Size: 50, Ratio: 5% : 2.5 mil thickness. NO.

Size: 50, Ratio: 10% : 5 mil thickness. JUST.

Size: 50, Ratio: 10% : 5 mil thickness. JUST.

Size: 50, Ratio: 20% : 10 mil thickness. GREAT!

Size: 50, Ratio: 20% : 10 mil thickness. GREAT! And you still need reading glasses!

One more time, graphically

Width = Size x

WIDTH = SIZE x RATIO

In Conclusion

A board house will often tell you their dimension limits, for traces, isolation, and silkscreen.
For best results, avoid the limits.

If you can make your text 10 mil thick, and the board house can manage down to 5 mil, you should have no problems.

Salted Caramel Sauce

Left-over cream, what can I do with this? Cribbed a few recipes together, and improved the technique.

image

Salted Caramel Sauce

A. 500g caster sugar
B. 150mL water
C. 300ml double cream
D. 250g butter
E. 1 heaped tsp salt

  • Heat cream, butter, and salt in a small saucepan, at low heat.
  • Stir occasionally, continuing on with the recipe, and switch heat off and cover once the butter is dissolved.
  • In a heavy-based medium saucepan, heat sugar & water together until the sugar fully dissolves.
  • Increase the sugar mix’s heat to high, and bring to the boil.
  • When boiling cover the pan for 2 minutes, to allow the buildup of steam to dissolve any grains of sugar on the sides.
  • Uncover the pan, boil without stirring.
  • Watch pot carefully! When mixture reaches >170ºC and becomes golden, remove from heat. (IR thermometers are great)
  • With a long-handled spoon stir the mixture, while very slowly pouring in the cream/butter mix. The mixture will foam up a lot!
  • When all combined, put back onto medium heat, still stirring.
  • Bring mixture back to the boil for a few minutes, lifting the pan off the heat if it threatens to boil over.
  • Let cool for 10 minutes, then taste test. You might need to sample several times.
  • Pour into jars, over ice cream, cakes, whatever you like.

Salted Caramel Peanut Chocolate Tarts

Here’s my new very dangerous tart recipe.
Not for diabetics or those with heart conditions!

IMG_20130817_114856[1]

Pastry

A. 250g plain flour, sifted
B. 3tbs cocoa powder, sifted
C. 3tbs pure icing sugar, sifted
D. 165g chilled unsalted butter, chopped
E. 30ml (2 tbsp) chilled water

  • Process all ingredients except the water in a food processor until fine powder.
  • Add the water, process until combined.
  • Turn out onto floured board, knead for 1 minute, roll into a ball, cover with glad-wrap and refrigerate for 15 minutes.
  • Divide the dough into 8 portions, then for each portion;
  • Roll into a 12cm-dia circle, place into an 8cm-dia flan case, trim excess with a knife
  • Place on a tray in the freezer for 30 minutes
  • Preheat oven to 200ºC.
  • Cover the cases with baking paper and pastry weights, bake for 10 minutes.
  • Remove and bake for 5 minutes longer – should be dry to the touch.
  • Let cool completely.

Salted Peanut Caramel

A. 300g caster sugar
B. 180ml water
C. 250ml double cream
D. 120g salted peanuts, finely chopped

  • In a heavy-based saucepan, dissolve sugar & water at low heat until the sugar dissolves.
  • Set heat to high, and boil without stirring. Occasionally remove sugar crystals from the side of the pan with a wet pastry brush.
  • Watch pot carefully! When mixture reaches 160ºC and becomes deep golden, remove from heat. (IR thermometers are great)
  • With a long-handled spoon stir cream quickly into the mixture – it will foam up!
  • Put back onto medium heat. Stir for at least 2 minutes, until mixture is smooth and bubbles up again.
  • Let cool for 30 minutes.
  • Stir in peanuts.

Ganache

A. 150ml double cream
B. 150g dark chocolate, coarsely chopped

  • Chop, process or grate the chocolate into small pieces, put in a jug.
  • Heat the cream (but do not boil), then tip into the jug.
  • Stir with a spoon until the chocolate is combined, then mix with a stick blender until smooth.

Putting it all together

  • Pour caramel into each case, leaving room for the chocolate layer, tilt cases to spread caramel
  • Put back in freezer for 5-10 minutes
  • Pour ganache into each case, tilting to ensure coverage.
  • Place a few flecks of sea salt in the centre of each tart.
  • Chill until served.

The tarts will be very rich. Serve with cream or ice-cream.

Atmel Studio: Clearing debugWIRE

debugWIRE is a fantastic bit of technology in many recent AVR chips, allowing you to set breakpoints, step through your code, and a bunch of other useful features. All you need is a programmer that supports it – the AVR Dragon for instance.

In the Atmel Studio project, simply set the Debugger/Programmer Interface to debugWIRE.

The only fly in the ointment is that for extremely low-power applications, having the DWEN fuse and thus debugWIRE enabled will prevent the chip from fully sleeping, meaning your device is much more thirsty than expected.

So you set the Debugger/Programmer Interface back to ISP, and try to program your device again; Failure! In fact; CRYPTIC ERROR MESSAGE!

TO CLEAR debugWIRE FROM A CHIP WITHIN Atmel Studio 6:
Start a debug session on the chip, then
Go to the “Debug” menu and select “Disable debugWIRE and close”.

Now you can access the chip using ordinary ISP, and low-power devices will be more frugal.

This may seem an obvious thing, but there are a number of “solutions” floating around, including people advocating hooking HVPP programmers into devices simply to clear DWEN!

More Javascript Templates Using ‘src’

There was some concern about my previous solution, that it loads templates synchronously and serially. An application should have templates inlined before it goes to production anyway.

Fair point though, there is a better way.

Better Definition

Firstly; Marionette.js can transparently lazy-load and cache DOM-stored templates;

//What I had been doing
var MyView1 = Marionette.ItemView.extend({
	template: _.template( $("#template_myview1").html() )
});

//What I should have been doing
var MyView2 = Marionette.ItemView.extend({
	template: "#template_myview2"
});

The difference between the two is significant.

  • MyView1 will access the DOM as soon as the class is defined, and build the template immediately.
  • MyView2 will access the DOM only when a MyView2 instance is constructed, but only builds the template once.

This means the templates are only built at the time they are first used. The template blocks don’t need to be accessible at the time the classes are defined. The app only needs to build the template functions the first time they are used.

Using the MyView2 style will give much faster start-up times for larger applications.

(Marionette.TemplateCache can be used stand-alone, or you can fairly easily create your own caching DOM template loader)

Better Loading

Now, the template blocks won’t be referenced until they are used. We can load them asynchronously now, but we still don’t want to start the app until the templates have been fetched. $.ready(…) won’t wait for the templates, but there’s a fairly easy workaround;

//A list of promises that need to resolve before starting
var loaded = [];

//Load all templates
var $templates = $('script[type="text/template"]');
$templates.each(function() {
	var src = $(this).attr("src");
	if (src) {
		loaded.push( //Wait for the template to load
			$.ajax(src, {context:this}).
			done(function(data) {
				$(this).html(data);
			})
		);
	}
});

//Wait for the DOM to be ready
loaded.push($.ready);

//Initialise after everything is loaded
$.when.apply($,loaded).done(function() {
	//Start application
});

There! With that in place;

  • Templates are loaded into script blocks as you’d expect, asynchronously and in parallel.
  • The application starts after the DOM and the templates are loaded.
  • For production, the templates are inlined. Without any code changes, the application will transparently start as soon as $.ready is completed.

Javascript Templates Using ‘src’

Background

John Resig was the first to document a technique for storing templates in <script> tags;

<script type="text/html" id="item_template">
   <li><b>{{ name }}</b> - {{ description }}</li>
</script>

This works well for several reasons;

  1. Using the unknown type “text/html” means that the browser ignores it.
  2. Giving the tag an id allows us to easily grab its contents;
//Build a new item, and add it to the list
//Using JQuery, Underscore.js
var contents = _.template(
  $("#item_template").html(),
  {name: "Foo", description:"Sir Foo the Second"}
);
$list.append( $(contents) );

Today there are many libraries available for retrieving and building templates in this way, such as Mustache.js and ICanHaz.js, and more that integrate support.

Problem

One of the only problems with this technique, is that the scripts must be declared inline.

<!-- Works! -->
<script type="text/html" id="item_template">
   <li><b>{{ name }}</b> - {{ description }}</li>
</script>

<!-- Doesn't work. -->
<script type="text/html" id="item_template2" 
                  src="templates/item2.html"></script>

If the browser doesn’t understand the type, it won’t load the source. Whatever the reason, the template text is never added to the DOM.

Inlining template contents is detrimental to readability, maintainability, and traceability.

Some libraries offer asynchronous methods for loading templates. (require.js among them) Some have issues with complexity and performance.

It feels natural to define and compile the template functions at class definition time. Other solutions may add unnecessary layers of indirection.

Solution

I’ll preface this by saying “Okay, maybe this won’t work for you”, but so far it’s working well, transparently, and fast. And when you go to production, a decent deployment optimisation process will inline the templates anyway.

What if the src attributes were read properly?

<script type="text/html" id="template_widgets"
                    src="templates/widgets.html"></script>
<script type="text/html" id="template_widgets_item 
                    src="templates/widgets_item.html"></script>
...
...
<script type="text/javascript">
  //Synchronously load the templates
  var $templates = $('script[type="text/html"]');
  $templates.each(function() { 
    //Only get non-inline templates
    //No need to change code for production.
    if ($(this).attr("src")) { 
      $.ajax(
        $(this).attr("src"), 
        {
          async:false, 
          context:this, 
          success:function(data) { $(this).html(data); }
        }
      );
    }
  });
  //From this point onwards (in the same script, in the 
  //following scripts) all the "text/html" script tags 
  //will be loaded as if they were inline.
</script>

Just insert this code after all your template tags, and before you build your template functions, and you’ll be able to treat them as if they were inline all along.

Easy.* 🙂

*There are some downsides to loading template serially and synchronously. I’ve written a follow-up article that discusses a technically better solution.

Finished: Display Case Doors

IKEA, your ‘professional assembly service’ sucks. My grandmother’s display case doors have scraped since the day it was installed, and the repeated twisting caused the glue to fail on one of them.

  • Glued back together the broken door.
  • Planed a few millimetres off the bottom of both doors.
  • Smooth, silent doors that no longer stick.
  • Happy grandmother!