The book I read is Jez Humble and David Farley’s Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation. I’m not sure if the weaknesses are due to Amazon’s ebook platform, this particular title, or some combination of both, but these were the issues I had:

1. The table of contents as displayed by the PC reader application, isn’t detailed enough.  The book is divided into three sections, and the sections appear in the ToC, but none of the chapters in the sections do. One of the entries in the ToC is the Contents as it appears in the book itself (which is also where you go if you choose Table of Contents from the iPad menu). It has links to everywhere, but is extremely detailed and spans 19 pages, making it cumbersome to use. There’s no easy way to just jump to a particular chapter.
2. Cross references don’t tell where they’re going in a meaningful way. They reference other parts of the book by page number, but Kindle books don’t have page numbers. There is a link, so not all is lost, but I couldn’t tell if a cross reference was to some part of the book I had already read (and that I ought to therefore nod and say, “Oh, yeah”) or somewhere later on. Maybe just a little arrow icon pointing left or right would have been a good hint.
3. The index is cumbersome. There aren’t any links to jump to the different letter sections, so if you want to look up “Tests”, be prepared to flip through a lot of pages to get to the T’s.
4. The figures are too low-res. One in particular, 15.1, was almost completely unreadable. It sounded like a really interesting chart, but it was just too small and couldn’t be zoomed so I feel kind of cheated out of that.
5.  Compound words were problematic because the dashes were usually dropped and the words mashed together. Apparently someone/something confused them  with dashes as a result of layout (to split words across lines) and dropped them all.

It seems possible that Apple, with their new iBooks 2 platform and its textbook focus,  could end up being a better experience for technical books like this. I’ll be interested to give it a try.

I guess I’m not the only one with this problem. A friend sent me a message thanking me for a gift basket I’d sent him a couple of weeks ago. He hadn’t opened it until it was time to start wrapping all the presents he’d ordered himself from Amazon. Hopefully the food was still edible.

At first I was thinking that Amazon needs to figure out how to solve that problem. If I were Amazon, I might just suggest gift wrapping presents to others so that it is always safe to open the box, but gift wrap starts to get expensive — especially if you have several less-expensive items.

Another solution is to address the packages in a way that differentiates them. I’ve changed my wishlist address so that it includes “(Wishlist)” after my name. My regular ordering address now has “(Self Order)” after my name. Now maybe I just need to add “(A gift for you)” after the names of my friends to tip them off.

I guess I’ll see how it goes…

General rant aside, I also get tired of paying $60 for TurboTax every year, so I cancelled my automatic subscription, determined to try something else this time around. After reading some reviews, I decided to go with TaxACT Online, which looked to be reasonably good and quite a bit less expensive. The nice thing is that you can use the application for free until you’re ready to actually file or print your return.

There were a few times that I felt unsure about what I was doing while doing my return — I had some employee stock purchase program things last year to complicate matters. I eventually made it through, though, itemizing my deductions since I’ve got mortgage interest and lots of charitable donations. My remaining federal tax liability at the end was around $500.

That felt wrong to me. I don’t think I’ve ever owed federal taxes beyond what had already been withheld. State taxes, sure — I frequently owe some there — but owing federal taxes was enough to encourage me to take a run through TurboTax’s estimator. That gave me hope that I might be able to get a more favorable result.

Doing taxes is far from fun, but it was definitely easier with TurboTax Online. I felt more like I was being guided along rather than being presented with a bunch of text to read and some form inputs to fill in. I was also able to import a lot of data electronically, which helped with both speed and accuracy. When I finished my federal return (for the second time), I came out with about a $1500 refund.

Maybe I did something wrong with TaxACT. Maybe I did something wrong with TurboTax, but the refund was more in line with previous years. Certainly for my situation, TurboTax was clearly worth the price of admission.

1. Ubiquity
2. Price (free)

OneNote’s list is shorter:

1. It’s a truly excellent Windows application

The folks at Evernote can’t quite seem to get their act together. I think the Windows application has been through at least two complete rewrites since I’ve been using it, each time with the promise that this version will finally be the solid platform on which fantastic new features will be added. But the editing abilities still compare unfavorably to 1990′s-era HTML editors.

I can expect, though, that I’ll be able to find an Evernote client for pretty much any platform I want, with data synchronized between all of them because of Evernote’s cloud focus. Not all of the clients are created equal — Evernote for the iPad simply refuses to edit notes with “rich” formatting — but they aren’t bad.

OneNote’s anchor to Desktop Windows has been its biggest downfall. The cloud-stored notebooks of OneNote 2010 are a great advancement, but Microsoft needs clients for other platforms — and good clients at that. Even when I had a Windows Mobile phone a few years ago, the OneNote client there was pathetic. I regularly run Evernote clients on Windows, Mac, iOS (iPad) and webOS, and until I can do the same with OneNote, it’s hard to imagine it becoming my primary exocortex. That Microsoft has released an iPhone client is promising. Hopefully they’ll continue to add other platforms.

Using OneNote on Windows is a delight. Formatting works as expected instead of suddenly flaking out like it does in Evernote. Tables are easy to work with and look good. Images can be resized in-line. Screen clips go into the note I’m editing instead of a separate note, which is the behavior I want 95% of the time.

That Evernote is free is nice, but I’ve got 80 bucks sitting right here for OneNote if it can make that final jump to universal access.

My previous system started with XHTML content transformed through various XSLT style sheets thatproduced summaries, an RSS feed, a Google sitemap, and a common appearance across all the pages. The whole process was driven by an Ant script, and required no server-side code except for a comments form. It worked pretty well except for a few things:

