Its hard to see the “death” of the relational database right now. I don’t think a switch-over from relational databases to non-relational databases is coming – but there is a game changer coming; another new technology getting a lot of buzz and traction in the blog world: Cloud Computing. I think the biggest driver in changing from relational to non-relational databases will be The Cloud.

Microsoft, Oracle, Google, Amazon, RedHat, JBoss, Ubuntu, Rackspace and many others are starting to provide cloud computing hardware, operating systems and hosting services. Cloud computing provides cost effective scalability and resource sharing for web applications. Looking at three of the main cloud contenders out there, Amazon Web Services, Google AppEngine and Microsoft Azure you see three common components:

1. Scalable Computing / Web Hosting computing
2. Scalable File Storage
3. Scalable Database Storage

The first two are pretty obvious and typically similar to traditional architectures, or not that different – however the Database storage is where things change: all three (Amazon, Google, Microsoft) have non-relational engines! While Amazon and Microsoft also have a cloud relational database, each comes at a different cost.

I see Amazon SimpleDB, Google’s BigTable, Windows Azure Storage Tables and others being a big NoSQL driver because of their price and scalability features. Once enterprises start moving into the Cloud and onto Cloud services I think we will see more architects evaluating and pushing for NoSQL.

I know the Unit Testing drum has been beaten for years, so instead of getting on a soap box and berating the Internet for not Unit Testing, I’m going to give you a story about a recent project I worked on, and how unit testing helped me succeed.

It all started last fall when I started work at a new client’s office. I opened the project from VSS and red flags started popping up. The first red flag was that this was a Visual Studio 2005 project and I was using Visual Studio 2008 (they did not install VS2005 on my computer), but this wasn’t really a problem – I was assured that they had standardized on Visual Studio 2008 now and the .NET Framework 3.5. The second red flag was the five projects in the Solution that couldn’t be found in VSS – each one ending with .Tests. I still don’t know why they were removed – but my guess is that they were removed because they didn’t pass.

The first thing I did was create a new Unit Test project. After examining source code thoroughly I created a test harness of unit tests of the existing functionality of the project. This is a very difficult and risky task since these tests are built under the assumption the current code works correctly! This is not a safe assumption when projects are missing from the solution. However, the fewer behavior changes I introduced to a program already in production use the better.

During this period (probably one week) I uncovered and fixed many bugs. I re-factored a lot of code. I did more testing.

Then I added my new functionality, retested and it worked.

I added more tests. They went from red to green.

My confidence grew with each little green light.

I added integration tests to the unit tests. These all passed.

Eventually the program was ready for deployment to the testing server (UAT – User Acceptance Testing) – a model of the production environment. And I was confident! My tests were passing!

This is when everything went wrong.

The Problem? Updating to the .NET Framework 3.5. Of course I had been misled when they assured me that they standardized on 3.5 – the production environment was still very much in 2.0 (and I was strongly assured they would not upgrade – even though I hadn’t asked).

The Solution? Unit Testing! I had extensively used the new productivity features of 3.5 like LINQ and Extension Methods. It took some rewriting and work but I was able to revert and rewrite everything back to 2.0 compatibility in one afternoon! The only reason I could do it so quickly was the unit tests I wrote that told me the functionality was still there and working in the old Framework. It took more time to find another computer with Visual Studio 2005 and the .NET Framework 2.0 installed (and not the 3.5 installed at all) than it took to rewrite the app to the older framework version.

There were more problems that were solved with more testing, but Unit Tests saved me a lot of time and guessing. There were some other things that could have made the project more successful such as better communication with other developers and the production team. Those issues were beyond my control. But I was so glad I had those unit tests, they saved my bacon. They gave me confidence in the completed software. The Unit Tests were also something I could show my client, the maintenance teams, and the testing teams in terms of functionality assurance for them.

Ah success! A new project! Another Solution! …and guess what? No unit tests. *sigh* Here we go again!

Google isn’t the Internet, and they aren’t the only search tool in town, but the idea that Google is stealing your content is pure ignorance. Google drives traffic to your sites. It’s what Google does – sell advertising by getting people to stay on the Internet as long as possible! Having Google link to your content is good news for any publisher!

But then I read this post at Neowin and my mind reeled. Microsoft is encouraging websites/content owners to block Google and partner with Bing, Microsoft’s search tool! OK, way to go Microsoft for trying to capitalize on a billionaire’s lack of internet savvy, but this isn’t good for Bing! But Murdoch wants people to pay for the content on his sites! If I have to pay to visit all of the search results I get from Bing there is no way I would switch from Google.

