As the title suggest, we are going to learn something new today! We are going to strictly talk about Software Process Improvement (SPI), which is a methodology that allow is improve (duh) the software that we deliver. Instead of explaining it with a bunch of text, I found an excellent video that gives a brief introduction to the topic:
One thing you can catch from the video is that is not focused on software, but it’s talking about general projects, but it’s an excellent way to get some ground start to what is about to come. Most of this process involves the following:
- Current Situation Evaluation
- Improvement Planning
- Improvement Implementation
- Improvement Evaluation
As the names say, they are all focused on improving the current state of a software. To explain more in detail about the SPI I am going to explain some of the methodologies that are used.
The Capability Maturity Model integration (CMMI) is a model that focuses on the behavior and organization, it’s objective is to provide organizations with processes to encourage productive environments and a streamline that it can follow to do efficient behaviors that can lead to problems at software development. The model consist on the following:
As seen on the image before, it follows the same old pattern of any other iterative process, but the important thing here is that is focused on the people, with the training and system implementation and the internal audit, where they take a really quantitative approach about the efficiency in the project parties.
A great resource to read into a more in depth approach about this model can be found at this article.
The Personal Software Process (PSP) is a structure that helps engineers to measure and improve the way the work. It helps develop skills in a personal level in the way you do your own work or projects, this is a basic structure of how it looks like:
A blog post that I really like (and the one I took the picture before) is from Juanjo’s blog where he explain into really deep detail about PSP, just a heads up, is in Spanish, but you can use a translator ;).
All the abilities that are compiled in this are a requirement to work as part of a Team Software Process (TSP), which is a process that develops huge programs, that require more than thousands of lines of codes and are intensive, one example that you build with this type of process is something like high quality medical software. A great video I found for this process (in case you want to know more) is the following:
Now we enter the real of ugly names that you won’t probably remember other than ISO-1something, the good thing is that is has another name! It’s also known as Software Process Improvement Capability Determination – seriously? – (SPICE for short).
When we talk about standards ISO always comes to play with us, SPICE establishes requirements to evaluate processes and models of of evaluation, where evaluation requirements are as follow:
- Evaluation of processes.
- Improvement of processes.
- Evaluation of capacity and efficiency of the processes.
Well, what the hell is all of this? Basically is a standard to determine how a process is evaluated to verify if our requirements are achieved or not, and catalogues them as a “maturity” level, in the following image you can see the way they are classified:
This almost Microsoft model consists in a set of good practices and process to manage the development of software, it’s based on processes of small and medium companies, making it ideal for startups, or in small development departments and software maintenance, it’s main focus it’s on the process of the basic structure of a company, dividing it by top executives, management and operations, in which it evaluates effectiveness, productivity and continuous integration in each one of them.
One important thing about this method is that is Latin American, so English information about it it’s scarce, but there is a version of the process in this link, which is a translation from the original one.
Initiating, Diagnosing, Establishing, Acting & Learning (IDEAL) is a model that gives a roadmap to reduce defects during the start, planning and implementation processes. The main process as seen on the model image above are as follows:
- Initiating: Careful and thoughtful planning for successful future.
- Diagnosing: Determine what is recommended and set strategies and priorities.
- Establishing: Plan actions.
- Acting: Do those actions.
- Learning: Whatever went wrong, learn from it and improve it in the future.
For more in depth reading, please refer to the user’s guide where they explain this model in detail.
In the end, we have a lot options that we can use to improve our software quality in the future, and also have many tools that we can focus on depending on the thing we want to build or work on. Is important no now that, as I said in my post about software life cycles from a year ago, there is no absolute or ideal model that can be used in every project, you must seek for tools and analyze what is best for you.
Have a great day 🙂