• Running the scripts (which included FTP to the server) to publish a new article took a while, so it wasn’t something you could just quickly do.
• The scripts were only available on one machine, so publishing could only happen from there.
• When my comments form was turned on, it got a bunch of comment spam.
• If I wanted any new features, I had to do them all myself.

I thought I’d take a look at some actual blogging software to see what was available. I ran across an extensive comparison (though I can’t remember where that was now) where the person doing the comparison decided on using WordPress. I had thought about trying to use a .NET application, since I’m trying hard to learn .NET deeply right now, but there was a telling comment about .Text (the only .NET blogging tool considered) in the comparison. The reviewer said something like, “.NET programmers are more excited about .NET than actual working software.” While a sweeping generalization, I sense a bit of truth in there. Also, as a programmer, it is good to be exposed to lots of things, so a PHP application seemed good for technical diversification.

I created my own WordPress theme, both in order to preserve my site’s look as well as to learn more about WordPress. Then I needed a way to migrate my content. I don’t have a ton of articles, but certainly more than a manual approach would work for. I tried adding a couple of articles by hand, and quickly discovered that the WordPress editor treats all whitespace as significant, unlike HTML’s text flowing regardless of line breaks.

My first attempt at an automatic import was to transform my content to WordPress’ native export/import format. I abandoned that after a little while because it was based on RSS, but added a bunch of stuff that wasn’t really relevant for my content. I realized that I might as well just do an RSS import, which was easier.

The significant whitespace characteristics I noticed in the editor carried over to imports as well, so my conversion program had to strip out all the non-significant linefeeds out. I also discovered that if there were XML namespace declarations where the importer didn’t expect them, then it would think that there weren’t any posts to import. It would just say, “All done! Have Fun!”, which was kind of infuriating until I figured it out. I think I’ve heard someone say that blogging software is only as good as its import and export functions, and I almost gave up on WordPress at this point.

Once I got my content imported, I was happier about WordPress when I discovered Ryan McGeary’s WP-Syntax Plugin. I had thought about doing something like that myself at some point. I did make one small tweak to the plugin, though. GeSHi’s default syntax colorings were a bit too much for me, so I switched the GeSHi option over to use CSS styles for the highlighting, and chose fewer and more subtle colorings. I’m sure there are lots of other interesting plugins that I’ve yet to discover.

There have been some glitches (bug-like behavior), some manual work required even after my automatic import, and still some things to figure out, but I’m optimistic that WordPress will work out.

My program, ByChance, works like this. You supply an image that represents the ideal in survivability. Once you’ve done that, you click the “Start” button. The program starts with a black image with the same dimensions as the “fitness” image you picked. It then proceeds to pick a pixel in the image at random (around 200,000 possibilities, depending on the shape of the image). Then it picks a random color (24 bits, so there are around 16.8 million possibilities) for the random pixel and tests the survivability of the new picture. If the new picture is more like the “fitness” picture than what was there previously, the new picture, with its single different pixel wins. If not, what was there before wins. The program displays the winning picture, and also keeps a running total of the number of generations that have happened. A generation is every time a pixel changes and the fitness test is done.

Early Screen Shot

Later Screen Shot

I’m certainly not an expert in evolutionary theory, but it seems like the program serves as an interesting analogy. I should point out that evolution doesn’t have a perfectly ideal goal that it is shooting for like the fitness image. Given the forces of nature around us and all the aspects of our environment, there is pressure toward a survivable form.

Some of the choices I made in writing the program were arbitrary:

• Why not make the image size random too?
• Why start with black? Why not start with white or a completely random starting image?

Maybe something a little different would be a better analogy of our best understanding of what really happens. This experiment is kind of related to the infinite monkey theorem, but with not so many permutations and with pressure toward correctness.

After running the program several times, I’ve noticed a couple of things. The image becomes recognizable really fast. The image becomes perfect some time later than my patience allows for, but I expect it would take a really,really long time.

If you would like to run ByChance, you can download it from here.

The point of IShellExtInit.Initialize is for the shell to let your handler know which files are selected so that you can display your context menu based on, believe it or not, context. Here is a typical implementation:

int IShellExtInit.Initialize (IntPtr pidlFolder, IntPtr lpdobj, uint hKeyProgID)
{
  try
  {
    // save the information about the selection
    m_dataObject = null;
    if (lpdobj != (IntPtr)0)
    {
      m_dataObject = (ShellLib.IDataObject)Marshal.GetObjectForIUnknown(lpdobj);
      FORMATETC fmt = new FORMATETC();
      fmt.cfFormat = CLIPFORMAT.CF_HDROP;
      fmt.ptd = 0;
      fmt.dwAspect = DVASPECT.DVASPECT_CONTENT;
      fmt.lindex = -1;
      fmt.tymed = TYMED.TYMED_HGLOBAL;
      STGMEDIUM medium = new STGMEDIUM();
      m_dataObject.GetData(ref fmt, ref medium);
      m_hDrop = medium.hGlobal;
    }
  }
  catch(Exception)
  {
  }
  return 0;
}

Then later on, to get the selected file:

// Get the file name to work with
StringBuilder sb = new StringBuilder(1024);
Helpers.DragQueryFile(m_hDrop, 0, sb, sb.Capacity + 1);

There’s a fair amount of nasty interop going on here, which is sometimes inevitable for things like shell extensions. In this case, however, you can actually use the .NET Framework’s DataObject class instead for much simpler code:

int IShellExtInit.Initialize (IntPtr pidlFolder, IntPtr lpdobj, uint hKeyProgID)
{
  DataObject dataObject = new DataObject(lpdobj);
  string[] selectedFiles = (string[])dataObject.GetData(DataFormats.FileDrop);
}