Let's take a moment to appreciate how much has improved, in a developer's lot, over the last decade. In particular, contemplate how many "basic" programming concepts and "everybody knows" knowledge didn't exist in your life.
I've written a lot of computing nostalgia articles, from Old-school programming techniques you probably don't miss to Technologies We're Glad Are Dead, and I sometimes fear that there's a little wistfulness in my voice. But the truth is that we (as technologists as well as software creators) are far better off than we used to be.
To highlight some of the improvements, in this post I identify several programming concepts that have entered the "ordinary" developers' awareness in that last 10 years. (I got help from several kind people on LinkedIn.) Perhaps you'll appreciate how far we've come, and how much easier things have become for those who need to crank out working software on a boss's or client's unreasonable schedule. (Or at least we like to think they make things easier.)
The first problem in doing so, though, is deciding what we can claim "existed" a decade back. Because plenty of programming techniques were invented or discovered long before that... they just weren't considered ordinary, a concept that even the most naive of developers are familiar with. I'm not speaking here of competence, just awareness. Or, look at it this way: A decade back, you'd have considered knowledge of these unique enough to call out on a resume; today, it's common knowledge, or so endemic that the technique is built into your development tools.
For example, design patterns were around since the book was published in 1994. But for years their use remained... not esoteric, exactly, but certainly something expected only from senior developers. Arguably, design pattern expertise was how you proved you were an expert. Nowadays, developer tools assume that you at least know what a design pattern is, if they don't offer features to align with them.
Another arguable category — is this "repackaged" or "new"?—is Software as a Service. SaaS existed, kind of, in 1999; we just called them Application Service Providers, and most of them failed because the companies behind them couldn't invent a business model, because they were over-protective of their APIs, because they required a not-yet-extant ubiquity of Internet resources (like common broadband access), and for many other primarily-business reasons. But this, too, was esoteric knowledge and not a topic that developers would discuss at any length. What is different in the ASP-to-SaaS transition, I think, is developers commonly writing applications building on public Web APIs. In 1999, it was still a big deal for your Internet application to integrate with FedEx tracking. Now, an entire Web application can be composed of glued-together APIs.
XML existed, in 1999, but the first conference examining the technology and showing how to use it was in 2000. I attended that conference (and have a coffee mug to prove it). The big issue at the time was whether Microsoft's unique "extensions" had any relationship with the burgeoning XML standard. Everyone took for granted that XML would be a godsend to anyone who needed to exchange data with others, but nobody had invented the term Web services at the time. Service-oriented architecture was far in the future, though all of that, I think, was intimated by the initial promise of XML. And not just XML as a technology, but in its insistence on creating actual web standards to which everyone (even Microsoft) adhered.
One programming methodology that certainly fits in the "last 10 years" category is Agile development, as the Agile manifesto dates from 2001. I think Agile led to many other process improvements, and thus tool enhancements. As one LinkedIn friend pointed out, "Test-driven development, unit-testing tools (like NUnit and JUnit) and mocking frameworks have become widespread and are big improvement over the ways developers tested their code in the previous decade."
And hard as it may be to imagine, Microsoft's .NET didn't exist until 2002.
Surely, we must include Ajax on the list of advances in the last ten years. As with others, all the pieces were in place already, but turning a collection of useful techniques into a package of common tools has changed the way that developers work. The same might be said for any number of open-source development tools, from databases like MySQL to IDEs like Eclipse; initially considered "Well, they're okay for free," they are now overtaking and worrying the proprietary vendors. And while there were application servers ten years ago, in the last five or six years that we've seen the growth of useful meta-applications, such as content management systems, giving developers more than a rough scaffolding on which to build sites and applications.
But those just represent the tip of the iceberg. I expect you could name all sorts of other development techniques and tools that have vastly improved the quality of developers' lives. Care to add a few?
This story, "Gosh, Things ARE Better for Developers These Days" was originally published by JavaWorld.