hRecipe – Semantic Recipes for WordPress (Google loves these)

(Reading time: 8 – 12 minutes)

I have an agenda, and this is definitely tipping my hand a bit early, but the iron is hot, so…

It’s time to strike!

There’s something simmering away out there on the web which you’re going to need to know something about Real Soon Now. Because if you don’t, the people that do know about it are going to clean your clock on search results. And if you have any hope of semi-passive income, search results matter.

What is it?

Semantic web.

I’ve been working off and on for about a year on a little plugin that implements semantic styling for recipes. You can find it in the WordPress plugin repository. Just search on “hRecipe” in your WordPress plugin interface, it comes right up.

Last night (April 20, 2010) I checked up on Zarela Martinez, who was testing hRecipe plugin for WordPress, and thanked her for checking it out. She replied that she found it hard to use:

Dear Dave:

I’m trying it out but actually it is very hard to use. It requires lots of cut and pasting plus when you post the recipe all the ingredients and procedures run together and I have to separate them one by one. Also it should ask what category it is so one can save it right there without an extra step.

I’m sorry but I write cookbooks and this is not user friendly.

Thanks,

Zarela

Now that’s great feedback!

I agree, hRecipe isn’t that easy to use. My reply: “If you would recommend just one single thing that would make it more helpful for you, I’ll see about implementing that into the next release.”

Whence:

If you tell me why it is difficult I may be able to make suggestions. Right off the top of my head I think it should be a regular post without the sections and one could put in the separator like you do when you are writing a regular recipe for an article or book.

Here’s an expanded version of my email reply as today’s blog post.

Wow!

Most people don’t care at all about the details. But the details are important. Like cooking, little things can make a big difference.

There are two main issues to consider when displaying semantic recipes:

1. Recipe display, which is the easiest, that can be handled with CSS styling.
2. Recipe data entry, which is getting the recipe into the computer. This is “rope through a hole problem.” The difficulty is the same, it’s just who bears the brunt of the work. When it’s easy on the user, it’s really hard to program. Conversely, being easy to program usually involves conventions most users are not familiar with.

Let’s start with recipe display, the CSS.

No, actually, let’s give you a chance to jump right to hRecipe ingredients formatting.

If you’re still with me, then, here’s what’s involved.

Displaying semantic recipes

CSS stands for Cascading Style Sheets. It turns out that when “wrap” your recipe with CSS indicating it’s a “recipe class,” everything inside is treated as part of the recipe. There’s two reasons this is important:

1. CSS let’s you choose a “style” that will render all your recipes exactly the same.
2. Google (and other search engines) are evolving to understand this kind of CSS, which is known as a “microformat,” which defines what is known as the “semantic web.” More simply put, the hrecipe CSS gets you better search ranking. Since you’re putting your recipes on the web anyway, a little extra effort that you do helps.

(MS Word doesn’t have this kind of capability built into it as far as I understand)

Ok, so much for now about CSS.

Entering semantic recipe data

Data entry is obnoxious, for everyone. Programmers, users, business owners, everyone.

In hRecipe, each part of the recipe needs to be classified according to it’s function. Further, some parts of recipes have lists: lists of ingredients, lists of preparation and cooking instructions. These lists can have an arbitrary number of items in them, and each item in the list can be very short or very long. Furthermore, each item in the list has it’s parts. “1 cup of flour” is 3 things. It’s a measure (1), a unit (cup) and the ingredient (flour).

The hrecipe microformat provides for designating each part of an ingredient list. The hRecipe plugin has not yet implemented this… it’s not a difficult problem per se, but there are a lot of “edge cases,” exceptions which make programmers stab their eyes out and users think “programmers are too smart for their own good.”

For example, translation on the user end is pretty simple. But how to deal with translation on the programming side?

And it’s important on the programming side for… parsing.

Let’s examine that word, “parse.”

What means?

From the Free Dictionary definition of parse:

parse (pärs)
v. parsed, pars·ing, pars·es
v.tr.

