Notice how much darker the old sample is than the new sample? (I poured it onto a white plate for the photo-op.) Here are some closeups, first old:

Then new:

The new stuff looks practically like water compared to the old. Which could be the answer; maybe they’ve sold out and started watering down their soaps to keep up with the competition from all the fakers. It also could be that something in the soap gets dark over time. Another possibility is that they’ve just altered the formula slightly—which is certainly true, because the ingredients are different, though not by much.

Old ingredients: Water, Saponified Coconut-Hemp-Olive Oils (with retained Glycerin), Olive Fatty Acids, Peppermint Oil, Rosemary Extract

New ingredients: Water, Saponified Organic Coconut* & Organic Olive* Oils (w/ Retained Glycerin), Organic Hemp Oil, Organic Jojoba Oil, Organic Peppermint Oil, Mentha Arvensis Extract, Citric Acid, Vitamin E

(The asterisks indicate which ingredients are “Certified Fair Trade”, which by the way seems a little disingenuous considering the comments by David Bronner in the interview above, and the fact that the new label prominently displays “CERTIFIED FAIR TRADE”).

Another dubious piece of evidence: the hole in the lid grew significantly from old to new, as if to say “use more!”.

WE’RE WATCHING YOU, DR BRONNER! DON’T DILUTE! DILUTE! OUR SOAP! OK! OK!

The book makes an interesting point about why we should pay attention to our money, instead of just assuming God will take care of us. The idea is basically that we should be “provident and resourceful” people, so that in the event something happens to the economy or the world (e.g. a natural disaster), we’re able to function enough to continue doing good things—helping the needy, who will be more so during times of duress. We’re not taking care of ourselves purely for self-preservation or so we can be lazy, we do it to maintain our future potential to act beautifully in the world (okay, that last bit was more like my interpretation of what the book says). This leads naturally to why we should have savings, and not have lots of credit card debt, and generally live within or even beneath our means so that we have means to help others now and in the future.

One other thing it leads to is not something I had expected. That is that we should be prepared for future problems outside the economy. In other words, sure we need to save money, but if the economy itself fails us (e.g. the store has no food), are we prepared? So this whole section of the book is dedicated to talking about planning for things like a flood or hurricane that wipes out communication or transportation for a time. It talks about a “Self-Sufficiency Exercise”, in which we give up all outside resources—electricity from the grid, fuel that’s not stored at your house, food from the store—for a period of time, such as a week. This is to test the character of ourselves and our family, and perhaps just as a learning experience to show just how much we depend on the economy from day to day.

Doing this exercise in the city seems rather hard, because having a generator or propane tanks is not really feasible. However, some things are probably easier in the city, like the fact that most places are within walking distance, or at least you can take public transportation (if your disaster scenario permits). Regardless of location, one can certainly have a few weeks worth of food and water stored up. I haven’t decided to undertake such an exercise, not the least because the other person living with me probably would object. But I might start storing a little water, and a little food—just in case.

I was a little surprised to find as much interesting in the book as I did. There was one other little thing: I learned about the existence of futurology—the study of what’s going to happen in the future, of course! It sounds like Asimov, but it looks like it might actually be real.

The primary things I want to say about the film are:

• Stylistically, it is very much like the graphic novel. In fact, a very many scenes are almost exactly what I imagined when I read the novel. This is a good thing. Lots of beautifully bloody and bad-ass slow-motion battle shots.
• They made up some battle scenes with big ogrey guys for the movie. No problems here.
• Oddly, the massive amounts of violence didn’t bother me much. However,
  there were a few scenes where they went a bit too far.
• There’s not a whole lot of story in either the book or the movie. However, there’s more in the movie than the book. Primarily, the filmmakers added a side story about Leonidas’ wife (Leonidas being the king, the main character). They also added a political agenda: discourse along the lines of “freedom isn’t free”, “support the troops”, “finish the job”, “congress sucks for opposing the increase of troops in Iraq”.. well they obviously didn’t say that last bit but they might as well have. This particularly bothered me because I felt it subtracted significantly from Frank Miller’s original portrayal of the reason, freedom, and justice pose struck by the Spartans.
• (minor spoiler) One interesting detail conspicuously missing from the movie: in the book, when Ephialtes, the betrayer, finds out by speaking with the king that he is not worthy of being a Spartan warrior, he jumps off a cliff in an effort to kill himself. He does not quite die, and then drags himself to his feet again to perform his betrayal. In the film, he does not try to kill himself at all–he instead immediately turns bitter and gets the idea to betray the Spartans. I thought the suicide was an important illustration of the depth of the warrior Spartan image. I’m not sure why it was left out–perhaps because they wanted to make Ephialtes more clearly a badguy.

