What I’m thankful for as a developer

The holiday season should be a time of rest and relaxation. If you’re a developer, hopefully you’ll get some time away from the keyboard this week to spend with friends and family. It’s not always easy in this business.

Mind you, software development is a lot less painful than it used to be. I’m old enough to remember when performance-critical routines meant hand-coded assembly language and sometimes even keying in machine code as hexadecimal digits.

We’ve come a long way since those bad old days, and not surprisingly we owe a lot of our progress to technology. So for this Thanksgiving, here are just a few of the modern advances for which I, as a developer, give thanks:

Open source tools

Developer tools have benefited more from the free and open source software revolution than any other category of software. When I was learning C programming in the early 1990s, Borland’s offer of an integrated MS-DOS C compiler, editor, debugger, and linker for $150 came as a revelation. Developer tools for commercial Unix systems cost thousands.

Then Linux brought Unix to the masses, and with it came the Gnu Project — compilers, libraries, editors, linkers, debuggers, and all for free. The days of paying for access to header files were over.

In a way, it was bad news for tools vendors. The market basically evaporated. But it was great news for developers, particularly students. These days, you’ll scarcely find a language for which no open source compiler, interpreter, or VM is available. Even Microsoft is getting in on the act — last year it released its F# compiler under the Apache license.

Online documentation and support

Programming manuals were an essential part of my early education. But despite how tasteful the woodcuts on the covers of O’Reilly books were, dead-tree documentation was bulky, was hard to navigate, and went out of date quickly.

These days, I keep a reference or two handy for when I need a moment away from the keyboard, but all the real documentation is up on my screen. Through the Web I have instant access to thousands of pages of tutorial and reference material — whether I’m in my office, at the coffee shop, or on a plane — always current and readily searchable. (And O’Reilly’s been no slouch here — in fact, it’s leading the field with its Safari service.)

Even more significant is the impact of social media. Mailing lists, message boards, wiki-based documentation, and crowdsourced Q&A sites like Stack Overflow give access to on-the-spot training and insight like never before. Finally, developers can move as quickly as technology does.

Modern IDEs

Back in the day, we used to scoff at any programmer green enough to need an IDE to write code: “Whatsamatter, kid? Can’t remember how to spell ‘main’? Real hackers use Notepad!” (Just kidding. They used Vi.)

Today that kind of braggadocio just seems naïve. A modern IDE offers far more than just a text editor or integration with a compiler and debugger. It’s your partner throughout the development process, from application design to coding, debugging, and maintenance.

Where would we be without code completion for boilerplate-heavy languages like Java? Remember how difficult it was to refactor large projects before we had context-aware IDEs? Automatic error checking, class browsers, instant documentation — the list of advantages goes on. Stick to command-line tools if you prefer, but if you’ve never learned your way around an IDE like Eclipse or Visual Studio, you’re probably not as productive as you could be.

Desktop virtualization

Coding is one thing. Testing and QA is another. Once, I might have kept one workstation for development and a few others for testing — machines I’d end up wiping and reconfiguring on a regular basis. Virtualization makes those headaches disappear.

I’m a particular fan of VMware Workstation‘s snapshot management capabilities. I like to take a VM with a clean install of an OS, then grow a branching tree of snapshots as I upgrade the system through various patches, Service Packs, and upgrades. Then, with just a few mouse clicks, I can test the same Web app from four different versions of Internet Explorer at various Windows patch levels, all from the same window on my desktop. When I’m finished — or if something goes horribly wrong — I simply roll the VM back to its pristine state, or to any other fork on the snapshot tree. I honestly don’t know how any developer could live without it.

Distributed version control

Source code version control systems certainly aren’t anything new — CVS dates back to the 1980s or earlier. It’s only been fairly recently, however, that version control systems have been adopted widely enough to be used even on relatively small projects.

Again, we probably have the open source movement to thank. Where once version control might have seemed like a formality, the community-based development model made it a necessity. That in turn led to the development of modern, distributed version control systems like Git and Mercurial that allow developers continuous access to source code trees even when traveling to remote locations.

I, for one, don’t miss the days of managing source code by hand on server directory trees, and these days, I use version control even for personal projects. If only continuous integration systems could be as ubiquitous.

jQuery

I don’t mean to knock other JavaScript frameworks. Some of you prefer Dojo, Prototype, or some other package. I happen to prefer jQuery. One thing’s for sure, though: If you’re still coding plain JavaScript by hand for your Web applications, you’re doing things the hard way.

The problem isn’t really JavaScript, but the DOM. As John Resig puts it, the DOM is a mess. But with jQuery, DOM traversal actually becomes easy, intuitive, and, well, sane, allowing you to skip the headaches involved in adding basic interactivity to HTML elements and get on with the business of coding application logic. Not to mention that it frees you from juggling the various quirks and bugs of individual browser releases over the years. Add the rich community of mature jQuery plug-ins, and you need never pull out your JavaScript recipe book for simple projects ever again.

What’s on your developer Thanksgiving list? Leave your additions in the comments.

This article, “What I’m thankful for as a developer,” originally appeared at InfoWorld.com. Read more of Neil McAllister’s Fatal Exception blog and follow the latest news in programming at InfoWorld.com. For the latest business technology news, follow InfoWorld.com on Twitter.