Last decade, known by many as the Naughties or Noughties, set the stage for a number of key software development trends. Here are some of the hottest of those trends and resulting challenges developers will face in the next 10 years. Initially, the goal of this piece was to come up with a “Top 10” list — to name the top 10 software development advancements of the last decade. But I quickly compiled a list that went well over 10 items. And when I asked various friends and trusted sources in the industry for their opinions, the list only grew further. So this list will feature many more than 10 key trends in software development from over that last 10 years, and will be delivered in two parts. The list is in no particular order or ranking, other than that SOA is first because it became a big deal early in the decade. But other than that the list is not ranked chronologically or in order of importance.
1. Web Services/SOA
The first technology trend of the Noughties I’d like to call out is that of service oriented architecture (SOA), which burst on the scene in the early part of the decade and made things crazy for a while. SOA defines how to integrate widely disparate applications for a world that is Web based and uses multiple implementation platforms. Springing from the foundation of pioneering Web services standardization efforts of Microsoft and IBM, SOA became a big buzzword early in the decade, prompting many an ad and marketing campaign to include the term “SOA.” Some companies, such as SOA Software changed their names to reflect the significance of the term and technology to the solutions the IT issues of the day. Originally named Digital Evolution, the company changed its name to SOA Software and claimed the URL: www.soa.com. However, IBM has perhaps been the most successful at monetizing its involvement in the SOA craze, by focusing its WebSphere middleware line at the SOA world, encouraging customers to start pilot SOA projects, and mobilizing its massive services arm to help take customers beyond the pilot phase.
As the trustworthy creator of Java, Sun’s James Gosling, told me, one of his observations for the decade is:
“Distributed computing has become the norm. It’s not just ‘SOA’ the specific architecture based on X M L that was popularized in the middle of the decade, it’s ‘SOA’ the general term for service oriented architectures that include techniques like REST and raw sockets.”
Dion Almaer, co-founder of Ajaxian.com and co-director of developer relations at Palm, said, “SOA bombed at first. WS-* was the EJB [Enterprise JavaBeans] of Web Services and no one cared. However, SOA is back with the emergence of rich clients on the Web. But instead of being WS-* SOA it is just simple REST services.”
2. The Rise of Open Source Software (OSS)
Open Source Software reached critical mass in the decade of the Noughties. The open source model caught on like wild fire among developers and quickly became adopted by entrepreneurs looking to build companies by providing services for these OSS technologies. And it worked. Marc Fleury founded JBoss around the JBoss application server and later sold the company to Red Hat for more than $350 million. Rod Johnson founded SpringSource around the open-source Spring Framework and last year sold it to VMware for $420 million. VCs saw an opportunity and began to get behind the best and the brightest. And organizations such as the Apache Software Foundation (ASF) and the Eclipse Foundation sprang up to, among other things, foster community involvement in various open-source projects. Although the ASF was founded in 1999, it saw some of its best days in the Noughties.
OSS had such an impact on the industry and on software development that tightly closed Microsoft was forced to acknowledge it. After initially trying to ignore and then show hostility to OSS, Microsoft had to come to grips with the reality of OSS and had to create its own (mostly) open source community, CodePlex. Microsoft has since spun out the idea of its CodePlex project hosting effort into the CodePlex Foundation.
Several factors led to the emergence of Open Source Software, including that developers often felt they could hack their own solutions and that they were sick of seeing vendors slap up to an 80 percent markup on proprietary systems. Not to mention that it was a way to tweak Microsoft and keep some money from going into Bill’s pocket.
However, another factor was that the industry didn’t need the kind of innovation in proprietary software that it did when the problem for customers was all about automating previously manual processes. Now that the problem is about improving what we already have, the existing software vendors don’t have a business model for that. Open source does — one of the ways you improve a product is reduce its cost, in this case by sharing the R&D.
David Heinemeier Hansson, creator of the popular Ruby on Rails Web development framework, told eWEEK he believes the Noughties were the decade of: “The dominance of open source: The entire stack is now free and most people only look at commercial alternatives for very specialized setups.” Although “shops trapped with Microsoft are the exception,” he added.
Grady Booch, chief scientist for software engineering at IBM Research and co-author of the Unified Modeling Language (UML), told me: “Whereas most early open source projects were just rehashing older commercial things, we’ve seen real innovation of late (e.g. Hadoop) that has produced major subsystems that contribute to a lot of production systems.”
3. The Web becomes the Number One Development Platform.
Hansson said: “The Web becomes the number one software platform: RIA [Rich Internet Application], this, RIA, that. The regular Web has proven to be the number one software platform despite all the dooms mongering.”
Added Booch: “Google is on the rise, and they have in effect contributed to creating the next development platform — but I’d add folks like Facebook and even Salesforce — the net being that operating systems have become a commodity, and the Web is the new development platform that
emerged during the Noughties.”
Emergence of Web Frameworks
4. The Emergence of Web Frameworks
With the Web as the development platform, the need for Web development frameworks became paramount. This is where Ruby on Rails caught steam and started to roll and along at a fast clip. Then came others like Django and JBoss Seam to name a few. Says Hansson: “Before this decade, most everyone where rolling their own home-brew frameworks. Today very few bother. I’d like to think that Rails played a big part in this.”
5. Web 2.0
Spawned by the blossoming of Web services and the underlying foundation of SOA, the Web 2.0 craze hit by the middle of the decade and has been at the heart of all kinds of new computing paradigms and startups with new business models. The term is commonly associated with Web applications that facilitate interactive information sharing, interoperability, user-centered design, and collaboration on the World Wide Web. Examples of Web 2.0 include Web-based communities, hosted services, Web applications, social-networking sites, video-sharing sites, wikis, blogs, mashups, and folksonomies. Tim O’Reilly is credited with having coined the term Web 2.0.
6. Simple Beats Complex
Although the Noughties saw its share of complex systems — as systems began to scale to enormous proportions (which will be part of the next installment of this series) — the decade also can be viewed as one where simple solutions easily beat out complex ones. For instance, Hansson said: “Simple beats complex: Ruby over Java, Rails over J2EE, REST over SOAP, etc, etc. Complexity fell out of fashion.”
7. The Rise of Scripting/Dynamic Languages
8. The Developer Community Bifurcates
The last decade was one of empowerment for developers – for the uber developers who build tools for others to use, for the programming wizards who use those tools to build software systems, as well as for dabblers, power users and just plain folk who need to put together a quick solution for them or their small team.
Thus, Sun’s Gosling said one observation of the last decade for him is that:
“The community strongly bifurcates into hackers and engineers: hackers prioritize slapping stuff together as fast as possible; engineers take more time and concentrate much more on scalability, reliability and performance.”
Although some might see a disparaging comment there, it was not meant as such. Several of the factors below actually lead to this, such as the rise of scripting languages and frameworks and tools aimed at enabling folks like designers and line-of-business staff to create applications — perhaps as mashups.
9. Heterogeneity Rules
During the past decade it became clear the development world was going to be heterogeneous, despite there being shops that did .NET or Java development. In the end, the systems all had to work together. During the 1990s the industry still believed that a single general purpose programming language might emerge that everyone would use. This was the initial promise of Java, and Microsoft appeared to have similar ambitions for VB. A big-time software architect friend convinced me that the world has changed — his and other major organizations can no longer afford to play the Java versus .NET game.
Besides, during the last decade we saw a shift away from proprietary software vendors leading the way with innovation, new features, new technologies, and new solutions. The balance has shifted to open source projects and to the large Websites such as Google, eBay, Amazon, Facebook and others to reinvent computing for the new century. The vendors appear to be stuck in last century’s battle over the hearts and minds of developers. The Java vs. .NET battles have not died down in their minds even though perpetuating that mentality is probably the last thing on the customers’ minds, my architect friend assured me. Perhaps the most glaring example of the failure here is Web services. This started out as a very simple definition of an X M L message with an X M L based interface and data definition. But the vendors could not allow X M L to be “the thing you develop” since that was not aligned with either Java or .NET. It still had to be Java and .NET that took prominence in the integrated development environments (IDEs). The Web services standards took a beating as a result and ended up being overly complex, bloated and proprietary as a result.
Moreover, we are seeing the big Websites tell the big software vendors that their enterprise products just don’t cut it. Google, Amazon, eBay etc. are not using application servers or .NET or relational databases. Their requirements are just not served by these “mainframe centric” product designs. They need new designs for commodity data centers that are always up and for environments not under control (i.e. not in the glass house).
10. The Emergence of Team Development (and the rise of Agile development)
The folks at IBM’s Rational software unit had the right idea from the start. They set out to create a complete platform for teams of developers to work together to design, develop and maintain software. And the software they helped folks build was serious stuff — complex systems, embedded systems, scientific and defense solutions and more. In short, they fostered the creation of mission-critical systems. Rational wasn’t alone, companies like MKS, Serena, Borland, Telelogic, TechExcel, Compuware, BMC, CA, Genuitec, CollabNet, Atlassian and ThoughtWorks came in to get a piece of the so-called Application Lifecycle Management (ALM) market by providing tools and solutions to help development teams work better together. And IBM later acquired Telelogic to add to its portfolio. ALM tools typically include requirements, development, collaboration, metrics, and reporting components, among other parts.
However, nothing defined the last decade as one focused on team development more than Microsoft’s entry into the ALM space with its delivery of Visual Studio Team System (VSTS) and Microsoft Team Foundation Server (TFS). Former Microsoft executive Rick LaPlante fulfilled his vision of taking Microsoft into ALM before retiring from the company. In a 2005 interview with eWEEK about Visual Studio 2005 and VSTS, Microsoft CEO Steve Ballmer said Microsoft initially looked at acquiring Rational itself, but decided to pass on it and deliver an ALM solution of its own.
Asked in that interview whether Microsoft would be able to transform the team development space with its lower price, higher volume approach, Ballmer said:
“I’ll be shocked if we don’t have super-high market share within a year. I’ll just be shocked. If you take a look at the total number of customers that these high-end development suites have, it’s tiny.”
Microsoft hasn’t shared its sales numbers for VSTS and TFS, but the company has been aggressive in adding to its product, including support for Agile development. A new version of the Microsoft team technology will be available with Visual Studio 2010, expected in April. Meanwhile, IBM Rational delivered Jazz, its super-ALM platform for collaborative software delivery. Also, companies like Atlassian and ThoughtWorks come into the ALM space with Software-as-a-Service (SaaS) based ALM solutions.
The decade of the Noughties also witnessed the emergence of Agile development. Agile software development is the term used to describe software development methodologies (such as Scrum) based on iterative development, where requirements and solutions evolve through collaboration between self-organizing cross-functional teams.
In the last decade, “Agile became the standard,” Hansson said. “In the ’90s it was still somewhat respectable to say you were doing waterfall development. Today it’s a joke.”
“As for a more intense focus on team development, I’d reframe that to say that the pendulum has swung to more agile processes,” Booch said. “With the global economic pressures that have lead to global development — And I mean more than just outsourcing to India and China — and then coupled with the nature of lots of development on the edges of systems, a la scripting, this has fueled incremental and iterative development styles.”
Gosling kind of gets to it cleanly and simply, saying: “Teams go global: It’s common for teams to span geographical regions and time zones. Skype, chat and ‘forge’ sites make it all work. Also, the industry goes global. Software developers can build viable companies based anywhere in the world.”
That’s it for Part 1 of this look at The Decade of Development. Come back to next week to see Part 2. What did I leave out?