Quality Improvement: a 4^th grader’s lesson

“Everything we need for today’s marketplace we learned as kids”

-Huntsman(in his book, “Winners Never Cheat”).

           

            Truly, who would have thought that the lessons we had way back when we were elementary ‘pupils’ will be useful today and even in our careers. Analytical and solving problem skills are important to a ‘komsai’ student like me, and so to other professional developers out there. Thus, it gives an advantage to those who have trained these skills during their elementary years. This leads me to the idea that software quality in software development is also similar on to how we usually solve math word problems back in 4^th or 5^th grade.

             Quality is a vague word and when asked about its definition, one gets a variety of answers. In the following section, I will introduce some ways on improving quality in terms of software development, which is quite similar to solving word math problems. 

1. Understand the Problem

           

        What does the client need? 

       A must thing a developer must do in every  software development process. In order  

       to produce a good quality software, understanding the problem is the key. When  

       one has a full understanding of the problem --  why it  exists, what are its needs---, 

       higher are chances that the  team will be able to produce a program that will address 

       the needs of the clients, is reliable, and has higher customer satisfaction.

2. Identify the Knowns and Unknowns

            The ‘knowns’ refer to the ‘given’ information in a math problem, while the unknowns(usually denoted as x) are those information which the problem is asking.

        Research and gather sufficient information about the stakeholders.

        In software development, there is a tendency for software developers to only look    

        for the things that the client wants and needs. Little do most people know that    

        identifying the ‘knowns’ will be a great advantage to the development. These  

       ‘knowns’ may vary but mostly include having a knowledge on the client’s  background 

        information, their assets, resources, policies and laws. Having a great deal of    

       understanding of these kind of things will give us information on how to   go about  

        the development process.

3. Translate the Problem into Mathematical Language

         List down requirements and other specifications.

         This means translating the client’s needs into system requirements, and writing     

          down specific details on each of the requirements.

          

         Design and Architecture.

         Make a complete and thorough design on the flow of the program. This will serve as   

         a guide on how the actual making(coding) will go about and what appropriate  

         algorithms, programming language, and data  structures to use.

          

          Plot down schedule.    

          This will aid on keeping the team on track with the project deadlines and goals.

                       

4. Solve the Problem

This is basically decoding the Requirements into software through coding.

         The fewer the lines, the better?

         Not necessarily. Software quality is not determined by  number of  LOCs(Lines of 

         Code) of a program. It is not best to measure quality through LOCs, but 

         certainly there are other better means to do it.

         

         Use FPA(Function Point Analysis), instead of LOC

         It is better in determining whether or not a program needs to be improved                 

         since it counts the number of function points in a program, rather than LOCs.

           

           

5. Check your answers

          Review Code a million times!     

          Most developers tend to forget this part after finishing #4 but it saves a lot in terms  
          of time, effort, and costs. Code reviewing will help determine bugs and defects   

          early before even deployment of the software.

          Let others also do a review on your code.      

          Sometimes, we tend to be so   familiar of our code that we can’t notice errors like 

          missing semicolons, etc. It is important that you also let others (your seniors) to   

          review your code so that they can give suggestions on better ways on improving  

          it(like a better data structure to use).

These are just among the many things that can help in improving quality. Most importantly is how interesting it is that these things were already taught to us back when we were 4^th and 5^th graders. (Nah, not necessarily these things, just exaggerating)

This is list out of the learnings I had as a computer science student and back when I was in elementary. Hope it helps!