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?

Disclaimer: I am not a medical doctor, nutritionist, herbalist, doula, or massage therapist. I am just some guy with a blog. Consult your own medical professional and/or megacorporate lobbyist before determining what is right for you, your heart, and your arteries.

Few topics irk me more than trans fats. Trans fats (specifically artificial trans fats which are my focus in this post) are what give tasty junk food an incredible shelf life. Chances are good that if you eat fattening prepackaged foods with creaminess or super smooth texture, you’re enjoying the wonders of trans fats. Many commercially fried foods, like chicken and donuts also contain trans fats.

What’s Wrong With Trans Fats?

There are an overwhelming number of things to worry about in my diet every day. There’s high fructose corn syrup (HFCS) in just about everything these days. There’s even mercury in fish. What the hell am I supposed to eat?

Grocery shopping in our household is difficult. We’ve had to make compromises from time to time. There are several things we don’t eat. HFCS is one we absolutely avoid. We’re less radical about other ingredients, but still shy away from prepared foods with nitrates or soy-based ingredients. If you are in the habit of looking at the ingredients while shopping, you can imagine how many items we put back on the shelf.

Trans fats have a special place on our no-fly list though. Unlike many other troubling ingredients in foods, trans fats accumulate in the body. For example, if I eat something with HFCS I may have a crazy sugar high but then I’m done. The HFCS is metabolized and will leave my body. (Or turn into fat on my ass, whichever.) Trans fats, however, have a hard time leaving the bloodstream and even worse, trans fat molecules like to wedge into arterial walls, contributing to coronary heart disease.

This is very frustrating to me. From the time I had my own money to spend as a kid up until a few years ago, not a day passed where I wasn’t pounding trans fat crap into my pie-hole. Which means that not only was I eating poorly and packing on the pounds, I was doing direct, permanent harm to my arteries and my heart!

How to Spot a Trans Fat

Trans fats are delivered primarily in hydrogenated oils. Most often you’ll see the ingredient listed as “partially hydrogenated vegetable oil”, although sometimes the particular variety of oil will differ (palm, sunflower, canola, etc.). A few years back the FDA added a separate line item on the Nutrition Facts panel for trans fats. So now if you want to know if a product has trans fats you can just look at the Nutrition Facts and it will tell you. Well, sort of. See, there’s a catch.

The FDA Gets Metaphysical

Unfortunately the Nutrition Facts doesn’t tell the whole story. While it is true that trans fats have their own line item in the Nutrition Facts panel, it doesn’t tell the entire truth. I don’t know the full story, so I’ll try not to be judgmental of the FDA (see my disclaimer above). What I know is that the food industry was rightly concerned that no one would buy products with trans fats in them. Also, they were having a hard time eliminating trans fats from their products while retaining product consistency and shelf life. So the FDA made a compromise. Food manufacturers can claim that their food has “0g trans fats per serving” if the food has less than 0.5g of trans fats per serving. I think the FDA sees this as just a matter of rounding numbers down. As a numerate consumer it means zero != 0. Which is more than a little confusing.

Products can now proclaim “zero trans fats!” on the package, and what they actually mean is that their product has less than 0.5g of trans fats per serving. I’ve had several conversations over the past few years with people who tell me I’m crazy for not eating a product because the package clearly says “no trans fats”. When I point at the partially hydrogenated oil in the ingredients I just get a blank stare.

SOYLENT GREEN IS TRANS FATS!!

Can you imagine if the FDA had an equivalent rule for ingredients that caused allergies?

“0g wheat gluten!”
“no peanuts”

“I can’t imagine why I had an allergic reaction to these chips. They said no peanuts!”.

“Ah, that’s no peanuts *per serving*, sir!”

Where Is the Point of Diminishing Returns?

Certainly there are safe or near-safe levels of consumption for just about any bad thing. What is the safe level for trans fats? I don’t think it is 0.5g per serving. That’s just a hunch. Again, I refer you to my disclaimer above.

