What we get “paid for” is actually dealing with a lot of crap code, some written by us, the rest written by others. Ayende has a great quote, broken English and all:

There are always at least two people in any software project:

• The developer who wrote the code.

• The developer who read the code.

They are never the same person, even if just by temporal dissonance.

In other words, we will generally have a thought of “who wrote this crap”, and most of the time, it is our past self.

As tempting as it is, we cannot simply try to create new projects whenever we encounter difficulties or better ways of doing things. We would never get things done.

There are however instances that demand a new project. Here are a few that come to mind:

• Platform is not actively supported or vendor’s development has reached a sunset.
• Another major technology has supplanted the one your using in the marketplace, one that would reduce your codebase significantly.
• You have to re-read nearly the entire codebase to make any changes or you have limited tests, specs, documentation, etc. on a key application. This is a special case, one that’s not very popular and easily ignored when we get busy, but in this event, you want to capture as much of the knowledge from the developers now, this is your “project”.
• Your application is small (e.g. 1 developer, handful of function points), these are the perfect environments for learning new technologies, techniques, etc.

Any others come to mind? Let’s have them!

Basically, my friend come up to me at work today and asked if I knew of any way to record and save a song she had heard on the internet. It should go without saying that the legalities of this should be investigated a bit before trying this yourself, but in this case, I felt comfortable that we were within the law.

Audacity can do this sort of thing nicely, but the problem is, Audacity doesn’t ship with an MP3 encoder (due to legal reasons, I suspect). I needed to find a simple way to copy lame_enc.dll to the user’s hard drive, and create a registry key in the right spot that points to that dll. There are a lot of ways to do this: a little .NET application, a variety of scripting languages, etc. But let’s think about this for a sec…really, what you’re doing is a lot like what an installer does. InstallShield, Wise Installer, the installation wizard that comes with Visual Studio, WiX…all these are great, albeit a bit expensive and/or confusing. Did you know there are two great, free alternatives? Inno Setup and NSIS are both quite robust, fully scriptable, free installation packages. As an aside, I’d encourage you to not underestimate the significance of having your installer be totally scriptable…just being able to follow the version of your installer via a source control system is immensely helpful. And if you’re stuck with Windows Installer, check out WiX…it’s great.

Out of the free options, I tend toward NSIS for several key reasons:

1. Helpful support community
2. Used by Google
3. Very small install files (smallest of all installers)

There are several IDEs to help you create and maintain NSIS installers. I choose HM NIS Edit simply because it was first one I saw years ago (before all the others were available). It has a nice little wizard that can help you build a simple installer script very quickly.

I walked through the wizard and chose lame_enc.dll as the only file that this installer will install. I decided to put it in Program Files, since I assume that most users know not to randomly delete files from there. Plus, it sort of fits there .

Now, all, we need to do is add the registry key that tells Audacity where to find lame_enc.dll. The NSIS documentation is very helpful, and I found the answer in no time:

WriteRegStr HKEY_CURRENT_USER "Software\Audacity\Audacity\MP3" "MP3LibPath" "$PROGRAMFILES\LAME MP3 Encoder\lame_enc.dll"

My NSIS script already had a block of code called “MainSection”. That block contains the operations that happen when the installer runs. I just added my new operation to the end of the main section, and added a corresponding DeleteRegKey operation in the Uninstall section, and voila! The installer was done. Well, done after I compiled it, of course. Now, all I need to do is point my friend to the Audacity installer, and the LAME MP3 Dll installer I just wrote in 3 minutes, and she’ll be making her own mp3s like a pro.

Oh, and remember when I said that NSIS makes small installers? Well, the dll we’re installing here is 296KB, and the installer? It’s 219KB. Isn’t that refreshing?

I hope every developer has a chance to spend some quality time learning how modern installers work. That knowledge comes in handy more times than you might think. Check out NSIS and Inno Setup for starters…they’re so simple to use, I bet you’ll find yourself thinking of ways to use them before you know it.

Helpful links for this article:

• Installer source file
• Installer compiled
• Article on how to save audio from the internet

PHP is rather new to me, but I was comfortable with the interpretive style with my experiences in Classic ASP, and PHP’s C-like syntax. I figured I could whip something out in a few minutes (maybe an hour once I saw what we could do) that would retrieve my Delicious feed using their API.

“Wait a minute!” you say, “Doesn’t Delicious already provide a way to find this information using JSON and this would then allow you to use JQuery to do a Remote Data call?” Ah yes, but only for public bookmarks. We’re trying to support all Delicious bookmarks here.

So let’s get back to the bane of PHP development: trying to find relevant, correct examples. Not only did I need to retrieve data using Curl, but I also needed to provide a Username and Password, over SSL. It felt like going from 0 to 100mph and I forgot to cover the basics first. But, I’m a “seasoned” developer, I can handle it.

A few hours later and I had code, that wouldn’t run. I was relegated to reading…a book. A little time with w3schools PHP section would have answered most of my questions, correctly.

