Raspberry swirl cheesecake cupcakes

I volunteered to bring some baked goodies for a rowing event earlier this year, and for some reason I decided that I would really like to bring something that looks nice. Some bits of Googling later, I came across a lovely recipe for cheesecake cupcakes with raspberry swirls at Annie’s Eats. These not only look amazing: they taste amazing. You get all the joys of cheesecake in a nice, manageable quantity. And cupcakes are much easier to make than ordinary (big) cheesecake. In short: make this recipe.

Aren't they adorable?
Aren’t they adorable?

Cheesecake is quite forgiving, as long as you’re gentle with it. I didn’t need as much cheesecake as the original recipe, and I found it was a little tricky to find cream cheese in the particular quantity I needed, so I modified the original recipe for my purposes. A few weekends ago I did it again with the same tweaks and it worked out wonderfully, so I thought I would share.

My recipe makes about two thirds of the original, so it will give you a little over two dozen cupcakes. I added some cottage cheese, and I’m using “medium” cupcake cups, which are 2.5″ in diameter at the top and a little under 1″ tall.

Those extra raspberries in the photo provide scale, and deliciousness. I don’t mention them in the recipe, but I’m sure you know what to do. I’m sticking with the raspberry swirl here, but I should mention it’s really easy to make a few different toppings and mix them in as well. I’ve listed some I have tried at the bottom.

Fair warning: I am not an experienced chef, which is why my website is about software and not cooking. But, hey, it worked for me! (And of course, the recipe at Annie’s Eats is bound to work perfectly. It’s tried and tested and very well photographed).

Ingredients

For the crust

  • 1 ½ cups graham cracker crumbs
  • 4 tbsp unsalted butter, melted
  • 3 tbsp sugar

For the filling

  • 500 grams reduced fat cream cheese, at room temperature (use blocks of cream cheese if you can)
  • 100 grams cottage cheese (try to squish it a little and drain some of the liquid)
  • 1 cup sugar
  • pinch of salt
  • ⅔ tsp vanilla extract
  • 3 large eggs, at room temperature

For the raspberry swirl

  • ¾ cup raspberries (fresh or frozen)
  • 2 tbsp sugar

Directions

  1. Preheat the oven to bake at 325° F, and line some muffin tins with cupcake liners. If you have a lot of empty spaces in the tin, fill one of those spaces with a bit of water. You may need to come back to this step a few times (depending on how many muffin tins you have), and that’s okay.
  2. In a large bowl, stir together the graham cracker crumbs, 3 tbsp sugar and melted butter until they are well combined and moistened.
  3. Press up to 1 tbsp graham cracker filling into each cupcake liner, and push it down. This isn’t exact, of course, but your crust should be even, and about 5 mm thick. Bake these until the crust is set – about 5 minutes – then set aside to cool. Leave the cupcake liners, with the crusts, in the tin: you’ll be using it again very soon.
  4. Meanwhile, put the raspberries in a blender, and blend until they are smooth. Run the purée through a fine strainer to remove the seeds, then stir in the 2 tbsp sugar.
  5. Using a stand mixer on medium speed, beat the cream cheese and the cottage cheese until it is light and fluffy. Blend in the 1 cup sugar until the mixture is smooth. Mix in the salt and vanilla. Add the eggs, one at a time, mixing well after each addition. Pour 2-3 tbsp of the cheesecake filling into each cupcake liner, on top of the graham cracker crust. (You might want to add a little more or less depending on your cupcake liners. Keep an eye on them in the oven and you’ll be fine).
  6. For each cupcake, dot ⅓ tsp of the raspberry purée in a few dots on top of the cheesecake filling. Then, using a toothpick or a chopstick, swirl the purée to create a marbled effect.
  7. Bake the cupcakes until the filling is set; about 22 minutes. Transfer them to a cooling rack until they have cooled to room temperature, then transfer them to the refrigerator for 4 hours. The cupcakes will be quite puffy when you remove them from the oven, but they’ll settle back down once they have cooled. Be extra careful with them until that happens, though.
    • Now is a good time to plop on some decorations, if you were planning to. Once your cupcakes have settled a little, lightly push a fresh raspberry onto each one, or maybe sprinkle some chocolate flakes on top. You can do that later, too, but once the cupcakes cool you’ll need to find other means to make things stick.

