You Are Not A Lawyer

Difference between them and us?

  • Techie: If you don’t know how to do what I do, then learn.
  • Lawyer: If you don’t know how to do what I do, pay me $500 an hour or your children

This comment, found over on Seen On Slash, is funny because it’s absolutely true:

Difference between them and us?

  • Techie: If you don’t know how to do what I do, then learn.
  • Lawyer: If you don’t know how to do what I do, pay me $500 an hour or your children will die penniless in the gutter.

I Have N.A.D.D. (and I’m proud of it)

I  have NADD – that’s “Nerd Attention Deficiency Disorder.” And I’m proud of it. (Rands – of Rands in Repose – does a great job of describing what NADD is, if you’re not familiar with the term, or if you can’t grasp the concept right away).

I  have NADD – that’s “Nerd Attention Deficiency Disorder.” And I’m proud of it. (Rands – of Rands in Repose – does a great job of describing what NADD is, if you’re not familiar with the term, or if you can’t grasp the concept right away).

It was after seeing “Show off your N.A.D.D.” that I thought “gee, I have a lot of windows open too… I wonder how my desktop looks in comparison?” So I took a screen shot during a typical session at my computer.

Suffice to say, it’s… well maybe you should just look for yourself.


For a better view, click the image to see a full-sized (that’s 1280×1024) picture.

Let’s face it – there’s a lot of stuff going on there. And I’m aware of all of it. There’s a virtual machine running, a Subversion checkin in progress, Visual Studio, 2 IP-phone applications (eyeBeam, the one you can see, and Skype, which is minimized), a Remote Desktop session, 2 email programs (Outlook and Thunderbird), and… well I think you get the point.

Although I must admit, I’ve actually brought a number of apps to the foreground that are normally minimized so that you can see them. At any given time, I rarely have more than 2 or 3 windows “active” and in the foreground. Anything else gets minimized – or better yet, sent to the system tray (sorry, taskbar notification area).

Oh and in case that wasn’t enough going on, I should mention that my desktop background (or wallpaper) changes randomly every 15 minutes (thanks to the awesome John’s Background Switcher program), cycling through a well-organized folder of wallpaper pictures I’ve collected over the years. What can I say, I just like to be surprised whenever I switch windows!

One of the things that this picture fails to capture, however, is the number of tabbed interfaces in use. At first glance, there may appear to be only, what, 8 or 9 windows open – but consider this:

  • Firefox at any given time has at least 3 tabs open – usually many more
  • Pidgin, my IM client, uses tabs to keep multiple conversations in one window
  • Visual Studio uses tabs for each open file

And then there’s the programs that I’ve minimized to the notification area – Skype, Process Explorer, a bandwidth monitoring app, GoToAssist Express, Witty Twitter, Thunderbird, Outlook, Pidgin, and of course Winamp.

What’s that? You didn’t see Winamp? Ah, sorry – it’s right at the top of the screen, partially transparent – so I can see it, but can still see through it enough to read the title of any window that might be maximized.

You might also notice that I’m using Windows Desktop Search – that’s because no matter how well organized my files are, there are still times I can’t find things – and often a search is faster than even looking it up even if I do know where it is!

And that’s just my computer’s desktop. My real-world desktop is just as bad.

There’s a notebook to the left of my keyboard, for jotting things down or working out things visually (my “scratch pad”). There’s also a small digital photo frame here, too, which rotates randomly through a bunch of my photos (of my wife and our rabbits mostly).

On the right side of my desk is a smaller notebook, for jotting down the names of songs as I listen to music (I put together “mix” CDs of different types and use the notebook to “compose” the playlists in advance, so I don’t have to sort through the thousands and thousands of songs in my library when I want to make a CD.)

Further to my right is a big whiteboard. Whiteboards are awesome. They may be “sooooo last century,” but they’re still awesome. Sometimes you just need to write or draw out what’s in your head to help get it straight.

Some people might wonder how I can possibly keep this all straight – but the fact is, I really have no problem with it. To me, managing this much information just comes naturally. In fact, if I don’t have this much going on, I sort of feel… bored?

