In a recent post I wrote about the craziness of just measuring the things you do to build something, without ever measuring the quality of the thing you build.
Imagine Michelangelo Buonarroti measuring the force and angle of his blows on stone without any sense of the beauty of the statue emerging from these blows?
Imagine Usain Bolt clocking his sleep time, his training time, his eating time, his Playstation time, but somehow failing to clock the time it takes him to run 100 meters!
Sure, that's crazy. But it's EXACTLY what happens in software development, enhancement, and maintenance projects.
Now, software projects do suffer from the Michelangelo problem: how do you define and measure the "goodness" of the software you produce?
Usain has it easy in this regard. How can we make the software product measurement problem less like Michelangelo's problem and more like Usain's?
Here's how we at CAST define and measure the quality of the software you produce.
For any given technology/language, CAST goes right down to the smallest unit of that language/technology. All metrics below are captured at that fundamental unit level and then rolled up all the way to the application level. The application-level metrics are also rolled up to the application portfolio level. An application may consist of many different languages and technologies -- that's a major strength of the CAST platform: it provides an end-to-end view of the entire system from database, to application logic, to middleware, to business logic, to the user interface.
There is extensive documentation on how each metric below is defined and how it is computed. But it's worth a short explanation here. CAST measures the degree to which an application satisfies a set of rules. At the foundational level, you can think of CAST as three things:
- a set of highly sophisticated language parsers (to parse source code in 30+ technologies/languages),
- a knowledge base of 900+ rules of software engineering (culled from the engineering specs of the technology, industry standards such as SEI, MITRE, ISO, etc., and field experience from our existing clients), and
- a highly sophisticated comparator or rules engine that calculates the degree to which an application's components (and hence the application as a whole) complies with the 900+ rules of software engineering.
The language parsers and the knowledge base or rules evolve to keep pace with changing technologies, languages, and software engineering standards and practices. They rules are kept up to date by our engineering team.
Rules in the knowledge base are classified by technology/language. For example, there is a set of rules for Java and another distinct set of rules for C++. There is also one general set of rules that is independent of technology/language.
Each rule in the knowledge base is assigned a series of weights - each weight tracks that rule's contribution to a quality metric (weights can be zero). A complete assignment of rules to weights is called a Quality Model. The weights of the quality model can easily be tailored to particular production environments in which the systems operate.
Once the source code of the software system (multi-tier, multi-platform, multi-language) is parsed, the rules engine goes to work assessing the degree to which each basic component of the system complies with all rules that apply to it. Some rules will apply to sets of components; for example, how a set of UI objects calls a database object.
Quality measures are rolled up to two high level metrics: The Technical Quality Index (TQI) a gross measure of the quality of the software system, and 5 Health Factors:
- Performance - Business Productivity
- Security - Peace of Mind
- Robustness - Responsiveness to Business Needs
- Changeability - Speed to Market
- Transferability - Rapid Knowledge Transfer Between Teams
So there you have it. A way to define and measure the quality of the software output you produce.
When it comes to software, be like Usain!