Just try not to eat them all yourself, and you’re done. Good luck!


Some extra toppings you could try…

The original recipe calls for raspberry swirls, and that works beautifully. But you might like to try something else, too. Chocolate sauce and blueberry sauce have worked well for me. It’s hard to be exact, so be prepared for some leftovers. Careful, though: the raspberry purée is quite light, but the others aren’t always like that. If your topping seems to sink into the cheesecake filling, make sure you spread it out lightly. If you leave a particularly heavy dot, it could punch a hole in your cupcake.

I was meaning to try orange sauce, too. If you do, I’d love to know how it goes.

Blueberry

  • 1 cup blueberries (fresh or frozen)
  • 2 tbsp sugar
  • ½ tbsp cornstarch
  • ½ tbsp lemon juice

Combine all the ingredients in a saucepan and cook over low heat, mashing the blueberries slightly, for about five minutes. Once the sauce has reduced and slightly thickened, remove it from the heat and allow it to cool slightly. Use just the liquid part with your cheesecake. You can save the blueberry bits to sprinkle over the cupcakes. Or you can eat them, because blueberries are delicious.

Chocolate

This sauce is quite thick, so you won't need very much
The chocolate sauce is quite thick, so you won’t need very much
  • ⅔ cup cocoa
  • 1 ½ cup white sugar
  • 1 ⅓ cup water
  • 1 tsp vanilla extract

Combine the first three ingredients in a saucepan over medium heat. Bring to a boil and let it boil for 1 minute. Remove from the heat and stir in vanilla. Allow the sauce to cool before adding it to the cheesecake.

The flakes in the photo are from a block of white cooking chocolate and a lemon zester. Just add them when the cupcakes come out of the oven and they should stick nicely.

GNOME Break Timer: Final report

Well, it’s September, so I guess it’s time to call it quits with that whole “summer” thing. This has been a really nice few months. I’m very grateful that I could participate in Google Summer of Code this year with my project to build a shiny new Break Timer application for GNOME 3.

This was meant to be a picture of Fall's first day of torrential wind and rain, but the rain stopped as soon as I went outside and this is all I got. Stupid rain.
This was meant to be a picture of Fall’s first day of torrential wind and rain, but the rain stopped as soon as I went outside and this is all I got. Stupid rain.

So, where am I leaving you? With GNOME Break Timer 1.1, of course! (And I’m not leaving). I think my project over the summer has been successful. At times I have had the unmistakeable feeling that I was trying to spread too little butter over too much bread, but we always found something interesting to work on (including a nifty and GNOMEy side project that I’ll talk about really soon, but mostly on Break Timer itself) and I think we have some good quality code as a result — and a lovely little application, too!

GNOME Break Timer 1.1

Well, it has an About dialog
Well, it has an About dialog

Don’t worry, that icon is a quick placeholder, and I realize it looks confusingly similar to either a normal clock, a speaker or a power button. If you feel strongly about it, I will be eternally grateful if you check out the art request for a new icon.

Here’s what I did this summer, in summary…

  • Cleaned up a lot of old code, fixing bugs and removing oodles of unwanted complexity.
  • Adopted a “normal” build system and fought off my intense fear of Automake. (I now simply dislike Automake. That feels like progress).
  • Made a cute little application to get started with Break Timer, view the current break status, and set a break schedule. I think it’s pretty cool.
  • Improved the activity tracking code so it’ll be way easier to adapt to changes in the input stack. I still need to take a close look at how this will work under Wayland, but I’m less worried, at least.
  • Polished up the “take a break” notifications and added automatic screen locking, as well as better awareness of the system in general.
  • Implemented really awesome state saving between sessions.
  • Investigated per-application defaults for notification appearance. (Didn’t go brilliantly, but I’m going to try again. More on that later).
  • Wrote lots of tests. I didn’t get to write any UI tests, and I was hoping to find out about testing timeouts and timers but I’ll need to save that for another day. Probably a rainy one. Still, it should be very hard for someone to (unknowingly) break any of the more fiddly parts of the application. I’m sure that will pay off in the long run.
  • Learned all about GObject, Vala, Cairo, unit tests, GNOME, and wonderful new things in GTK!
  • And I wrote a blog post for each of those things.