The real problem with the FDA rules for labeling is that we don’t get to find out how much trans fat is in any given product that claims to be “trans fat free”. All we are allowed to know is that the quantity is under 0.5g per serving. So it could be 0.4999g or it could be 0.0001g per serving. There is no way for the consumer to know.

My Wife Thinks I’m Crazy

And you may think I’m a bit crazy also. But I’m not alone. The country of Denmark is crazy too. Denmark outlawed trans fats 5 years ago. Switzerland is apparently also crazy, since they followed Denmark’s lead. And now local governments around the US are starting to ban foods with trans fats. So I may be crazy, but the crazy is spreading.

Let’s Zero In on the Problem

In a perfect world we wouldn’t be forced to ferret out fake food from our diet. Since we have to live with fake food for now, it would be nice if we could have a system where the exact amount of artificial trans fats per serving could be stated. It would also be nice if the “zero” was returned to it’s rightful state of literally meaning “none” instead of “a little bit”. At the very least we should make food manufacturers declare “very low trans fats” instead of “zero trans fats”. Specific numbers about trans fat content would be nice too. Then we would be on the right track.

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

I’m still a functional programming n00b. Which is funny to think about, because I probably know more about FP at this point than I knew about OOP many years ago when I was a junior programmer and considered myself something of an OO expert.

FP newbie or not, I’m still an experienced programmer with my own aesthetic sense of what qualifies as good code. One of the things that has always annoyed me about LISPs is their antiquated use of car and cdr as function names. Certainly once you’ve seen them enough you know exactly what they are and what they do. But as far as skimming code goes, they are awful. They aren’t clear or intuitive to new or casual readers. Even pronouncing cdr annoys me. (I want it to be ‘cedar’. Instead it is ‘could-er’ which sounds like a character from the Dukes of Hazzard.) I feel compelled to wrap them in my own functions just to make friendlier names like ‘first’ and ‘rest’, or ‘head’ and ‘tail’.

Other languages do use the head and tail metaphor directly. Erlang, which I enjoy programming with quite a bit, has an idiom where the head and tail metaphor shows up in the naming convention but not directly in syntax or function names. Instead of extracting the first item in a list with car and the rest of the items with cdr, you unpack the list with a pattern:

Eshell V5.5.5  (abort with ^G)
1> [H|T]=[1, 2, 3].
[1,2,3]
2> H.
1
3> T.
[2,3]

(Btw, Erlang’s pattern matching is far more powerful than I’m letting on here, and it makes this simple head/tail stuff look like child’s play.)

By convention it is understood that H stands for Head, and T for Tail. And that’s fine, but what this idiom often means is that you end up declaring two or three variables for what essentially are views on a list. For example, during the SICP study group we solved a “change making” problem from Ch. 1. Here’s the code I wrote in Erlang. I opted to replace H and T with domain-specific names:

-module(change3).
-export([find_variations/2]).
-export([count_change/1]).

find_variations(0, _) -> 1;		% No amount given.
find_variations(_, []) -> 0;	% No coins given.
find_variations(Amount, _) 		% Amount is impossible.
	when Amount < 0 -> 0;

find_variations(Amount, [Coin|Rest]=Coins) ->
	find_variations(Amount, Rest) + find_variations( (Amount - Coin),  Coins).

count_change(Amount) ->
		find_variations(Amount, [50, 25, 10, 5, 1]).

The spot of interest here is the find_variations method matching [Coin|Rest]=Coins. This creates 3 variables which are, respectively, the first item from the list, the remaining list, and the original list itself. All of which get used in the function.

While I *looooove* the pattern matching in Erlang which allows these fairly clear variables to exist, I wonder if there might be a symbolic way to decorate the list variable to yield a particular view instead of requiring three separate variables to deal with. I came up with a few ideas, but I’m not sure I like any of these. Feedback is appreciated.

Idea 1 – Graphically show head and tail

