After though

After my initial though, I did not know where to begin. So I tried to write a prototype. It was fun to do. My main goal was to get the priorities of what to do first or to look for new details. After many late hours before going to sleep, I ended with a messy working prototype. Then I note some new details to add to my list.

• Database table naming
• Security - SQL Injection
• Security - Cross site security
• Controller separation
• Prevent Tag soup (by extending the HTML Helper)

With all those nice new tough going on, I received books ordered from Amazon. Code complete 2 and Peopleware - Productive Project and Teams. I stop all coding and start reading Peopleware. I currently have read the half of it and there's good insight on how the environment we work in as a programmer could affect our productivity. I will continue to read it.

Some time have pass since I wrote the prototype and I had an horror vision about it. In the past many prototype have gone into production without major refactoring... And that's definitely not something I want to happen again. Then from horror came light; I found how to set the priorities on points I need to look for. I will begin with the ones I really don't want to be left apart first. The one that will be hard to insert later through refactoring. So I now have a new prioritize list.

1. Test Driven Development (TDD) with Unit test
2. Exception handling
3. layer separation
4. each layer role
5. Controller separation
6. Security - SQL Injection
7. Security - Cross site security
8. Internationalization
9. Prevent Tag soup (by extending the HTML Helper)
10. naming convention
11. Database table naming
12. Data access (will work with LINQ until I got to that point)
13. Explore nHibernate (data access tool)
14. Explore Catharsis (Application framework using nHibernate)
    
15. etc.

After doing the sort, I realize that all tasks can be grouped in a few category.

1. Development process (After it's done, you can change the way you did it)
   
2. Software architecture (All the thing you want in place before writing usable functionality)
   
3. Implementation standard (How things will be written to be easier to maintain)