All sorts of people have helped me with my project over the summer. Thanks, Jasper and Allan for being so patient with me :) And thanks, GNOME! You folks are all brilliant. I’m definitely going to keep going with this project and I’m excited to work with you all in the future.

I typed this standing up

Almost five months ago, I switched to a standing desk. I am in love.

Yes, it is absolutely sane to be in love with a desk.

We made a standing desk out of processed trees. The result is modest, but I'm happy with it! Dads are great.
We made a standing desk out of processed trees. The result is modest, but I’m happy with it! Dads are great.

The idea with a standing desk is your body stays more active while you are at your desk, so you can read those health warnings about sitting all day with a sense of superiority. And we all like to feel superior. But I didn’t just switch to a standing desk because of how everything is killing us. I had a few reasons of my own! When I sit, I end up sitting wrong within minutes. This is a problem, because my choice of obsession (and profession) means I am doomed to a lot of fooling around with computers. For a long time, I assumed that doom required equal amounts of sitting. During my little internship at the David Suzuki Foundation, one of my awesome coworkers was thrilled with her standing desk, so that finally got the wheels turning for me.

Meanwhile, I was noticing that I never really solve much while I’m sitting at a desk. My brain works a lot better when I’m at least moving. The problem is my work environment wasn’t really made for moving around. There was a giant, allegedly comfortable chair in the way. I say “allegedly comfortable” because this is one of the other neat things. I considered actually buying an actually comfortable chair, then I realized I could change my desk, instead. Hundreds of dollars in savings, I thought.

Didn’t turn out that way, but it was still worth it.

I started off looking at different articles around the web for inspiration. Jorge Castro wrote a nice blog post about his own adventure building a standing desk on top of a metal frame, and Priceonomics has suggestions for cobbling together a standing desk from Ikea stuff. I momentarily entertained the idea of buying from Geekdesk, but, besides the price, I decided I would prefer to jump in head first with something that is not adjustable to sitting. If I make it easy to go back, I probably will.

So, I was looking at different bits of Ikea furniture that I could somehow jam together into something coherent, and soon enough my dad talked me out of all that. Instead, we (mostly he) built a new desk frame from scratch. This way we could get something at the right height from the start. After all, you don’t want to stand at an uncomfortable desk, and unlike sitting on a fancy chair, you can’t really adjust your standing height. There’s a sort of general guideline that the desk should be at a height where you can look straight ahead with your elbows at a 90° angle, and we ended up with something pretty close to that for me.

As might be expected, it looks slightly more flattering from the top.
As might be expected, it looks slightly more flattering from the top.

As well as the desk, I have collected some standing desk paraphernalia. After about two weeks I got a new, cheap office chair that adjusts almost as high as the desk. I haven’t used the chair as much as I expected — I can remember maybe eight specific occasions — but it is great for those long sessions of Crusader Kings 2. (Its height even resembles a throne, and it terrifies me. As it turns out, I would make a terrible king). Just last month I got a brand new anti-fatigue mat, which is under my rug in the photo. It’s an Imprint Comfort Mat, which has a durable surface and some sort of memory foam cushioning. It feels a lot like wearing a good pair of shoes. I got along fine without it for the weeks before, but I can see why that extra stress on the feet can make a big difference for some people, and I’m glad I have something for them now.