1. To break (a sentence) down into its component parts of speech with an explanation of the form, function, and syntactical relationship of each part.
2. To describe (a word) by stating its part of speech, form, and syntactical relationships in a sentence.
3. 3.
   1. a. To examine closely or subject to detailed analysis, especially by breaking up into components: “What are we missing by parsing the behavior of chimpanzees into the conventional categories recognized largely from our own behavior?” (Stephen Jay Gould).
   2. b. To make sense of; comprehend: I simply couldn’t parse what you just said.
4. Computer Science To analyze or separate (input, for example) into more easily processed components.

Our main interest is in Definition #4. As it turns out, these “easily processed components” correspond to the syntactical relationships defined in Definition #1.

As it turns out (you should check this yourself), parse can often be used as a synonym for “chop” or “cut.”

(Digression: the web has dumbed down common search terms because the vast majority of search results scrape or license one or at most very few sources instead of presenting their own work. Thus, a Google search for such terms results on a multitude of web pages all saying the same thing, in the same order, sometimes using the same words. You can’t do that in paper. It’s called “plagiarism.”)

Parsing your ingredients list

So, just as you might chop up a carrot, each item in the ingredients list needs to be chopped up into it’s parts.

Is this hard?

Well, not really, but as I hinted above, it’s tedious, time consuming and impossible to get right the first time.

For now, let’s not worry about that and focus on each list as a whole.

So instead of parsing an item in a list, we have to parse the entire paragraph!

One thing at a time… let’s back up a little bit and consider the whole hRecipe interface: 4 panes on a tabbed window, with several fields in each.

Each field represents an part of the recipe which can be defined using semantic CSS.

It turns out that it’s really simple for you to enter ingredients and instructions… if you follow a couple of simple – albeit totally unintuitive – rules. I say unintuitive, what I mean is these rules make perfect
sense to anyone who has written a parser.

When we get to the “Ingredients” field, there is no way for me (Dave) to know what you (Zarela) intend to prepare. That is, I can’t tell from behind the computer, separated in time and space, how many items in your ingredient list.

It turns out, this is the nature of the universe.

Rope through a hole

It’s basic thermodynamics really. There is one length of rope. Pull it through a hole and the length of the rope depends on which side of the hole you’re looking at. But the rope never changes length. TANSTAAFL.

There are several ways out of this predicament. Let’s look at the end cases:

• I do little work, you do a lot.
• I do a lot of work, you do a little.

Neither are very satisfactory. It turns out that using the semantic web correctly requires understanding a little bit about the semantic web, what it is, and the strengths and weaknesses implementations.

Let me restate that last paragraph: Supposing hRecipe was somehow written in MS Word. You would still need to learn some new stuff to use it correctly. There’s no way out!

Think of it this way: each semantic recipe is a little machine carrying little bits of recipe DNA that it can shoot into search engines.

But you have to load the machine. It’s different for each recipe.

Thus, data entry.

Getting back to lists of ingredients…

Upshot – 2 rules for fast hRecipe formatting

Here’s the two rules for helping me parse lists of ingredients or instructions:

1. Each ingredient or step in the instructions should start with an “*”.
2. Each ingredient or step in the instructions should be on it’s own line. Let it wrap if necessary, just don’t put a line break in (don’t hit the Enter key).

Alternatively, you can use raw HTML for these lists, but I don’t recommend it anymore. I’ll be stripping that out in the future.

This is all I have tonight. I’ll do more on this tomorrow and post it on the blog,

By the way, the blog has a LOT of material you will find useful for WordPress.

Thanks again for your interest, it helps keep my interest high.

—-

Thus concludes my email.

Whether Zarela chooses to use hRecipe on her blog is irrelevant. What’s much more important is that she asked me to explain the details.

That is critical. Because even if she doesn’t understand (or decides against taking the time), she has now been exposed to the notion of semantic web.

And so have you.

That’s way more important.

I have metric boatload of material coming your way.