These were the two things that made the progress slow:

• Finding the correct way to concatenate strings in PHP – “.”
• Finding the correct way to retrieve variables from “$_REQUEST” object

Enough already, let’s have the code!

Note: As Nathan has pointed out already, you don’t have to use “$user” or “$pwd” as they will be automatically populated via PHP. I choose to include them to highlight intentdidn’t know PHP did that at first.

I’m not backsliding into an old habit of BDUF. I’ll keep this brief and use this latest post to simply work out the plan of how the major pieces fit.

Here’s the current intent:

Delicious RSS Importer Architecture

Basically we need to have a server-side piece to proxy the data requests from Delicious and external RSS feeds. Those results are then stored client-side using Google Gears.

The other concern is that NO passwords are stored externally. Once you setup Delicious RSS Importer for your environment, your credentials remain private.

Finally, I managed to setup a dedicated project space for this work with the good folks at SourceForge.

If everything goes as planned, it’s trivial. For ActiveX DLLs, you can just use regsvr32 with the /u switch, like so:

regsvr32 /u dllFile.dll

For ActiveX executables, you use the /unregserver argument for EXE itself, like so:

ActiveXFile.exe /unregserver

Each ActiveX file has a class ID (CLSID) that uniquely identifies that file in the registry. When you unregister the ActiveX library with one the previous commands, all references to the library are removed from the registry. This is important if you’d like to update an ActiveX library that has had it’s CLSID changed. Normally, you’d just unregister the old library (using the old file), remove the old file, then copy in the new file and register it.

Lil’ Orphan Annie

So what happens if the old library file has been deleted? You’re stuck with all those old keys in the registry, and often times that will prevent the new from registering properly!

It just so happens I was working with a company that had a problem like this. Their product had several ActiveX exes and DLLS, and more often than not, when trying to update a client’s files, someone would forget to unregister the old libraries before removing them, so we found ourselves stuck in this mess quite often.

To figure out how to fix this, I decided to figure out exactly what happened when an ActiveX library is registered, so I could undo the changes. I did some research and concluded that when an ActiveX library is registered, the only thing on the system that changes is that several keys are added to the registry. There are several programs (mostly for installers) that will help you discover exactly how an installation has affected your system, but I wanted to try a free way. This is where a simple but irreplaceable tool came into play: the diff tool.

Visual diff tools rock!

Diff tools compare two text-based files (or blocks of text) and visually show you how those files are different. It’s an absolute must-have for programmers…when combined with a revision control software product like SVN, git, or Source Save, you can easily compare how a text file has changed since it was last ‘checked-in’. There are plenty of good ones out there…I’d recommend checking out WinMerge. It’s fast, free, looks good, and integrates nicely with TortoiseSVN.

So how is WinMerge going to help us here? Well, fortunately the Windows Registry Editor (regedit) provides an option to export the entire registry into a text file! So, discovering how your registry has changed after an operation is as simple as:

1. Taking a snapshot of your registry (export to text file)
2. Applying the change (registering your ActiveX DLL)
3. Taking another snapshot of your registry (export to different text file)
4. Comparing the two text files to spot the differences (Use WinMerge or other diff tool)

On to the next adventure

It’s ridiculously simple, but it works great, and it’s free. You’ll learn a lot about how much your registry is being used constantly by the OS and your running programs.

Now that we know which registry entries have changed, we can look for patterns and figure how to remove all traces of an ActiveX library from the registry just by knowing it’s original path. I’ll cover that topic in a future post.

I hope this can help out some poor soul still using VB6 ActiveX libraries!

There are currently several elements to my utopic RSS lifestyle:

• iPhone 3G
• NewsGator online account and services
  • NetNewsWire for iPhone
  • NetNewsWire for Mac
  • FeedDemon for Windows
• Delicious

Here’s the great part: NewsGator products all synch with each other, so I’m never re-reading content.

Here’s the real problem though, I read most of my feeds on my iPhone, which doesn’t easily post content to Delicious, instead they use something called “Clippings”.

This Clipping thing, while interesting, is something similar to Google Reader’s Shared Items, just with less features. Both Shared Items and Clippings can themselves be output as RSS feeds and you can do fun stuff with that to be sure.

So the problem is this: how can I import RSS content into Delicious?

Delicious themselves don’t have a good answer. Google also doesn’t provide relevant solutions, even other solutions don’t quite measure up.

So, without further adieuado, here’s the first Half-Baked Bits project announcement: Delicious RSS Importer.

Here’s the idea in a nutshell:

1. User hits a page and enters Delicious credentials. Those credentials are stored in cookies, no server-side saves.
2. User adds RSS feeds of their choosing
3. User adds items from those feeds to Delicious, while being provided a simple tag window of popular and existing tags, existing items (via URL) are then hidden from display

Thanks again to Balsamiq for their excellent Mockups tool.

Here’s the entire review in two words: Perfect Fit.

Alright, if you promise to come back, stop reading and just try out the online demo.