Speaking of gadgets, I quickly began to appreciate long cables. My headphones have an unusually long cord, and that used to bother me, but now that I’m a few feet higher and I like to wander away from my desk, the extra length is indispensable. Cables have been a problem in other spots, though. Many of them, like my video cable, are only just long enough. As it is, I can’t do much to hide them from view. They just reach to the top in the quickest possible way, which of course involves a giant knot. I really should hunt for some new cables, but at this stage it seems almost insurmountable. It makes me wish I had chosen differently every time I thought “I don’t need a longer cable — it just needs to reach around my desk.” So, uh, there’s my helpful advice.

Not actually the view out my window, but close enough.
Not actually the view out my window, but close enough.

My favourite thing with this standing desk is what it means for taking a break. Sitting down almost feels like a worthwhile, and entirely justified, change of pace, which is very refreshing. I still have my perpetually unfinished home-made “take a break” app running, and I have an easier time prying myself away from my computer when a micro break or a rest break comes along. I’m always one step closer to it, after all. Also, I think I’m biting my nails less! Weird, but exciting.

As for the standing part, it definitely took time to adjust. For the first few weeks, I had a weird habit of standing completely still at my desk. I guess that’s because I was so used to sitting still at my desk, but my feet didn’t thank me for it. As I have become used to the idea, I’m prone to stretch and move around more, so my feet aren’t being pressured in one way for the whole time. At this point, I definitely find it easier to walk around and look out a window when I’m pondering something. I haven’t decided if that really helps me to think, but at least it seems healthier. The bottom line is I feel more free when I’m doing computer stuff, and that’s really cool.

So, add me to the standing desk fan club, please! I don’t think I will be going back.

My new website uses WordPress and Smarty

Spurred on by the rather dull situation of my web dev portfolio being a single long page with pictures and writing on it (which simply will not do!), I spent the last week moving my blog (and my portfolio) to my own webspace with WordPress and a custom theme. This entailed re-learning PHP (ugh), learning more about WordPress, and pulling a lot of hair. And the whole thing is still a work in progress, but it’s here, and it’s better than my old blog. Yay!

WordPress has worked really well for me, so far. It has a really good post editor that doesn’t spew broken HTML all over my posts when I look at them wrong, the SQLite plugin works (for when I was testing locally), installing it was simple, and it has reasonably detailed documentation, most of the time.

But there is one place where WordPress and I simply cannot agree, and that is writing themes. My new site has a fancy header that picks up rows as you go from page to page. My attempt to create reasonable semantics for that under a typical WordPress theme was completely fruitless. The convention in WordPress is to write a theme in straight PHP, using stuff like the_content() to print the selected post’s content directly. Coming from Django, I was not a fan.

What I wanted was a good template engine, like Django’s. I wanted it to support inheritance, so I could have a base page and override specific parts of that base page in each subpage. I wanted the ability to use the same template for different back-ends without too much turmoil. I wanted to stick variables in page content without generating incomprehensible giberish, and I would prefer to separate logic from presentation at least a little. There is just a thing for PHP: Smarty! Now, some searching for Smarty support in WordPress led me to a lot of requests and no real implementations (or attempts), so that’s why I’m here. This site passes through Smarty for just about everything, and I probably didn’t do it right but at least for a small site this method seems to work. (And I’ll keep this post updated if it doesn’t). I’m going to write (or at least brain dump) some tips for those who are looking to do something similar. I am assuming, if you’re interested, that you have some idea how Smarty works and some idea how WordPress works, but not much of an idea is necessary.

This probably isn’t terribly efficient, though it’s worth noting that Smarty is normal PHP code once each template is run for the first time, so at least to me it intuitively felt more expensive than it ended up.

First, you need a custom WordPress theme that acts as an adapter to Smarty, because Smarty can’t talk to WordPress directly. (It can’t call functions). Unfortunately my WordPress theme was made in a big hurry so it isn’t reusable. (A clever person could do better – maybe something like the Sandbox theme). Coming from Django, I decided I would think of WordPress’s template files like Django’s views; the things that go between an HTTP request and the (Smarty) template system. Look through WordPress’s Template Files List. In each of those, instead of displaying something directly we’re going to gather data and send it over to Smarty.

