Now I remember why I like .Net, and why developers need to stop being cute.

I am currently on a project where the entire architecture is J2EE based. I know, I know, I am a .Net developer, so what am I doing on a J2EE project?

Two things:

1) I actually used to work for Java companies doing J2EE development, including BEA. This was ages ago, and we didn’t even have IntelliJ. Blah….

2) I was put on the project because it was a spike of SOA within a much larger project. Since I have extensive ( or at least as extensive as I can have seeing how SOA is about a minute old ) experience with SOA, I was pulled on for architecture help.

Little did I know that I would actually be expected to, gulp, CODE!

So, here I am, on a 5 week project coding in J2EE.

Not to start some sort of Java vs. .Net debate, but I really dislike Java & J2EE. Rather, I really dislike programming in it. It’s just a personal preference. 1 day into the project and I remember why I leaped over to MS for development.

And, it’s got nothing to do with tools, although WebSphere is a BEAST. No, it’s more to do with the environment it self. It’s just too complex and what’s worse, is that Java devs KNOW that its too complex, and they refuse to admit that there are better ways to do things. They resort to ‘platform independence’ this or ‘microsoft sucks’ that. That’s all well and fine, but the bottom line is that J2EE is too damn complex.

People are starting to realize that Java isn’t all that it’s cracked up to be. It’s timing to the market was PERFECT. People were looking for a middle ground between VB & C++, and with the .com boom, a web-friendly environment that wasn’t CGI based.

But now, the honeymoon’s over. People are starting to realize that while they feel good having several layers of indirection and countless patterns for BASIC platform usage ( I am looking at you My. Remote-Service-Facade & Mr. Business-Delegate! I am sorry, but when patterns become so ubiquitous as to be used by default when using a platform, something’s missing ), for 90% of applications out there, J2EE is an OVERKILL.

This is all why I love .NET and why I really love Ruby on Rails. Now, easy there, I am not going to jump off into full blown zealotry mode here. I love .NET for their 80/20 rule. For about 80% of the things you need to do, the BCL is fine. For the other 20%, there is enough extensibility that you can do what you want.

Now, as for RoR, the reason I like it is that one of my favorite idioms is represented within the damn framework itself: convention. For a long time, teams have instilled official conventions to their development. Things like ‘name private variable this’ or ‘put all resource here’. There are HUGE value adds to any team because they associate a common context to otherwise complex code and artifacts. Software development is difficult enough without having to decipher individual programmers’ styles and quirks, especially if they are on your own team.

It’s strange to me when I see teams refuse to do something like this. They always have strange answers as to why they don’t follow this std, or that std. Most of the time it boils down to the programmer wanting to be ‘cute’ and show just how smart they are. Instead of doing it one normal, perhaps even vanilla way, they love to whip out their API doc and find some ‘hack’ that reduces the LOC from 10 to 8. Eww….

Now, within RoR, the framework is built on the idea of ‘coding by convention’ into the framework. Things like ‘All controllers go HERE’ and ‘all domain object go HERE’, etc…. Of course, if you want to say ‘screw it’ to the conventions, you are more than welcome to work outside of them. That’s the reason people are falling in love with RoR: simplicity. Developers are starting to realize a lot of the software that they write is fairly boring. Simple CRUD apps. Many times, the app revolves around the DB, and pulling & pushing things to & from it. It’s very nice to work within a platform that directly supports this.

Now that I have rambled on, I want to say one more thing. Not only has RoR baked in the idea of ‘coding by convention’ into the framework, but it’s also a DSL.Most of the syntax revolves around objects & their relationship, and how those relationships map to the DB. This syntax is built as an extension to the Ruby language it self, which is amazing. To think that you can extend a language with specific syntax & idioms that are related to your particular environment…sounds a wee bit like a DSL to me. Think about being able to do this vertically and not just horizontally.

I know, I know, we want to flex our brains at how we can solve problems, but isn’t it nice when we make problem solving easier and we can really flex our brains at the important stuff? I am sure we will be hearing more from DSL’s, RoR, and the revolt against Java.

Exciting times are coming…