I’ve recently returned from the Øredev developer’s conference in Malmo, Sweden where I had the privilege of sharing knowledge with a very eclectic group of technologists . In addition to existing trends such as language agnosticism on the JVM, Agile, and mobile proliferation I noticed 3 emerging trends that stood out. Some of the concepts will be familiar to you and while they are not drastic departures from the past, they are significant and becoming more prominent and recognizable as we near the end of 2009.
1. Processing in the Cloud Becomes Simple
In 2007 I was just beginning to experiment with Amazon’s cloud compute offering, EC2. Not for the faint of heart, EC2 at the time required extensive knowledge of VM images, REST api invocation, and a willingness to do everything from command line. The compute power was cheap, but you were on your own with regards to fail over, load balancing, and offloading of data when your images are decommissioned. This is no longer the case. At the highest level of abstraction are cloud computing frameworks such as Google App Engine and Microsoft Azure which make cloud scale accessible to any developer with an internet connection. Within these frameworks the heavy lifting has been done for us, and we are left with merely connecting our business logic to their persistence or web api’s. The implications are profound in that any simple app can become highly scalable provided you are willing to pay the costs as load increases. There is no capacity planning phase, pre-purchase of blades, or sleepless nights worrying about what will happen if your blog gets slash dotted or appears on drudge. If it’s on Azure or Google’s App Engine, it’ll be able to handle large unexpected spikes.
2. NoSQL
There is a budding movement that describes persistent or data storage api’s that are not based upon relational databases called “NoSql”. Personally I happened upon this design aesthetic by way of weak DBA skills, but other folks have valid architectural and design reasons for eschewing the venerable relational model. I divide them up into 3 main categories; graph stores, hash key-value stores, and document oriented stores. An area where relational databases are having trouble is cheaply scaling to the massive storage sizes applications require. For instance, instead of pitching in for the Oracle site license, Google opted for inventing what it calls “BigTable”. Another problem that the NoSql class tools may remedy is the ability to quickly relate information sans a rigid schema. Graph stores and document oriented databases work fine when previously unknown data types arrive. As we all know, a new data type for relational stores requires a visit to the DBA’s office. The scale big, they run on commodity hardware, and they handle highly interrelated information without foreknowledge of a declared schema. And most importantly…you don’t need to know SQL to use them. My favorites in this category are google’s BigTable, via Google App Engine, and neo4j, as it most resembles the graph structure of RDF triple stores which I’m familiar with. Emil Eifrem of neo gives us a very good summary of many “nosql” offerings and predicts we are moving away from a one size fits all concept of persistence in “NOSQL: scaling to size and scaling to complexity“
3. The OOP Community Rethinks MVC
There is a bit of a small revolution happening in the OOP community regarding one it’s favorite patterns, namely, Model View Controller. MVC was given it’s moniker by Trygve Reenskaug while he was visiting Zerox Parc back in 1978. As a budding OOP student you may have been taught that OOP is essentially a combination of data and the procedures that operate on the data, combined together as an object. For decades OOP developers have sensed that something is not quite right. Evidences of this of this are a general tendency to avoid inheritance altogether (like Google’s Noop), an emphasis on dynamic languages, especially their meta-programming features that allow runtime replacement of behavior, and other techniques like Aspect oriented programming and byte code interweaving. All of these tendencies point to a desire by developers to give their objects new behavior based on the role they are playing in a particular context. One minute I’m a father, the next a son, the next an author and so on. Consider what the “Me” object would look like in your own life. How many methods would it have? I’m sure you’re already thinking that a better approach would be to model the roles you play, and leave the object to merely recording some basic stats. The approach Trygve and others are taking to this problem recently is to codify and declare a pattern that de-emphasizes combining behavior with data, which they are calling “DCI”. Not surprisingly, modern languages are adapting and have innate features that make DCI simple, such as Scala’s “traits”. For languages like Java and C# frameworks such as Qi4j are under development to provide similar features. DCI stands for Data, Context and Interactions. The open-closed principal is still adhered to, as Classes are closed to modification but are opened to extension through injection of roles. I highly recommend you become familiar with the pattern and what it entails.
Out of the three things I’ve introduced (DCI pattern, Cloud computing simplicity, and the NoSql movement) choose one or more and investigate further. If you are a systems engineer, at least two of three should stand out. When architects design systems that utilize a NoSql store, you’ll be the one deploying and monitoring its availability…might as well help them choose the right one. If you are a software developer all three are applicable. And finally, if your role is managerial or executive, knowing these trends will help you spot good talent as well as employ your fair share of jargon and techno speak. For those of you who want to dig deeper I’ve collected a set of links here that will get you started.
Very interesting. Last months i’ve been reading a lot about cloud computing and NoSQL, as the mainstream in the web backend engineering, which is perhaps the most important market of systems administration. But as a programmer it is interesting for me the MVC question. The very-very-easy approach of Ruby On Rails’ ActiveRecord and other frameworks has caused a big controversy in highly escalable environments. In the other hand, I think in semantic technologies and AOP combined as a complex, but powerful software architecture for the World Wide Web, as described by Roy Fielding in his disertation: “a global and distributed hypermedia application architecture”.