You’ll need to add some stuff to functions.php. First, load the Smarty library (require('includes/Smarty.class.php')). Then we have a Smarty subclass that can be used for the project:

class Smarty_Base extends Smarty {
	function __construct() {
		parent::__construct();

		$basedir = get_theme_root().'/'.get_template();

		$this->setTemplateDir($basedir.'/smarty/templates');
		$this->setCompileDir($basedir.'/smarty/templates_c');
		$this->setCacheDir($basedir.'/smarty/cache');
		$this->setConfigDir($basedir.'/smarty/configs');

		//$this->caching = Smarty::CACHING_LIFETIME_CURRENT;

		//** un-comment the following line to show the debug console
		//$this->debugging = true;
	}
}

I added another subclass that would guarantee some variables be sent to every template. The most important ones here are wp_head and wp_footer, which are popular points for plugins to attach themselves.

class Smarty_Wordpress extends Smarty_Base {
	function __construct() {
		parent::__construct();

		$wptitle = wp_title(' | ', false, 'right');
		if ($wptitle) {
			$this->assign('page_title', sprintf("%s %s", $wptitle, get_bloginfo('name')));
		} else {
			$this->assign('page_title', sprintf("%s", get_bloginfo('name')));
		}

		$this->assign('resource', get_stylesheet_directory_uri().'/resource');

		/* get wp_head */
		ob_start();
		wp_head();
		$this->assign('wp_head', ob_get_contents());
		ob_end_clean();

		/* get wp_footer */
		ob_start();
		wp_footer();
		$this->assign('wp_footer', ob_get_contents());
		ob_end_clean();
	}
}

So, WordPress (bless its heart) doesn’t have a get_wp_head function; it will only print the head directly. We can work around that using PHP’s output buffering functions, which are those blocks of code with ob_start and ob_get_contents. Again, not pretty, but this solves our problem: now the template can choose when and where to stick wp_head and wp_footer. You’ll be using this a lot, actually.

From here, getting Smarty to render my pages has been as simple as making Smarty templates and running them (with the right values) from the appropriate WordPress template files. Because Smarty templates inherit from each other, don’t be afraid to add helper functions since you might have all of your pages sending the same variables to templates because they inherit from the same base.

For example, I added a function that is called for any template inside my blog section:

function prepare_smarty_for_blog($smarty) {
	$smarty->assign('page_number', get_query_var('paged'));
	$smarty->assign('next_posts_link', get_next_posts_link("Older posts"));
	$smarty->assign('previous_posts_link', get_previous_posts_link("Newer posts"));
	$smarty->assign('blog_sidebar_html', get_sidebar_html('blog-sidebar'));
}

By the way, get_sidebar_html is to do any collection of widgets. Just like wp_head and wp_footer, we need to use output buffering because widgets output their contents directly when asked. Otherwise, it’s a pretty ordinary sidebar that we can freely customize from the admin page:

function register_sidebars() {
	register_sidebar(array(
		'id' => 'blog-sidebar',
		'name' => 'Blog sidebar',
	));
}
add_action( 'widgets_init', 'register_sidebars' );
function get_sidebar_html($index) {
	$sidebar_html;
	/* get sidebar contents */
	ob_start();
	if ( dynamic_sidebar($index) ) {
		$sidebar_html = ob_get_contents();
	}
	ob_end_clean();
	return $sidebar_html;
}

In the end, the WordPress template for a post page (single.php) looks something like this:

<?php
/**
 * The Template for displaying all single posts.
 */

$smarty = new Smarty_Wordpress();

$post_id = get_the_id();
$post_full = new PostContent($post_id);
$smarty->assign('post', $post_full);

prepare_smarty_for_blog($smarty);

$smarty->display('blog-post.tpl');

?>