Maybe it’s just a natural reaction to the information-centric world we live in today, or maybe it’s just a particular mindset or type of personality – whatever it is, it makes me ideally suited to doing what I do.

And whether you consider this to be a skill, a personality trait, or a terrible disorder – I, at any rate, am proud of it!

A Programmer’s Perspective on Politics

Election time always finds me musing on the nature of politics. Of course I must admit that being a computer programmer colors my view of the whole process more than just a little bit.

I mean, I know that the political process in this country is one that has evolved over (literally) hundreds of years – and the common law tradition that we use is even older than that. And while part of me thinks that something so old ought to be inherently trustworthy, the programmer part of me can’t help but think that it’s a little… obsolete?

I mean, it makes sense… if you think about it. Let me explain:

Laws are the “operating system code” of a Society

This is not as far fetched a metaphor as it might seem. After all, what is computer code but the instructions for how a computer should operate – and laws do the same thing for the society (or government). You could say that the Constitution in the United States is our “OS kernel”, and the US Code (which is absolutely enormous, by the way) is the Operating System. Various federal regulations and agencies’ rules make up the applications.

Image courtesty Flikr user umjanedoan
(Image courtesy Flikr user umjanedoan)

When you think of it that way, you can see that our system has more than a little bit of “cruft” in it. In fact, there’s a whole lot of cruft in there – after all, our legal system has evolved over more than 200 years, growing rather organically. If we were looking at a similarly aged computer program that had been expanded, built upon, patched, and repaired in the same way, every sane programmer who looked at it would recoil in horror and demand that the whole thing be thrown away and re-written with maintainability in mind.

Of course whether doing that to our laws and Constitution would be a good thing is somewhat up for debate. Of course, the ones doing the debating are usually legal scholars – one has to wonder what sort of decision would be reached if we put some programmers on the job!

It is Important to Eliminate Ambiguity

There’s a commonly understood legal principle that if a law is so complex that an average person has no hope of understanding it, then the law is a bad law and might even be declared null and void. After all, people can’t obey the law if they can’t understand it!

The same thing goes for (good) code. If you can’t understand it, then it’s not good – no matter how well it might work in practice. With programmers (good ones, anyway) the importance of eliminating ambiguity permeates every aspect of their being – it comes out in the way they communicate, and you can see it quite clearly in their code. If something isn’t inherently understandable, there’s comments nearby to help you. It seems to me to make sense that we hold laws to the same principle.

Ambiguity takes another form as well – computers are very simple-minded, when all’s said and done, and they need their instructions very clear without any wiggle room for misunderstanding – or else you’ll get bugs.

Providing Error Handling / Exception Handling is Important

People make mistakes, and it’s also impossible to consider all possible outcomes. That’s why having a good error-handling strategy is key to designing a robust computer program – and the same applies to a legal system, as well.

Image courtesy Flickr user Jims Junk
(Image courtesy Flickr user Jims Junk)

Right now, error/exception handling is handled by the appeals process, and ultimately the Supreme Court. Issues “bubble up” to the Supreme Court in the same way that unhandled exceptions “bubble up,” eventually triggering an OS exception or being trapped by a debugger.

It goes without saying that having such a system is important (because errors happen), but like in programming, exceptions are computationally expensive and slow down the entire system. Throwing an exception should be a last resort – and when you throw a lot of exceptions, you slow everything down. The same goes for our court system – when there are lots of cases and appeals pending, everything just gets bogged down.

As in programming, having the system to handle errors important, but it’s also equally important to limit the number of errors that “bubble up” to higher levels, and to try to handle errors locally, before they get out of hand and bring down the entire system.

Continuous Upgrades

Some people would say “if it ain’t broke, don’t fix it,” but it’s a fact of life that computers change – hardware gets replaced, and upgrades are pretty much a fact of life. Thus, code must be updated to handle these changes. Likewise, the society on which our laws “run” is constantly evolving as well – and laws need to be “upgraded” to handle these changes.

