Final Reflection

            It is the end of the semester, and my modeling system’s skills have gotten stronger than I thought. At first, I thought that I wouldn’t learn with this type of blogging method, but now I know that I was terribly wrong. I have found a new way of learning that not only helps me to understand a concept in an in-depth way, but also to develop my writing skills into a more specialized way. I really did enjoy the process and wish that more subjects were like this one. Even though I did not learn all the types of design patterns, or all of the tools that one can use to make a great code revision, I still think that with the knowledge that I acquire I can easily look up for that information and know what I’m doing with it.

            This final reflection will also cover the last main topics that were investigated to have a closure on all of them and understand that now I can use all of the blog posts that I did. My first and second reflection states the other two lists of topics and discussions of them, so in this final we can start with the last topics and at the end have a final ultimate conclusion (I like how that sounds).

            There were supposed to be five topics covered in the last segment of the class but the last two were optional and I did not have time to finish them. (Let’s say that is true) But the other three topics were actually very useful to me because in my present I’m still learning the tools and concepts of verifications, validations and observations in coding projects. Those three topics were code revision, verification and validation, and testing with object-oriented programming.

Code revision

            In the developing process there must be a way of checking if the written code is correct and functions in the way it is supposed to. But before that, one must make a code revision to find bugs and check for problems that we cannot find at first glance. Code review has many types of practices and ways to evaluate your own code or the code of someone else. The importance is to identify if the code has a great structure for some other developer to understand. Also, it is important to analyze the complexity of the algorithms that are used so that with the revision the code can be upgraded to a more efficient and faster one. With this, one can evaluate a code with many aspects to change or upgrade.

            There are several practices that are used to make revision better and more accurate. We also need to know that code revision is better the more you practice. So, it is always a good time to learn how to do it, and for that you have the Pillars of Code Review. These pillars make code revision what it is, and to really fully understand them one must do it and practice many times to identify them very well.

The first pillar is defining the type of code you are reviewing, this is because depending of the type, one must take different kinds of perspectives whether the structure is the most important factor, or the flow of processes. The second pillar is defining a scope, before starting to analyze the whole code, a scope must be stated so that it doesn’t become tedious to analyze a huge project. It is way better to resolve the problems by parts like dynamic programming. And at last, the third pillar is to make suggestions to improve the code, after giving the whole review to the code, it is important to make an argument of what points or segments of the code should be improved to have a more efficient and powerful software.

Verification and validation

With code revision I learned that it is necessary that after reviewing the code, there must be other steps to analyze and review other aspects of the code like the functionality and good structure of it, and that is were verification and validation come into place. Verification and validation are the process of reviewing a code to check for system specifications and standards that must be satisfied. There are several tools, techniques and tips when doing both of the V’s. From the use of these tools we find the first difference between Validation and verification which is the order that they take. Verification is followed by validation because verification checks that the software will run as a static testing, while validation is used when the software can run, and we want to find if it is what we wanted.

Verification is a process of reviewing and checking for any bugs in the software, and these bugs can be also found with code revision, but the difference here is that code revision does not have tools that make the revision more believable as a verification does. The verification process has specifications and requirements that it must have so that one can be sure that it is developed right or not. The activities involved in verification are inspections, reviews, walkthroughs, desk-checking and many others.

Validation, differentiating from verification and that takes place after it, is the process that checks whether the software is up to the mark of the requirements. In this time, it checks the flow of processes within the software so that it has the efficiency and complexity that it is looked for. Validation is also called dynamic testing because we are using the program as it is intended to. From validation several tools were created like the black box testing, white box testing, unit testing and the integration testing.

Object-Oriented Testing

            One of my favorite topics and the last one is the object-oriented testing. Big software developments use this type of testing when using object-oriented models because of the versatility and big help when diving the code in segments or “objects” as it is. The testing techniques that are used for other conventional coding structures would make the testing of OO systems slower, so that’s why new techniques were made specifically for object-oriented programming. When OO programming was introduced there were many new problems when making revisions and verifications of the code, so the solution was by dividing the code in levels, and for each one of it, a layer of the code would be covered until the whole program was tested and verified.

            The three levels that were created are class testing, which is the one that ensures that one of the classes that makes the whole software must work correctly. This one does not try to check the connection between classes but the class itself. The second level is the inter-class testing, this stage ensures that the connection between classes in the software works correctly. In this time, the connections are the key to know if the code was done correctly. And the last level is the system testing, in this last level we want to check if the requirements of functionality are satisfied. These functionalities cover things like performance, reliability, usability and testability.

            These levels were created to jump the barriers that OOP had brought to the world when it was first created. There are some issues with it that must take in consideration when using this model. The first types of problems are by encapsulation, these ones are created by the attributes and methods that testing cannot check in the same main flow of processes or in the invocation of methods. And the other ones are called inheritance and polymorphism obstacles, which states that test cases designed for base classes won’t apply on derived ones in the most of cases, so with that, testing methods need to be modified to ensure that all derivations can be checked correctly, even though they don’t participate that much in the program.

Final thoughts

            This last topics from my modelling systems’ class where key in my real life cases obstacles because one of my debilities when coding was that verification was very subtle and with poor code revision, most of my coding projects had very hidden bugs or obstacles that with the new learnings I could analyze them correctly and find them in a more exact way. I did really enjoy the virtual conferences that we had with Kent Beck because it helped me with the decisions in my life related to internships and foreign studies. It was really an amazing course and I hope to continue posting more about other topics and courses throughout the years to come.

Allow yourself to be a beginner. No one starts off being excellent.