And here is the Smarty template blog-post.tpl:

{extends file="base-blog.tpl"}

{block name=main}
	<div id="post-{$post->id}" {$post->class_html}>
		{if $post->blog_import_url}
		<div class="post-message">This post was imported from my old blog at {$post->blog_import_url}</div>
		{/if}

		<div class="post-main writing expanded">
			{$post->content_html}
		</div>

		<div class="comments-wrapper">
			{$post->comments_html}
		</div>
	</div>
{/block}

Isn’t that tidy?

PostContent is just a little object that grabs bits of information for the selected post and stores it all in readily accessible variables intended for Smarty. Alternatively, you can just fill up an associative array or a dictionary and send that to Smarty. The object was useful for me because I like to needlessly add objects to things, and because I could reuse code between lists of posts and actual posts. It’s pretty simple (and pretty site-specific), but one thing that may jump at you using this approach is lots of WordPress functions know what “the_post” is based on a global variable — $post. Since we are doing so much stuff outside the ordinary flow of a WordPress theme, changing the global variable can cause some problems. So, I tend to do something like this:

global $post;
$old_post = $post;
$post = get_post($post_id);

/* do stuff with the post, like get_the_excerpt() */

$post = $old_post;

Whether you find yourself in that position seems to depend on who you are. I found my code reading post IDs and wanting to immediately delegate processing said IDs to something else. Somebody else might run get_post from a higher point, in which case that global variable silliness is completely unnecessary.

Another more common thing to keep in mind is that WordPress likes to generate strings with HTML for us right away, and sometimes we can’t change them very easily. (And usually that’s a good thing. It’s pretty cool how it will generate a comment form or a post password form and magically process it for us, and it generally just saves time and makes your theme more flexible). To make this a little tidier, I like to add _html to the end of variable names that point to HTML content, instead of fighting a losing battle and making WordPress less cool :)

And that’s pretty well it. There is still lots of boilerplate, but I find it much more readable than a lot of WordPress themes out there. Smarty’s template inheritance is really the main thing I wanted and it works beautifully. In short, you can use Smarty with WordPress, barring some limitations. If you (like me) have been convinced that dedicated template languages are the solution to everything, it could even be worthwhile!

June, 2013

I have been iterating on my theme, recently. I added some responsive design bits and pieces, I changed the layout for sidebars and footers and things, I set a maximum width for the content, and I made comments look a little prettier. This involved a lot of CSS, but it also involved a lot of changes to markup in order to support that CSS. I noticed something interesting: the last modified date for all of my PHP files except comments.php and functions.php is April 2012. I had to modify comments.php because I still haven’t gathered up the courage to sort out that mess and move that template to Smarty, and the only recent change for functions.php was registering a new sidebar. So, as a person who hates PHP, I think this was pretty cool.

The borders: Cut them all down!! (Mockup)

I keep babbling about how ugly I think Appearance Preferences is, so I played with GIMP just now and made a couple of mockups.
I’m hoping to stay grounded in reality here.

First: the problem!

This here is the status quo in Gnome. The problem is not limited to Appearance Preferences, but it’s easy to demonstrate with it. I’m just going to focus on the Background section, too, but what I’m doing can be applied to the others. Let’s say I right clicked on my desktop and innocently selected “Change Desktop Background.”

The thing that immediately deserves a significant chunk of ire is that empty white patch to the right of the icon view. Were the window a few pixels wider, it wouldn’t be there. As it is, this gives us a 3×3 grid of tiny icons, with more space between the icons than the icons themselves, from which we need to choose a background picture. And that breaks one of my rules: Never, ever expect your user to resize a window.
We aren’t going to make the window wider, but we are going to fix that problem.

The next issue is visible by scanning across the window. I go through three heavy lines: the window border, the tab bar, and the frame around the icon view, before I get to the meat of this thing. That is three layers; three sections of the interface.
If this was a printed document, the icon view would be a subsection.
But what is this interface’s main objective? Choosing your background picture! Doesn’t that seem a little bit crazy?

