Nathan Dial's adventures in Interweb Land

I read about PhotoSketch on Gizmodo, and I was very impressed. After seeing a very impressive demo, I was really looking forward to actually getting the program installed and giving it a shot. And I was in luck, because I found a download link for "source files" ... then we get to the good news / bad news loop.

 The bad news is, it wasn't the source.

The good news is, it was Binaries.

The bad news is, the site is positively hammered.

The good news is, wget and patience were able to pull down Binary.zip

The bad news is, it's Windows .exe files and I don't have a Windows machine handy.

The
good news is, I'm not stupid enough to run random unsigned Windows .exe
files I just downloaded from a chinese university web server anyway. 
The other good news is I have Win XP in a VirtualBox instance on my
Ubuntu laptop, sandboxed and snapshotted.

The bad news is, it says it's misconfigured, and doesn't want to run.

The good news is, I ran strings on the binaries, and they do look like
real 32-bit Windows .exe files (at least, there are multiple mentions
of Win32 in the strings) and as far as I can tell, not that trojan-y
looking (but of course, a good trojan wouldn't!)

The bad news is, bottom line, I can't get them to run tonight. Maybe I'll take it up again tomorrow.

Also
bad news is, it's not just a "Paint" program that outputs
GIS+Photoshop+alphablend images... apparently you have to do some file
editing and command-line-argumenting, as well as running overnight
batch jobs and such, to get close to the output that looked so easily
attainable.  Maybe I'll take it up again tomorrow.  Posting this
tonight on the off chance it gets indexed and someone makes a useful
comment.

Here are some interesting things I found from running strings, that probably have something to do with why it's not working:

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">

  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">

    <security>

      <requestedPrivileges>

        <requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel>

      </requestedPrivileges>

    </security>

  </trustInfo>

  <dependency>

    <dependentAssembly>

      <assemblyIdentity type="win32" name="Microsoft.VC90.CRT" version="9.0.21022.8" processorArchitecture="x86" publicKeyToken="1fc8b3b9a1e18e3b"></assemblyIdentity>

    </dependentAssembly>

  </dependency>

  <dependency>

    <dependentAssembly>

      <assemblyIdentity type="win32" name="Microsoft.VC90.MFC" version="9.0.21022.8" processorArchitecture="x86" publicKeyToken="1fc8b3b9a1e18e3b"></assemblyIdentity>

    </dependentAssembly>

  </dependency>

</assembly>

That looks like it depends on some MFC libraries that come with Visual C 9.0?

 Well I'm not just going to type that and then not try it. But it's
taking a while to download and install.  I'll post an update if I get
it working.

Continue reading "running PhotoSketch" »

I think the easiest way to tell an experienced programmer from a newcomer is to see how much they care about maintainability. New coders (and some business clients) just want to it built as fast as possible, at any cost. Coders who have been around for a while understand, however, that code of any quality spends a lot more time in maintenance than it does getting build the first time.

 But there are still some disagreements on just what maintainability means. You can't boil it down to a number, like lines of code or hours spent, so it's not as easy to measure -- and if you can't measure it, it requires a lot more intuition and "art" to manage it. Here are a few thoughts for making decisions based on which is the more maintainable.

Maintainable Components

For almost any common programming problem, there are two or three potential solutions that are already built, and generally, a well-supported external component is more maintainable than rolling your own... usually. If the code is buggy, poorly-documented or poorly-supported, you might be better with your own home-made solution. Or, depending on the options and task, it may make more sense to take a poorly-supported, but open solution, add what it needs, and contribute the changes back.

In any case, you want your components to be reusable, reliable and, as much as possible, forgettable. If you never have to think about it, it's doing its job just fine.

Maintainable Design

Test-driven design often calls for the "simplest change that will pass the test."  And if you have full test coverage, it's so much safer to refactor that it can be the wisest decision. But often the type of "organic" design that can grow out of Agile development is closer to organic fertilizer.

Maintainable design means using "just enough" design to get your job done -- over-engineered code is a pain to maintain -- but it also means encapsulation, smart code re-use, and appropriate application of design patterns.

Yeah, I said design patterns.  I also said, and I emphasize, appropriate use of design patterns.  I'm not talking about using a Factory to produce "Hello, World!" But design patterns are a smart way of encapsulation with maintenance in mind, and when your developers understand and use patterns, you greatly reduce the typical heavy communication overhead associated with maintenance.

Maintainable Process

This can be a major challenge for rapid-development groups because there is a way to get working code out that is faster than the most-maintainable process for the first draft or two ... and some programs never get past the first draft or two. But if you have a high-output "lightweight" process that glosses over maintenance needs, it's only a matter of time before your output of so many code chunks that require maintenance starts draining resources from your high-production plan.

 There are many options for process, and it's wise to choose one that's appropriate for your team, your business, your industry, and your size.  Whatever process you choose, it's essential to track new development and maintenance work, to pro-actively reduce code debt, and to plan for maintenance before you start a new project.

A few weeks ago, possibly while I was enjoying a shawarma, I wondered what other types of grilled meat on a spit are available. A quick Wikipedia fugue led me to tacos al pastor (tacos "shepherd style"), an international fusion dish originally created by Lebanese immigrants in Mexico City. These tacos are made by stacking marinated pork on a vertical spit (such as are common with gyros in Greek restaurants), which is then roasted with pineapple chunks at the top, and sliced to order, placed in a tortilla with cilantro, onions and possibly roasted pineapple chunks.

my stomach is growling just thinking about it.

Let me tell you, it's a lot easier to find tacos al pastor in Austin than it was to find salt-rising bread in Knoxville.

First stop: Al Pastor restaurant on E. Riverside. Cheap, fast, good. Pick all 3. (Well, ok, it wasn't that fast to drive down to E. Riverside on a lunch break, but...) They were prepared quickly, and tasted splendid. Lightly fruity, barbecue (but not barbacoa) and not too sweet. Very good.

But of course, why stop with just one place? (Maybe because driving across town just to stuff my fat gourd with high-calorie gut bombs is hedonistic? /shrug) Anyway, the next place I tried (not on the same day, mind you) was Chango's on Guadalupe. I didn't see a spit there, so I'm not sure if it was authentic al pastor or not. But it was enjoyable, just like everything I've ever had at Chango's.

So far, that is all I've tried. The matter of "are they good" is closed, and the answer is Yes. It looks like Taco Xpress, Curra's and Evita's Botanitas should all be on the list before I cover "who is the best?"

In the past, I wrote an opinionated blog rant about how SEO is overrated, and how if you want to rise in search engine rankings, your only focus should be building a good product. I was looking for opinions or echoes on the net, and I found out that my radical ideas about Search Engine Optimization have already occured to others.

Having spent the better part of a year now working in the aggregation end of a major search engine, I ... I really have to take that back.  I mean, yes, being relevant is a huge boon to your search ranking, but being crawlable is necessary before you even get into the index at all! If you have a convoluted POST-based navigation or you require Flash, Acrobat or even JavaScript to navigate your site, search engines will have an uphill struggle to index your content.  Technology to do so is improving, but the bread-and-butter of search indexing is still GET-based.

Interestingly, making the right decisions to get crawled well, will also help you make good accessibility decisions, too. Have you ever looked at NoScript? It's a firefox plugin that disables all JavaScript by default.  It's troublesome to manually enable scripting for new sites, but in exchange you get to have very high confidence that you won't get remotely pwned by a rogue website. And if you're optimizing a site for accessibility/SEO, it also helps you test and see how your site performs to the average search indexing bot (or browser for the blind, or low-end mobile browser, etc.)  It doesn't have to look pretty with NoScript, but if it's not browsable without Javascript enabled, it's not as indexable as it could be.

There are obviously inappropriate SEO moves, like packing keywords or spamming links, that not only don't work in the long run, they're counterproductive, because resources that go into temporary, artificial ranking boosts are resources that could be directed into relevance. Or heck, into paid search advertising. It's kind of expensive, but if you need to get your name out, paid search works.

After dealing with a major server upgrade, around the same time I saw Cal Henderson's Why I hate Django talk, I decided to ditch my Django-based weblog framework. (Particularly convincing was when he asked the audience how many had started or was planning on starting a blogging framework in Django, and all but 3 audience members raised their hand.)

So, for now I'm playing with Serendipity just to fill the space up here. I'll have to see if I can go back and dig up some of my past posts for re-posting here.