Here’s an example from Satchmo, the web shopping cart software that is built on the Django framework. A bug involving MySQL was recently patched in the Satchmo code base. The bug fix itself isn’t very interesting, but the remaining code is. Here’s the post-fix code:

def payments_completed(self):
    q = self.payments.exclude(transaction_id__isnull = False, transaction_id = "PENDING")
    result = [p for p in q if p.amount]
    return result

Naturally, I have questions.

Why does the ‘result’ variable exist?

def payments_completed(self):
    q = self.payments.exclude(transaction_id__isnull = False, transaction_id = "PENDING")
    return [p for p in q if p.amount]

What are ‘p’ and ‘q’?

def payments_completed(self):
    query_set = self.payments.exclude(transaction_id__isnull = False, transaction_id = "PENDING")
    return [payment for payment in query_set if payment.amount]

Would a non-programmer understand this?

def payments_completed(self):
    payments = self.payments.exclude(transaction_id__isnull = False, transaction_id = "PENDING")
    return [payment for payment in payments if payment.amount]

Don’t we already have a ‘payments’ variable?

def payments_completed(self):
	return self.payments.exclude(transaction_id__isnull = False, transaction_id = "PENDING", amount__isnull = false)

I think that’s better. What do you think?

[hat[cat] if cat in hat else cat for cat in cats] 

Do you ever want to allow a non-technical user to edit just a part of a webpage? Just one paragraph? Or just some text over in the corner? That’s what Snippetology is for. You create a named snippet of text in the database by using an editor in the Django Admin panel. Then in the the webpage template you include a little tag that retrieves that snippet by name from the database and displays it. From that point forward your user can edit the text in the Django Admin panel and their changes will appear in the part of the webpage that you let them control.

This is basic CMS stuff. Django, not being a CMS, does not do this for you. (Or at least it did not at the time I created this. Things are moving so fast with Django and the surrounding community that there could easily be a solution I’m unaware of.)

Like any good tool, there is an “advanced” use for it. Snippets can contain all sorts of things: tags for embedded videos or Flash animations, or behind the scenes stuff like CSS and Javascript. So anything can be in a snippet. Cool! (Well, cool as long as you trust your users. You DO trust your users, don’t you?)

Next I added a randomizing filter. What the filter does is select a random line from the text in a particular snippet. This makes for interesting possibilities. The randomizing feature was originally requested by a client for a tagline generator. But since then it has become clear that more uses exist. For instance, put a banner image tag with a link tag on each line and you’ve created your own ad rotator. And if you’ve been around the web for any length of time, you know that ad rotators get used for all sorts of oddball things. Which is kind of fun!

Snippetology is a dirt simple idea. It’s not a genius breakthrough type of thing. I think that’s part of why I like it so much. It’s got that Unix tools feel; it does one thing and does it well.

Actually, I take that back: It is now two tools that each do one thing well! I hope I see more opportunities in the future to create little tools like this. It’s fun and makes me think in new ways.

Update (May 14, 2009):
Other people like this idea. In fact, they like it so much that there are at least four other comparable projects out there that do the same thing! Clearly people aren’t finding solutions easily enough. It’s odd to think that this is a limitation of a large network. Yes, the Internet is huge, but you only can see what you can find or connect to. Things outside of your network (people you know, things you see, what you’re capable of finding with search) might as well not exist. How to solve this? I don’t know. It’s an interesting problem though.

Here’s a list of the other projects I’ve found so far that are like Snippetology:

• django-flatcontent
• django-chunks
• django-flatblocks
• django-generic-flatblocks

Release 1: Web app for Client M.

This app was kind of like the MG of projects. Tiny as hell but still kind of fun. The client is a M$ shop, so it’s a .Net app in C#, and it’s main job is to handle uploads of large data files. In this case “large” means 30 MB to 1GB. Not the biggest files ever, but still enough to keep the browser idling uncomfortably long. I went digging around to see if anything could help. I had visions of end users trying to upload files, watching the spinning icon roll in Firefox and not knowing what the hell was going on. I wanted something friendly and understandable. A little searching found some Flash based solutions and some discussion of a Silverlight approach. I was indecisive as hell for a while. Every option came with a catch and tradeoffs! Then, just as I was about to roll my own Silverlight solution, I found SWFUpload. As the name implies, it’s a Flash-based solution. These days everyone has Flash except the tinfoil hat crowd, so I was game and I gave it a try. Like any other widget, there are learning curves and quirks. Even so, it turned out great and I’m very happy. Now my client’s users can see pretty upload bars and can upload a bunch of files at once. An unexpected dose of awesome.