This could be an opportunity, but Bing is still the real underdog. Google is a real Goliath, but we haven’t found a real David in Bing yet. I wish Bing luck, but I still Google almost everything.

XML Files

Most of the ORMs I’ve used required a lot of configuration in XML files. Probably the worst offender in this sense is NHibernate. L2S, EF and DataSets are bad too, but at least they have tooling in Visual Studio to make it easier to use and hide the XML from you. In this respect, the Fluent NHibernate project is a life-saver for anyone using NHibernate.

POCOs and the Repository Design Pattern

Another thing most ORMs provide you with is an ability to use simple POCOs or Plain Old CLR (or C#) Objects. Ordinary DataTables and Strongly-Typed DataSets come with a lot of extra “clutter” to them, this is especially visible when you’re interacting with them using IntelliSense inside Visual Studio. The clutter appears as all the baggage that comes along with DataTables, as well as the fact you have to use DataAdapters, and fetch row objects (i.e. UserTableRow).

It is really nice to just have a simple class that can do what you need it to within the “domain” (following the Domain Driven Design ideas). It simplifies your data layer model significantly, and of course reduces a lot of clutter.

NHibernate and SubSonic are the clear leaders here, NHibernate even more so, but SubSonic can regenerate mappings after you’ve made changes to your database.

Simple Database Schema Creation

Another thing I like to see in an ORM tool is the ability to take your data-layer mappings and generate a database schema from that. The primary reason is that database versioning during development is hard. Keeping everyone on the same page with databases is difficult and making each developer use the same database is hard to impossible. If your ORM can just create and/or update your database schema for you off the bat, keeping each developer up-to-date is a breeze. No more “why is my app crashing?”, “where is that SQL script?”, “who did this?” shouting over the cubicle walls, instead you just run the update scripts and you’re all set.

As far as I know there is only one clear winner here and that is NHibernate; L2S, EF and Strongly-Typed DataSets don’t have this functionality at all. I believe that the 3.x version of SubSonic does have this now, and version 2.x had a version of migrations (that may be obsolete in version 3).

My Pick for Best ORM

I’ve personally switched from the SubSonic camp to the NHibernate camp in the last year. With Fluent NHibernate and guidance from the S#arpArchitecture projects all real difficult barriers into NHibernate have fallen. SubSonic is an awesome ORM and does help you get up to speed quickly, but it does feel like it isn’t developer or maintained quite as much as NHibernate is, and the differences between 2.x and 3.x versions was so great as to almost be intimidating to me (almost)!

Entity Framework is good, but I’ve had problems with the tooling and updating the mapping schema in the projects I’ve used it in. To me, there is very little programmatic difference with Linq-to-SQL, in fact EF seems to have more functionality. According to what I’ve read, it will have Database Schema Generation in the .NET 4.0 version, but NHibernate 2.1 already has LINQ support (via another library) so EF is really still just playing catch-up.

Strongly-Typed DataSets are pretty much an obsolete technology as far as I’m concerned – from the .NET 1.0/1.1 days. They do provide some simplification over bare metal ADO.NET, but I don’t find them as easy to use as NHibernate or any of the other ORMs I’ve discussed so I’ve seen little benefit in modern projects.

Summary

While I know there are more options out there than just the ones I’ve pointed out, NHibernate is the tool that best represents what I’m looking for in an ORM.

The lack of ownership bothers me, because what happens with those projects now? I would sure like to know! I spent long hours and some late nights on them, sometimes I was the only one working on them. Unfortunately I can’t see what happens now because those unfinished programs belong to my customers.

So (now that I am between unfinished projects) I have started working on some projects of my own. This has led me to learn some new things about myself. Working from home on my own projects requires so much discipline it is almost like learning a new job. I do allow myself opportunities to work on home projects, but I have to be really careful not to let things get out of hand. I don’t want to end up with more unfinished projects!

I’ve also been setting goals for myself as a new company. I’m hoping to start earning revenue through other streams besides just consulting. This is a daunting shift for me, especially because I’m not earning revenue while I’m developing right now. Hopefully some projects will start earning recurring money soon though. That means I have to set priorities.

I’m also giving myself some time every morning to evaluate or re-evaluate my goals and to setup tasks to achieve those goals. This is a little different from what I do while consulting for clients, when I would simply set tasks for the day or week in order to get the project done. Now I am taking an even bigger picture look at the future of my career and the future of my company. I’ve still got a lot to look at, work on, and learn – but it is exciting.

I’m also hoping that the next contracts I will work on will be for longer-term contracts. The last few were under six months, I’m hoping to find work on 9 month+, multi-developer contracts from now on so that I will not only have time to finish them but also work on some larger teams and take more of a leadership role rather than be the sole developer.

I’m also going to keep in mind that not every change is permanent! I’ll be evaluating what I’m working on daily to see what is working and what isn’t. It’s a sort-of “agile” way for me to treat my business, career and life! I’m excited and looking forward to the future.

Oh, and one more goal is to blog at least twice a week. I’ve made that promise to myself before, but this time I’m giving myself time to do it instead of trying to find time to do it in.

I loled.

The thing is, why are these two competing?  They both have their own monopolies in their own right, Google is now a verb meaning to search the web, and Microsoft Windows is the nearly ubiquitous operating system, even on netbooks.

The biggest problem I have with Google’s Chrome OS is that Microsoft is on the verge of releasing Windows 7, which according to many reviewers will be the best version of Windows yet – and it runs well on current Netbooks.  Chrome OS is going to be a ‘lightweight’ OS designed for running a web browser and web-based content.  This will mean that Netbooks based on Chrome OS can only run apps like Google Docs online instead of Microsoft Office, YouTube instead of Windows Media player.

I see the same problem with Microsoft’s Bing.  It doesn’t do anything I’m not already getting from Google search.  It just does the same thing, in the same way.  There is nothing really to help me do more, or bring me better quality search results than I’m already getting.

To promote Chrome OS Google is probably going to provide incentives to both hardware manufacturers, maybe it will run on cheaper hardware?  But it’s not like current Linux and Windows powered netbooks are that expensive.  In typical Microsoft fashion Bing has a huge focus on Developer (developers! developers!) APIs hoping that someone else will make a killer app for them.  Microsoft is a Platform company after all, and Google is a Search company.

We’ll see what happens in the end, but it’s pretty difficult for these companies to switch their identity with consumers.

I didn’t actually speak to the developers myself, but my friend sent me an MSN transcript of their “discussion”.  Apparently tempers grew quite hot!  I did read most of the discussion and spoke with my friend to learn more about the system.

It turns out there would be many transactions with the database and web service coming from these devices with a fair bit of geographic data that had to be processed at the server.  One developer felt that using a web service would  involve too much XML/SOAP overhead and wanted to write his data as XML to the database directly.

I was not in favor of this suggestion.  A web service makes perfect sense in a .NET situation.  It denotes a logical boundary between applications and computers, and would be pretty obvious to any supporting developer what is going on.  Usually two applications do not share the same database (maybe the same server, but not the same database).   This increases complexity.

I was also not convinced that the “overhead” of the SOAP would actually limit the application.  Microsoft has done a lot to optimize web services.  They’re easy to develop now, easy to consume, and as I said: a logical boundary between systems.

In the end I strongly recommended that they do some benchmarking.  This early in the game is the perfect time to test assumptions.  I also recommended using one of the new Service Bus APIs out there that use technologies like Microsoft Message Queues if the web services are too slow.

Also, as Jeff Atwood recommended in his Coding Horror blog, sometimes it is cheaper to throw another $5000 server at the solution (even TWO servers) instead of paying two $70,000 / year developers to spend three-to-six months doing performance enhancements.

As a developer I think it is important to write the API so that it is usable and easy for a junior to understand.  Fluent is one way to do it, but it isn’t necessarily the only or best way!

Some places where I found Fluent difficult to use was if I needed to provide two parameters to an underlying service.  For instance its not uncommon in DotNetNuke to have to provide a User ID and a Module ID to one method call.  A Fluent Interface might say DoSomething.ForUser(userId).WithModule(moduleId), but that means storing the userId.  And to prevent the user from doing DoSomething.WithModule(moduleId).ForUser(userId) you would have to do some tricks with interfaces, and that is just not fun or easy for another developer to understand or use!

Sometimes it makes more sense to DoSomething.ApplyToSomthing(moduleId, userId) – it just does.

Of course, there are always tricks like Func<T> out there that we can use.  Because Func<T> is a .NET Framework feature I would expect another developer to understand how to use it, maybe not a raw cadet just out of school, but the documentation is there on MSDN for us to learn from.  Still I would probably have to define a class and use a lamda expression to use the method.  Lambdas are awesome for condensing code into readable chunks, but DoSomething.Using(p => { p.ModuleId = moduleId, p.UserId }) feels unwieldy to me. It makes a lot more sense in FluentNHibernate than it does in a small API or wrapper because you’re creating configurations and large sets.

So I’m going to be careful with my API designs and continue to make them usable.  After all, the best developer is one who’s code is readable and usable when its done.  And the best code does what it is supposed to but is maintainable by a noob.