In conclusion, I have to say that the made up plot points and political agenda turned me off significantly to what could have been a truly original and fine piece of work. Read the graphic novel; I felt that part was a valuable experience. Stay away from the film, or at least wait until it’s netflixed. It doesn’t deserve your $10.

On the latest break, two screws wiggled loose and got lost. The scooter still rides but the handlebar clamp is loose and probably won’t stay on forever in this state. I sent xootr service the following email:

What sort of response would you expect from your favorite merchant? I was thinking of one of two things: either “please buy an entire new handlebar clamp kit” ($20 plus shipping, IIRC), or “okay, that’ll be x dollars”. The actual response follows:

Subject: RE: need little screws for handlebar clamp

Hi XXXX.

Let me have your address and I will send some immediately.

Best,

Steve

Radical. I like small companies, and I like companies that respect their customers. Yay Xootr.

Micro X Copter

It’s about 8 inches long, and made mostly of styrofoam. The rotors are made of flexible black plastic, which makes them especially durable when you run into things (which I do all the time). The whole thing weighs about as much as two cdrs (sorry, it’s all I had handy to compare with), which is really impressive when you consider the fact that it’s got a battery and motor strong enough to keep it up in the air for 15 minutes or so between recharges.

The controller is pretty straight forward; the left lever controls the throttle, the right lever controls the yaw (it turns the copter left and right), and there’s a trim adjustment under the yaw lever which is basically an alignment adjustment for the yaw. It also has three channels (the A B C switch in the middle), in case you get together with some friends who have the same device.

One bit that I found kind of odd was that the helicopter charges directly from the controller. I would have expected an adapter that plugs into the wall. But this seems to work fine, as long as you have enough AA batteries.

The controller takes 6 AA batteries. I would recommend getting 6 usbcell batteries so you don’t waste throwaways.

Flying the copter is a challenge, as I would expect any R/C helicopter to be. What makes this one seem unique is:

• It’s meant to be flown indoors. I’ve crashed mine into the ceilings, walls, and random furniture over and over again, and it still works fine.
• It’s cheap ($39.95).
• It’s really simple to get off the ground and sort of fly it, but to really control it takes a lot of patience.

All told, it’s total zuitnis.

Title: Practical OCaml

Author: Joshua B. Smith

Technical Reviewer: Richard Jones, of Merjis
Publisher: Apress, part of the Practical series (which published, notably, Practical Common Lisp)

Pages: 456

Published: 2006

Review:

The concept behind the book is brilliant: shed some light on how OCaml can be used for practical coding. All the ivory tower academics are constantly touting the merits of type-safety and functional programming, but hardly anyone actually uses functional programming for real, practical work. There are only a small handful of significant open-source programs written in OCaml, and even now very few companies have embraced the language.

It’s a great idea to show how OCaml can be used to write real world applications. It’s clear from the title, overview, and structure of the book that Joshua Smith wants to emphasize OCaml’s practicality: his sample code includes “A URI Library,” “A Spam Filter,” and “A Shoutcast Server.” For this essential insight, I applaud Mr. Smith.

Unfortunately, that’s about where the praise has to stop. This book has several serious flaws, that render it virtually useless. In fact, this book’s existence will probably cause significant harm to OCaml’s reputation.

Let’s start with the writing. In the “About the Author” section, we learned that the author was, in fact, an English major in college. So we expect some good english–hopefully better than most dry technical books written by dry technical folks who know lambda calculus but don’t know what an adverb is.

Let’s take a few examples:

The Blog
In fewer than 100 lines of code, you can see the code that provides much of what you see on the screen. This is a simple, file-based web log such as CGI. It creates the disk files named by using an MD5 hash of the data within the file, which makes the likelihood of collision so small as to be a nonissue. If I were more concerned, I would add the time to the string used to calculate the MD5 hash, but I haven’t done that.

Try reading the first sentence out loud. Doesn’t make any sense, does it? The second one is no better, if you know what CGI is (it’s definitely not a type of “file-based web log”). The remaining discussion about the MD5 hash is almost readable, but it has technical problems (1: using an MD5 hash for the filename is a terrible idea; 2: adding the time isn’t going to make any significant improvement to this terrible idea).

Okay, so he had a bad paragraph. Lighten up? I would love to, but the whole book is like this. Let’s try the intro to the next section:

But I Want to Add Cookies!