Release 2: New version of Client M’s existing Windows app

“Existing Windows app”? If that sounds boring, you’re right, it is. This is an internal business app I created from client specs about 4 years ago and I’ve been maintaining ever since. New releases roll out about once a year. The app is a .Net/C# dealio than ties into a CRM system. This release added a new database reporting tool. Exciting right? Hey, I never promised to excite anyone with my releases. Hopefully the client will be excited. That’s all I can hope for.

Maybe my software releases would be more exciting if I was focusing on more exciting markets? I wonder what kind of software a nudie bar would need… Thoughts?

I’m going to do 30 software releases in 30 days.

To clarify, I’m not starting 30 companies or shipping 30 products. I’m shipping 30 software projects. Some of these projects I’d like to see pay off in some way. Some are for clients. Others are just for fun.

I have a few reasons for doing this. For starters, I never got my Christmas Wish.

For another thing, I’ve been so busy with work and family the past few years that every time I get an idea for a project (even a little one) I have to immediately shelve it. That gets depressing after a while. It also blocks further creativity. When you’ve got a lot of old “coulda/shoulda” ideas floating around in your head it is hard to get new ideas to grow. I’m hoping to exorcise some of those ideas and be free of them.

And frankly, I haven’t been satisfied with my development velocity lately. My inner prima donna has kicked in and I’ve been spending way too much time on how things should be instead of how things need to be to get out the door. In my last “regular job” I was doing late-stage R&D on a distributed system, so some prima donna action was warranted. But as a self-employed programmer that is bad business!

My software development business has recently slowed in the “New” New Economy, so I figured I might as well hone my skills and “sharpen the saw”. And the sword. And those axes over there…

Some thoughts:

1. It’s not natural to ship software like this. I will very likely fail.
2. That’s ok with me. The personal challenge and the experience are the main points.
3. 30 in 30 is an average. Some days I won’t release anything.
4. What I release will probably look and work like shit until I can refine and polish. No bitching!
5. These won’t be cookie cutter projects. I’ll certainly be reusing code opportunistically, but I intend to mix it up a bit and try some new things out.
6. I only have about 10 firm project ideas right now.
7. I will cheat and fight dirty. I reserve the right to redefine terms, be unoriginal, punch your mom, and declare myself successful at any point, even if all signs point to failure.
8. In fact, I’ve already cheated. I got a head start on this two days ago. I’m rolling out my second release tonight. So yeah, I’m already behind.
9. I’m going to blog brief descriptions of each thing I ship. If time allows I’ll also talk about technical hurdles and miscellaneous geekery.
10. Tempting as it may be, I’m not going to declare that every single build of a project is a new release. That would be bullshit. Then again I’m not going to declare hard and fast rules about what constitutes a release. Or a project. Or software, for that matter. Feel free to call bullshit at anytime in the comments. Just remember that my blog is not a democracy and we censor like Pravda around here.

Wish me luck!

I think it’s a little harder to blow off C.A.R. Hoare. Thanks Tony!

So Kent’s post is titled “Hit ‘Em High, Hit ‘Em Low“, and in the post he describes a debugging technique he calls the Saff Squeeze. It is very similar to a technique that I was taught when I was a junior programmer by my good friend and mentor John Petts. Up until now I’ve just called the technique “break it on purpose”. If I knew we were honoring people with names for things I would have given it a better name, like “the Petts Awesomeness” or something. Still, a name would be good, and Saff Squeeze isn’t really working for me (no offense to either Saff or Beck). If we continue Kent’s football metaphor we might just call it “Intentional Grounding”, but I’d prefer to think of it as “Injection of Failure”.

In Kent’s post he describes the technique in unit-testing and refactoring terms: You have a test that doesn’t work and you can’t spot the problem. So you inline your code-under-test which allows you to move your assertion(s) up through the inlined code until you find the error.

This technique is not limited to unit tests and doesn’t require refactoring. It does require a willingness to break things. That’s about it. Here’s all there is to it:

If you have an error in your code but you can’t tell exactly where that error is, create your own error that you understand and try to place it in the code before the error you’re hunting for.

When I was first taught this trick I was a C++ developer trying to troubleshoot a complicated build that had started failing after I pulled in code from another project. But this technique works great in any complicated system. I’ve used this technique recently to diagnose problems with Django, a Python-based web application framework which can sometimes generate very mysterious error messages. But the place that I’ve had the greatest success with this technique is diagnosing Javascript errors in the browser, where development is often like eating noodles with one chopstick.

