Post Mortem of a big js project (Part I)

Well, it seems ages since the last time I updated my blog, I really think is time to shove some dust off my blog.

Where did I'm vanished?

I was really busy on a project, in which I put lot of effort, I'm now to a point where I can consider the project to be quite stable so I can finally relax and return back here to write something about this.

I thought it was a good idea to write a post-mortem of this project.

Well. Let's start.

I was told to rewrite a really complex application originally written in vanilla javascript, because it needs to change it's UI.

After a little talk to the original application writer we comes to the conclusion that we can't only extend the old application to support the new UI but we need a total rewrite from scratch.

We only had something like 6 months to rewrite an application that was written in the span of 3 years with lots of features, in the meanwhile we even need to introduce more feature that wasn't expected to be introduced 3 years ago.

We immediately thought that we need to plan ahead what we will have to develop.

So we split the project in 2 big parts, the front-end and the back-end using an "MVC/MVP" approach,
in this way while he was concentrating on his parts, I could developing the new UI.

Both of us were sure that we needed to use a framework or a library to ease our work.

So we start to seek for the framework / library that was better suited for our needs.

He was quite sure to take jquery, but I was confident that we needed a better way to write our code, because, after all, it was one of our biggest problem.

The old application teach us that it was extremely important to write our code in a future proof way.

So, since I saw the benefits of good Object Oriented in my C# experience, I thought that we needed something that could force both to write more reusable code, enforcing the Object Oriented way to write javascript code.

With OO code we could have easily apply the TDD techniques that we both wanted.

After this considerations, It was pretty natural to me to follow the MooTools path, and I can tell you now that was a wise choice :)

Immediately after we started writing our firsts objects we feel the needs to automatize some tasks, like the merging of our little class file into a big script.

So I start to wrote the tool (a c# page) to merge together the classes, and to run our JSSpec page.
In the process of writing this page I included JSCoverage to made the code coverage of our tests, and I think this move was really smart, because we discovered that JSCoverage fails if it finds a syntax error in the code.
So technically it was as if we had a javascript compiler, that tells us that something was wrong even before running the page, not only that but it was amazing because JSCoverage returns the row where the syntax error was founded!

With a few tools we have TDD, BDD, Code coverage and syntax error applied to our js project. Marvelous.

Speaking of tools I found mootools really handy when we need to do a profiling of our application, it was as simple as writing a mootools mutator (https://gist.github.com/570711)

... but I'm seeing that this post is becoming too long, so I think I will continue it another day. bye ;)