My first mockup is getting rid of that excess border between the tab bar and the icon view…

This highlights a particular habit Gnome apps have, especially when they follow today’s HIG.  (And, as you might have guessed, I disagree with this habit). They add padding, padding, padding. They are obsessed with padding. Every container has 12 pixels of padding on every side.

Of course, I like padding, too. I want things to use padding. If everyone used padding and margins, maybe themes wouldn’t be using so many lines! (The other thing that makes me crazy, but it turns out these go together in our case. Note that one strangely thick border is now gone. I did cheat a bit by making it a 1px border instead of a 3px border, but as far as I can tell that’s a theme thing).

Unfortunately, padding is being used robotically to fill an arbitrary requirement. Everything uses the exact same amount of padding around every element regardless of what that element means. The result is a tangle. (See above).
I propose a slightly more organic approach: “Padding should be in multiples of x, never less than y pixels and never more than z pixels. In general, no control should reach within w pixels of a window’s edge or a heavy border.”

There is another problem here: if a container creates a heavy border, it is redundant to give the next container inside it a heavy border as well. Besides, having a sudden contrast between two halves of a double border defeats the purpose; it adds noise right in the middle of the attempt to create a clean surface. That can happen if one follows a mathematical guide to padding.

At this point the mockup is attainable with GTK as it is right now. However, I think I only applied my solution half-way. The icon view still has its own spacing around each icon. (Conveniently enough, it is precisely the same as the padding within a toplevel container: 12px). Here’s my attempt with that:

This one would need a few small changes in GTK, in themes and in philosophy.

The first thing is this interface stacks vertically, and only vertically. Trying to differentiate empty space from another element’s empty space going horizontally was a fruitless exercise, so this stops trying to do that.

If you draw a line down the left side, you will notice that the edge of the left-most icon in the icon view, the Style label and the Help button are all aligned. However, instead of a single Alignment, I’m adjusting each element on an individual basis to align based on its content.

As well, the buttons part of the Notebook widget would need a settable left margin. Quite attainable, really! There’s precedent in any web browser where the content spans to the edge of the screen. (MacOS’s design is interesting, too. Over there, a tab bar at the top of a window is styled a bit differently than one somewhere else).

I’m cheating a little by assuming that the theme will use a different background colour inside a frame or a notebook container. That is the case with Clearlooks or Elementary, for example. By varying the background colour, we can strongly communicate that the tabs at the top affect a particular thing without wasting 45,156px² of screen space on layers of margins and borders.

W3C: BoycottNovell is invalid

Out of curiosity for just how nasty BoycottNovell is from a web design standpoint, I ran the W3C validator on one of his article permalinks. (Direct link removed to spare those kind souls unneeded bandwidth consumption).

Here is the aftermath:

Clearly, Roy Schestowitz is a secret Microsoft employee. Through his web site, he spreads the use of Microsoft’s broken version of the web with completely invalid HTML. With this number of errors, it could only possibly be malicious. This is all part of an evil scheme to destroy peace and freedom.

Here is another damning piece of evidence straight from the page source:

<!–[if IE]><style type=”text/css”>.ratemulti .starsbar .gdcurrent { -ms-filter:”progid:DXImageTransform.Microsoft.Alpha(Opacity=70)”; filter: alpha(opacity=70); }</style><![endif]–>

Yep, that’s right. Not only does Roy’s web site not validate, it contains exclusive design elements that only Internet Explorer users can see, which are probably patented to boot! Only those users of non-free Microsoft software are permitted the full design experience. This, while modern, non-Legacy browsers that most people prefer are more than capable of alpha transparency on elements, even with rgba colouring.

We must put an end to this by researching Internet Explorer shills like Roy. We should also boycott all web browsers that can render his rag. By promoting such error-ridden design, they are helping Microsoft, a convicted monopolist.
Yes, I’m looking at you, Mozilla. You have just moved WAY DOWN on my credibility index.