Head: << List
Tail: List <<

Idea 2 - Borrow from Regex Anchors

Head: ^List
Tail: List$

Idea 3 - Misappropriate Perl's sigils

Head: $List (since the head is basically a scalar)
Tail: @List (since the tail is a list)

All of these suck in their own way, but I think I like Idea #3 the best because it gives you the opportunity to treat a list in reverse without having to reverse it first:

Last item in list: List$
All items in list except last: List@

If Erlang had a syntax like this (and thank god it doesn't), here's what that earlier function would look like, rewritten using syntax #3:

find_variations(Amount, Coins) ->
	find_variations(Amount, @Coins) + find_variations( (Amount - $Coins),  Coins).

I'd like to know what others think about this.

In closing, I'd like to note that Python, my day-to-day language, already has this flexibility using list slices:

def find_variations(amount, coins):
	return find_variations(amount, coins[1:]) + find_variations( (amount - coins[0]),  coins)

Unfortunately, Python is designed to discourage recursion so this is sort of misleading. You wouldn't write a real solution this way in Python.

Instead of digging through bookmarks (which I wasn’t doing anyway) I’d google for a term that I remembered had given me the results I wanted in the past. If that sounds like more work than using bookmarks, let me assure you that it isn’t. Once you collect a non-trivial number of bookmarks you have to categorize them and remember that hierarchy. Which is directly equivalent to just remembering what you typed in. If you think of your bookmark category and bookmark name as a key to lookup your desired results, then you can think of your search term in the same way. And generally your search term is easier to remember. In fact, you don’t even have to remember it: For whatever reason, when I find myself googling for a piece of information I invariably type in the same query or nearly the same query that I typed in last time. Even if months or years have transpired. When your “key” is so directly and humanely tied to what you want it works so much better.

My google-not-bookmarks strategy has served me well for about 6 or 7 years. Lately though, I’ve noticed that Google results have begun to fluctuate dramatically from day to day depending on the topic and the query I provide. So while my search terms haven’t changed much, the results have changed. Lucky for me that my browser remembers (and highlights) which links I’ve already visited, otherwise this system may have broken down for me a long time ago.

I don’t think anything crazy has happened at Google. Instead, the things I tend to repeatedly search for are in a narrow niche of geekdom. I’m sure this has been a problem for a long time for people who regularly google more popular topics. Only as the size of the Internet has increased – and therefore the size of the searchable content – has my neck of the woods finally been impacted.

To some extent this constant change is a good thing. Google offers a hybrid of fresh content and relevant results. So you can watch a topic for changes. You can even google yourself. In fact the how-to-blog crowd widely recommends that you google yourself often to see what people are saying about you online. (They don’t mention how unsatisfying that act is when no one knows who the hell you are and therefore no one is talking about you. Still, were someone to talk about me, Google would tell me all about it.)

On the other hand, I’m losing my auxiliary brain a little bit more every day. For instance, I sometimes have trouble remembering how to make a tarball. I don’t like the two-step process where you make a tar file then you compress it. Instead, I like a nice clean one-liner. Modern tar provides a compression option and will kick out a tidy *.tgz file for you. If only you know the magic command-line options and parameter sequence to get it to do that. Sadly, I never remember. So this is something I google for fairly often. Just in the past week I’ve had to google for this twice. And I know I googled for it a month or two back. And each time found markedly different results. I don’t even know where the site I found a few months ago is, but it isn’t in my search results anymore. At least not on that first page. Sadly, that site from a few months ago had the best instructions for making a tarball.

I guess I should have bookmarked it.

Everyone except the Business Journal. It’s bad enough they have an ugly site design (clean yes, but poorly organized, uninspired, and dull), but they also apparently have some kind of Soviet-era site management software on the backend. Just to make changes to your website account you end up digging around in long screens packed with demographic questions. Not fun. I usually stay away.

This morning they sent an email invitation to join their new “social network”. Because we NEED the fucking Business Journal’s social network! Life just isn’t complete without it. Heaven forbid they just piggyback on Facebook or do something innovative like a custom Reddit. But I digress.

This thing is a mess. You get in there and you have no idea what is going on. As a developer, I can see what is happening. They are handcuffed by the software that controls their site. That software wasn’t created with a social network in mind. Far from it. So to compensate they have to hang new functionality off the side of the site, so to speak. Kind of like the guy in the trailer park who puts an “addition” on his house by connecting a smaller trailer to his big trailer with some sheet metal, green fiberglass shingles, and (of course) duct tape.

This is more than a look-and-feel thing though. By trying to squirm around their handcuffs, they’ve had to split up where your user information is. Some of it is in your Account Settings, and some of it is in your “Dashboard”. (Protip: software isn’t enterprisey enough unless you call it a dashboard.) That might sound like nitpicking, but it isn’t. If you look at every single one of the “newest members” on the site, you’ll see a shadow icon in place of where their profile photo (aka mugshot) should be. Except for me. As far as I can tell I’m the only user with a mugshot because I’m the only dumb bastard stubborn enough to dig around in the site for 15 minutes to figure out where I can upload my pic. And it’s not like these users don’t know how to upload a pic. There’s a whole photo gallery filled with 8×10 Glamour Shots scans that users have uploaded. But no pics on user profiles!

The striking thing about this social networking attempt is how many features they’ve tried to pack into it without actually adding much value. They clearly put some thought into what they would provide, but not any thought into how it would actually work or what true value it would bring to their users. So you can upload some photos or even “start a blog” on their site. But you can’t have a simple URL to your company in your profile or link off to your own blog outside of their site. So it’s a walled garden. And walled gardens don’t work so well on the interwebs.

My advice? Begin with a simple goal which will genuinely serve your users. And get some budget before you try to do this shit. Don’t go in half-assed. Remove all but the most needed new features from the social part of the site. Trim it down so you can build it back up. Add only features that you can prove are valuable. (Hint: Your users will ask for most of them.) Consolidate your information into one place. Every account on the site should have the same type of profile options available to them (mugshot, url, etc.). And consolidate the information in your database too! I can tell that you keep the same pieces of information in several different databases. That’s crazy.

And if your website management or CMS software won’t let you do these things, throw it out and write your own. You’re obviously already doing some of that. Why not go all the way? It’s not hard. There are plenty of open source CMS systems out there to get you started, not to mention wonderful software  platforms that other newspapers are already using.

Otherwise, just pack it in. No one needs another annoying/useless “social” website that isn’t bringing its ‘A’ game.

***

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.

It’s OK to like pretty things. And you know what else? It’s OK to make pretty things too.

That’s right. And not just pretty things others make for you. Not just the candy coated interface you see on your latest OS or on your phone. It’s OK to make your programs pretty too. It’s OK to make your docs pretty. It’s OK to make your website pretty. Pretty pretty pretty.

Aesthetics are important. How you feel about the tools you work with matters. It matters a lot.But making things pretty isn’t just about aesthetics.

Bear with me here.

Beauty is a form of wealth. And wealth comes in many more forms than we imagine. I’m not talking tangible wealth – cars, yachts, bling. I’m talking about something a little more intangible but still very valuable.

I create wealth all the time when I’m programming. Again, I’m not talking about money or the literal value of the code I’ve written. I’m talking about the good stuff that just *falls out* while I’m working. And this isn’t because I’m particularly awesome, it just happens. I  think it happens to anyone who works in a creative field.

For instance, say I am writing some code, and I realize that I’m essentially repeating the same 4 lines of code in several different functions. So I Extract Method and boom, I’ve created some new wealth which wasn’t there before. Of course that is more intentional. What I’m getting at is directly related, but a little different. I’m talking about a sort of accidental wealth. For instance, say I’m doing a lot of work with lists. And I realize after a while that I have several places in my program where I am iterating over lists in the same way. So I pull out that code and consolidate it into one spot. Pretty soon I realize that the iteration function I created is handy in a LOT more places. And not just in this one project, but in all of my projects. Pretty soon I’m coding in a whole new way and I actually start to *think* in a whole new and more powerful way.

I don’t know what you’d call this. There’s probably some huge German word for it which would roughly translate as “the thing that gets you more things without you seeing it at first”.

Beauty can work in this same way. For one thing, there is just the simple aesthetic pleasure of working on something pretty. I remember back in the dotcom days I was working on a site that had a pretty UI designed by some skilled graphic designers. I had to start building out the site with placeholder HTML before we had the UI and it was an OK project. Nothing thrilling, kind of ho-hum. But then the designer’s UI came in and WOW, I suddenly liked working on that project a whole lot more. Of course one of my coworkers was working on an even prettier website, and after a while I really wanted to work on *that* instead, even though I knew that the technology under the hood was awful to work with. Apparently sometimes the grass is always greener, even if the green comes from a spray can. So working on something pretty can definitely improve your attitude about your work, and I would argue that a better attitude improves the quality of your work too.

But that’s not where all the wealth comes from. It’s not just the good feeling you get working on it. It’s the way things play out in your mind. Imagine you’re building an application and you have some objects that get manipulated. I don’t know about you, but for me, when I create new objects, especially ones that live in the database, it takes me a while to believe in the thing I’ve created. Not just believe in whether it will work or not, but to actually think of the thing I’ve created as real. But when you allow yourself to make things beautiful, to make that a priority on par with functionality and correctness, the things you create become tangible. Icons are a great example of this. Icons – good icons – can look great and really add something to your application. I’m not just talking about the icon for your program, I’m talking about the icons you pick to represent things within your program.

Think about a personnel database. The typical app that comes to mind is some byzantine Windows app or maybe a clunky web app which dumps out people’s stats in row after row of icky blandness. Now imagine that instead of row after row of text, there is a thumbnail image of the actual person. And imagine that you can click on that person to get more information about them. Imagine that you can drag that person around by their image. That you can transfer Tricia from Accounting to Distribution Support by literally dragging her from one department to another. Certainly you can do those same things with just text in a list, but it doesn’t feel the same way. You wouldn’t see Tricia as a real person. You wouldn’t *believe* in the idea of Tricia.

And it’s the same way with any entity in your application. Why should only the user-visible objects in your app have icons? Why should only the user-visible screens look nice? It’s very common to have programmers build out apps that look great to the customer, but when the programmer needs to get under the hood everything is fugly and lacks imagination.

That’s not right. That doesn’t serve anyone. And there are unseen opportunities missed! I’m not saying to spend all of your time making things pretty. I still stick by my Big 3: Make it Work, Make it Right, Make it Pretty. But making things pretty is definitely allowed and maybe even downright necessary.

I’m a hater.

I just can’t help it.

Maybe it is the heat, I don’t know. But shit like this just pisses me off, and has for *far too long*:

I DO NOT LIVE IN MOTHERFUCKING FRANCE!

And dammit, Yahoo, you know this. You’ve known me forever. Look – I’m logged in! Read my profile. Or see that I’m connected from a well known ISP in the US, with an IP address which simply *does not roam*. And cookies! You’ve got the cookies.  You can look at those and see every place I’ve asked about. None of those places is in France, or Mexico, or anywhere else you’ve asked me about.

I can’t believe this fail has lasted as long as it has. Why not just go all the way and give me a pulldown list with every country in the world on it. (Be sure to put Afghanistan first on the list and the US way down past Uganda too. Bonus points!)

See how negative I’m being? Feel the hate? It just seems so wrong.

But man, it *feels* so right.

Still, maybe I should be more compassionate. Maybe Yahoo US is underfunded and just can’t make it better. Hey! I know: Maybe the guys at Yahoo Japan can make it better. Seems like they have some extra budget over there…