Here is where the drawbacks of rolling your own become apparent. You have your blog application running, but now you want to add authentication. To add support for it, you have to add it myself.

Admittedly, the use of “myself” instead of “yourself” is a simple grammatical error. But rest assured, the book is riddled with similar errors. I did not look hard for these. And the guy is an english major, so this sort of thing is supposed to be his strong point.

The first page has an overview where he tries to answer the question: Why Objective Caml? He answers with an analogy:

To answer in not-so-mundane terms, we can compare what an architect might want in building materials versus what a carpenter might want in building materials. An architect wants the best materials to build with, but a carpenter wants the best materials to work with. This is as it should be–the carpenter values the work and wants to do it well. The architect, however, might not have the specific concerns the carpenter does. This is as true in software as it is in wood.

Huh? Who is better, the architect or the carpenter? What does this have to do with programming? Ah, he goes on in the next paragraph, surely he’ll explain it:

As a programmer, I want good materials. OCaml is one of the best materials I can think of.

..need I say more?

But I’m going to. A technical book like this need not be well written to be useful. After all, it’s teaching you how to code, so it’s got tons of code examples. Examples, when thoughtful, concise, and correct, can be very helpful. Bummer that the examples in Practical OCaml have none of these properties.

The first and most obvious problem is the formatting of the code. It’s a bit hard to explain, but the code samples have these little arrows all over that mean “this line continues” because the code didn’t all fit on one line. Usually this is because there’s too much code trying to squeeze into one line. An example (*** marks the spot where the little arrow is in the actual text):

let print_position pos = print_string "Holding: ";print_int ***
pos.holding;print_string (" " ^ pos.symbol ^ "@");
print_float pos.pprice;print_newline ();;

Nobody indents their code like this. It’s completely unreadable. The same function, properly indented, should look like:

let print_position pos =
  print_string "Holding: ";
  print_int pos.holding;
  print_string (" " ^ pos.symbol ^ "@");
  print_float pos.pprice;
  print_newline ();;

Actually, since we learned about the printf function earlier this chapter, let’s see how much more concisely and cleanly we can write this code:

let print_position pos =
  printf "Holding: %d %s@ %f\n" pos.holding pos.symbol pos.pprice

Enough about indentation. What about content?

module type LIFER =
sig
  val xdim: int;
  val ydim: int
  val results: int * int * int * int * int * int * int * int -> int -> int
  val default_colormap: int -> char * char * char
  val default_mapcolor: char -> char -> char -> int
end

What in the world is a results? A function that takes an 8-tuple of ints, then one more int, and returns an int? What are all these ints? Any OCaml programmer would look at this and say it’s very bad style, because it’s extremely hard to read. It should be a record instead. Let’s go on..

...
match res with
  remain when (res = 2) -> x
  | live when (res = 3) -> 1
  | gain when (res = 4) -> 2
  | more when (res = 5) -> 3
  ... 

This is not only confusing, it wouldn’t even compile. Well, depending on your compiler settings, it might compile, but the compiler would complain loudly because remain, live, gain, and more are not even used. Here is code that is simpler, doesn’t create a compiler warning, and does the exact same thing as the above code:

...
match res with
  | 2 -> x
  | 3 -> 1
  | 4 -> 2
  | 5 -> 3
  ...

Heck, we could even write it like this:

... if res = 2 then x else res - 2 ...

(simpler, eh?)

And this is just basic pattern matching; elementary OCaml stuff.

These are some of the more glaring and easily visible issues that I’ve happened across during a recent perusal of the book. There are other, much more insidious types of problems which require a reasonable understanding of OCaml to catch. For example, the first demonstration in the object chapter shows how to use the object system to automate the initialization of the random number generator:

class random =
object
  method int x = Random.int x
  method float x = Random.float x
  method rand () = Random.float 1.
  initializer Random.self_init ();Printf.printf "Random Constructor"
end

What he’s clearly missing here is that when you call Random.self_init (), this re-initializes the random number generator in a global, stateful way. So the whole notion of encapsulating the initialization of the random number generator is lost. In fact, the entire two-page example is based on a false premise.

In conclusion

Anyone who wants to learn OCaml should stay away from this book. It will only confuse. This is unfortunate, as the idea to shed light on the practicality of OCaml is an excellent one. I’m rather shocked that Richard Jones signed on to be technical editor, and that he let the book be published in this state (edit: see his explanation in comment #2 below).

I would urge any and everyone to not buy this book, and don’t let your friends read it; it will taint their view of OCaml and quite possibly confuse them enough to keep them away from OCaml forever.