There are lots of lists of old, weird laws that are still on the books in many states – and at the Federal level, I can only imagine the old, outdated laws that are still lurking in the corner of some ancient statute. As with code, it would be best for everyone if we took the time to go through the old laws (old code) and remove the stuff that isn’t relevant anymore – or at least update it so it reflects current society.

Look at laws related to things like copyright and search & seizure, and how they are being bent, twisted, and pried into “fitting” around things like digital archiving, the Internet, and so forth, and you’ll see why keeping your laws up-to-date is important. I’d almost say that the main part of a politician’s job should be reviewing and updating old laws, rather than always trying to write new ones.

Ease of Use (Usability)

This is less of a programming point and more of a UI-design point, but the two are closely related so I’ll let it slide.

No matter how awesome a program is, it’s useless unless people can figure out how to use it. People shouldn’t need to hire an IT professional every time they want to change their desktop wallpaper or install a new program. And by and large, programs today do try to make it as easy as possible for the user – to the extent of doing extensive usability studies and so forth.

If laws and statutes and regulations are the “programs” of our government, then it’s fair to say that their usability is… pretty crappy. Why else would we need to hire specialists (lawyers, tax specialists, accountants, etc.) to understand the law, or require police to read a simplified version of people’s rights to them when they are arrested?

Take the tax codes as an example. Most people have only the vaguest idea of how it works, and they use some default settings (1040-EZ) to get by, even though there might very well be better options for them. If the user can’t find these options, or can’t understand how to use/apply them, then they might as well not exist!

We need the legal equivalent of the Ribbon UI from Microsoft Office 2007 – or maybe the UI from Apple’s OS X or iPhone – to help people actually USE the laws that have (ostensibly) been created for their benefit.

Wrapping it Up

As I said, maybe it’s just because I’m a programmer that I think about these things in this way – but somehow, I can’t help thinking that having a few programmers in politics – or teaching some politicians to program – might not be as bad a thing as it might sound to some. Being a programmer and a geek does tend to come with a particular world-view, which does of course color the way you see things.

However, when you stop thinking about politics and law and government as being “special” or “sacred,” but instead just think of them as another system in our lives that needs to be managed, you can see that applying what I’ve talked about here – what is basically just common sense – is really in our best interests. I can only hope that eventually more people will see it that way.

(Images courtesy Flickr users umjanedoan and Jims Junk, licensed under a Creative Commons Attribution 2.0 Generic license and a Creative commons Attribution-Noncommercial-No Derivative Works 2.0 Generic license.)

A Walk through Windows History

I freely admit, I’m a bit of a history nut. And I also admit I use Windows, and have used Windows for pretty much forever. I should also mention that I’ve personally owned just about every version of Windows to ever exist, at one time or another.

Finally, I should mention that I’m a bit of a pack rat – that is, I don’t get rid of old things. Sometimes this is annoying – other times, it can be very useful (or at least entertaining).

This is one of those times.

Thanks to the wonder of Microsoft Virtual PC 2007, I was able to resurrect both Windows 3.11 (for Workgroups) and Windows NT Workstation 4.0 – both of which are versions of Windows I haven’t personally seen in many, many years.

It may seem rather boring to some, but to me, it’s like a stroll down memory lane. Feel free to browse through these pictures I took (gotta love the new gallery feature of WordPress) and share your own memories of Windows long past!

Legal System as a Perl OS?

OK, you really do have to be a geek to understand this, but that doesn’t make it any less funny:

Our legal code is almost entirely like an entire operating system written in undocumented Perl.

  • There are no hints as to what any part of it is supposed to do and it is written in a language that to most people looks like line noise.
  • Every significant patch is applied by adding an additional Perl module that overrides an existing method in an existing module, replacing all of the code in that method with a complete new copy of the method that is almost identical to the old one but adds or removes a backslash in a single regular expression.
  • The entire core logic was written in a crunch session by a bunch of geeks locked in a room together and forced to design it by committee.
  • The application was a rewrite of another application that never really worked well in the first place.
  • Every function name is chosen explicitly to provoke an emotional response in the developer, e.g. thisFunctionSucks() or callMeNow().

It’s funny because it’s true.