Sunday, February 26, 2006

Software that lasts...

There are plenty of concerns that IT Business Strategists and Architects address. On the business side dealing with the value, risk, budget and schedule are important.
On the Architecture side, building flexible, reusable and high perfrormance software is critical.

In many projects the constraints of business and technology lead to many compromises in building truly open software over time.

So what are the 2 critical aspects that projects need to address.

Those 2 things would be PERFORMANCE of the software and MAINTAINABILITY of the system. If Software does not perform well, users will not use it and the project will be dead.
If the software is not maintainable, it will take too many resources to be sustainable.

So how does one always stay on top of these 2 critical elements and adopt proactive infrastructure in the project?
- Performance:
During Business Analysis:
* Define SLA's for the project, and build Proof-of-concepts to give some justification to those SLA's (Something that is more tangible and proves that those SLA's are achievable).
During Architecture/Design:
* Identify the key functions of the application that are business critical as well as high risk from a technology perspective.
* Build Blueprints for building high performance systems.

During Development:
* Build infrastructre in the code so the start/end times of functions are automatically logged.
* Write code with Performance as a critical need(but balance with maintainability in mind).

Check out my other blog with some specific tips on coding for performance...

During Production:
* Build automated scripts that track and fetch timings of methods, and report on methods that take up high CPU usage, and perform slower than the SLA's.

- Maintainability:
During Business Analysis:
* Identify the best Arcihtecture team to build a design to last
* Business Analysis can best identify which business functions are the most critical to be flexible and which are less important to the business.

During Architecture/Design:
* Design to focus on high cohesion between related features, and low cohesion between unrelated features sets the foundation for building maintainable code.
* Formulating Standards for Vertical and Horizontal elements for the project is the key to maintainable code.
* Some Horizontal elements include Logging Strategy and goals, Exception Handling, Constants, Date functions, and other common features in the application.
* Vertical elements include standards and reusable components for business specific features.
* Build best practices and prototype code for the software is critical for consistent and maintainable code.

During Development:
* Reuse: Features that have already been built should be reused, rather than be built again.
* Patterns: Use a consistent style for doing a specific features. This is the key to maintainability. So have a consistent way to get data from the session, use Math libraries, use same validation style.

During Production:
* Automated test cases and continuous builds and tests is the key to maintaining robust applications.