The one refinement to this technique that Kent doesn’t mention is to use a binary search to find the bug. If there are a 100 lines of code and you know the error is in there somewhere, inject your own error right in the middle of that code. If the error message or program result changes, you know that the bug lives in those last 50 lines. Otherwise it is in the first 50. Then you repeat, moving your injected error halfway through the remaining code each time, until eventually you find the offending line(s) of code.

***

I work with several different technologies on a regular basis. Lately I’ve been working on a .NET Windows app. It’s one I created originally in 2004 and have been maintaining for a client ever since. I’ve been adding some new database searching functionality to the app.

To display the search data in the app I have a series of tabs, all of which contain a customized listview. Each listview has a Display() method which takes in a list of things to display. The difference between each list view is the subset of the data shown and how each column is treated. (There are some columns with special handling.)

After a while I notice this pattern where I’m going to update only the currently visible list view, so I end up with a dispatch table which abstracts away exactly which Display() method I’m going to call.
I started off with a List for doing dispatch, with each tab’s index pointing into the table. But that bothered me.

Mainly, I wondered, what would happen if I added or removed tabs in the future? I didn’t savor the idea of mixed up tabs or a null pointer exception.

At first I thought a hashtable would have the same problem, but that’s because I was “complifying” it, and thinking about using a string for the lookup – either the tab name or tab text.

Then, “Duh”, I thought, “just use the tab itself as the key”.

And it really is a duh, because I’m pretty sure I’ve gone through this exact same internal dialog many times in the past. Oy.
So eventually I ended up with this:

protected delegate void ListProcessor(List<Item> list);
protected Dictionary<TabPage, ListProcessor> listViews = new Dictionary<TabPage, ListProcessor>();

I’m still not so happy with the delegate since it is almost the signature for map(), and that seems like a smell. Also bugging me is some vague nag about polymorphism which won’t quite bubble all the way to the top of my brain.
So, anyway, I go on to set up my event handler which captures a tab change. Except there seems to be some kind of retardation here. If you handle TabIndexChanged, that doesn’t fire if you change the selected tab. You have to handle SelectedIndexChanged instead. Which, in retrospect, makes total sense. But the naming could be a lot better here. I’m still not entirely sure what TabIndexChanged does, although I suspect it has to do with tab-reordering. Still, names matter, and that one naming choice is confusing. Speaking of how names matter, here’s the handler I created for SelectedIndexChanged:

private void listView1_SelectedIndexChanged(object sender, EventArgs e)
{
    UpdateCurrentListView();
}

I wish VS would let you enter the function name as soon as you break it out. I’m going to have to rename it anyway, might as well.
Since I’m calling UpdateCurrentListView() from another place, without the event signature, I can’t just point to UpdateCurrentListView(),
but I can give it the same name.

private void UpdateCurrentListView(object sender, EventArgs e)
{
    UpdateCurrentListView();
}

Better? Worse? I don’t know. Ok, yes, I do know. Better. Just not WOW better. Anyway, onto the meat and potatoes of what I’m doing. Here’s UpdateCurrentListView():

private void UpdateCurrentListView()
{
    listViews[tabControl1.SelectedTab](foundItems);
}

It’s just one line of code, but even though I *just wrote it*, I knew I wasn’t going to know what it did in about 5 mins. I try really hard
not to let things like that go by. People have to read this stuff, and more often than not those people are me!

The name “listViews” made sense for the dispatch table when I was first setting it up and inserting functions into it. Actually *using* it didn’t make sense at all: “listViews” sounds like a *list* of *views*. In reality this is a list of functions.

I also am not a big fan of the automatically generated names VS gives things. It works well enough, but it doesn’t scale at all. You can only have so many textBox15’s before you gouge our your eyes and swear you’ll stop programming forever.

Then there’s the list of items that will be displayed. That list is shared among all of the views in the containing class. When I originally created it, “foundItems” seemed like a friendly name. But down here (at this level in the code) you’re not thinking in terms of things being found. You want to have a more generic idea of what you’re dealing with.

Some refactoring gave me:

private void UpdateCurrentListView()
{
    displayOnTab[tabs.SelectedTab](SearchResults);
}

I realized that while my dispatch table was technically a list or collection, the way I’m using it is as a multi-dimensional function. So why not just name it like a function?

So that’s what I did. Also, I’m only using one TabControl. Might as well go with a friendly name like “tabs”. And SearchResults is generic enough so that I don’t stop and think about the data but specific enough so I have a mental picture of what is happening in the UI when this code executes.

This reads fairly well, is only moderately redundant, and it has a decent English flavor: there’s a subject acting with a verb upon an object.

Good times.