Here’s what I really like:

• Clean UI: property boxes are dimmed until needed, keeping you focused on your screen
• Easy to Discover: I quickly found little nuances (like icon sizes)
• Smart: auto-appearing guidelines for aligning elements and providing consistent borders,
• Support: I had to contact Peldi about something and he responded within 45 minutes… from Italy… and it’s only Peldi as Balsamiq.
• Convincing: As I fly through this app I consistently try clicking on an object, expecting some behavior… only afterwards do I remind myself how dumb I really am.
• Multi-platform, web-delivered: Adobe AIR application all the way.

Here’s what still needs work:

• Consistent Text Editing: When editing text, I missed at first that I needed to use a “Label/String of Text” or “Paragraph of Text” to get Text Alignment, and other formatting options.
• Favoring the Keyboard: many times I was editing text of an object and I wanted some “quick finish” keyboard command (say, CTRL+Enter) to commit my change and drop me out of edit mode. Instead I had to use the mouse and click somewhere off the object.

This is just great software to work with… fantastic job to the huge software teamPeldi with Balsamiq Mockups!

• Excellent network reliability
• Excellent data reliability
• At least 2 GB of space
• At least 2 user accounts
• FogBugz integration
• Secure access to repository
• Good price ($15 or less per month)

I was checking out the CVSDude.com, SVNRepository.com, Unfuddle.com, BeanstalkApp.com, CodeSpaces.com, Hosted-Projects.com, and Wush.net. Only three had 2GB/mo for $15 or less: CVSDude, SVNRepository, and Wush.net.

Out of those three options, only Wush.net and CVSDude allowed FogBugz integration. SVNRepository did not advertise FB integration on their site, so Brett emailed them, and they confirmed NO FB INTEGRATION. Too bad, too. They had a nice price.

So I had to choose between Wush.net and CVSDude. CVSDude has been around forever…since 2002. Wush.net has been around since 2004. CVSDude has over 45,000 projects hosted right now; I couldn’t see a project count on Wush.net. Both seem to a solid data security plan (RAID, nightly backups, etc).

In the end, poor reviews of CVSDude made the difference. I typed in “CVSDude” in my Firefox search window (Google search), and suggested search 3 and 4 was “CSVDude down” and “CVSDude problems”. Ruh-row.

I’m sure CVSDude has to deal with a lot of traffic…probably several times more than Wush.net. For now, however, we’ll use Wush.net, and maybe CVSDude will work through their scaling issues.

So Wush.net it is!

How Did We Fall

Our applications usually start from a simple problem (something is costing someone money), but finish as masterpieces of problem solving. There are many natural complicating factors that go into this finished solution, the principal among them being users require various ways of getting the answers they’re looking for. Additionally, as a programmer, I rarely want to work on a problem that isn’t difficult. All of these forces contribute to taking a once simple solution and creating a Pit of Flexibility.

The Cost of Flexibility

Martin Fowler had this comment about flexibility in software:

The cost of flexibility is complexity. Every time you put extra stuff into your code to make it more flexible, you are usually adding more complexity.

This complexity will directly affect your users… which in turn will load down your support staff. You may have the brightest support staff, but problem solving a batch calculation system is a difficult and long business even for a few elements. Once the support staff is spent, inquiries will be sitting on the your door as the developer.

Often these problems aren’t bugs, they’re just buried complexity. Each element on even simple calculations can product a BigO effect on the final complexity of the answer. On applications written by different developers or teams, this problem solving can be compounded even further, taking the style and approach of each developer into account. So how do we as programmers shift these efforts back where they belong, so we can catchup on the latest 360 FPS find something more productive to do?

Jumping off the Treadmill

The way off this treadmill is simple: let the people upstream see what your application does, let them be able to analyze how your application solves the problem. Consider Wikipedia’s entry on problem solving, specifically the characteristics of difficult problems:

• Intransparency (lack of clarity of the situation)
  • commencement opacity
  • continuation opacity
• Polytely (multiple goals)
  • inexpressiveness
  • opposition
  • transience
• Complexity (large numbers of items, interrelations, and decisions)
  • enumerability
  • connectivity (hierarchy relation, communication relation, allocation relation)
  • heterogeneity
• Dynamics (time considerations)
  • temporal constraints
  • temporal sensitivity
  • phase effects
  • dynamic unpredictability

The next time my application is stuck in the Pit of Flexibility, and I cannot reduce its flexibility, I’ll be building time into my estimates for additional interfaces that provide:

• Transparency: context of the solution and problem
• Singularity: ability to find a specific example of a problem or work backwards from a solution
• Simplicity: capability to filter elements of a solution, while offering the completeness of the full answer

My first task here is to get a FogBugz On-Demand account setup. After that, I need to find us a good remote SVN host. We’re looking for something inexpensive and fast, with excellent uptime and a lot of storage space.

I’ll post the results of my search when I’m done. But first, I’m going with my family to Island Lake!