--Originally published at S' Nami Bog. Servitas Vitae

Throughout my time working with code, developing from zero and testing other’s code we all come to the conclusion that working code that actually compiles (yes I am pulling the typical and cliché meme) does not mean that it is ok for a valid use.

Let me explain, lets say that you are building a project that involves creating many files (10). Some of those files are linked to each other, using inheritance and when you finally want to test them you compile them one by one. Surprise? No compiling errors but guess what pal, none of those are actually linked to its entirety. Then you start to guess what are you doing wrong… I mean all of those compile! Where is the mistake?

Whenever we have those type of problems it is recommended to do the following:

1. Calm down
2. Verify
3. Validate

In other words, the code MUST meet and fulfill the specifications. Obviously it also needs to do its purpose otherwise it is “useless”.

A clear example of a program that needs to reworked would be a calculator. It is very easy to build its UI, place the numbers and operations but whenever the input is written, for instance 5 + 5 the result would be 10 but if it gives you 25,m what is wrong? The tests were not done on its entirety and QOL (Quality of Life) modifications must take place.

It is important to understand that QOL involves doing verification and validation, which both may sound a like but are not.

Verification: The process of checking if the system is being built correctly in every single of its aspects such as the processes. The requirements are set but it does not mean that other aspects are being done correctly therefore a whole new direction is being Continue reading "Mastery 11 – Verification and Validation" →

--Originally published at S' Nami Bog. Servitas Vitae

Whenever we have a problem in our life it’s said that we can solve that problem with over 50 different options and still solve it.

This applies for testing code, the paradigms change how we approach and do the overhaul of the software.

Through the course and the blog posts we have discussed that anything that involves OO needs a different approach but why?

In anything that involves OO = Object that is and must be dealing with another object, think about it as a chain. Checking the output of a OO code is easy, you need to verify that everything is connected and the arguments are fulfilled otherwise it won’t work; nevertheless, when you check an object and a modify version is replaced the chain it created bust be checked as well.

In any case, if the chain of objects is not checked problems will arise and give trouble. As mentioned before the use of Object-Oriented has been the main “discussion” therefore using the concepts and key components is a must.

In this case, inheritance which is arguably one of the key components of good OO programming is in charge of ensuring that the parent object is well implemented and doing all of its functions. In case it is not well implemented the child class cannot inherit enough attributes and any methods that were implemented on the super class, therefore it won’t work properly.

--Originally published at S' Nami Bog. Servitas Vitae

This assignment was cancelled due to an overhaul done by the teacher. His final decision was based on too many stuff to talk about in other blog posts.

--Originally published at S' Nami Bog. Servitas Vitae

I’ve always believed that paying attention in class saves you up to 50% of the work done at home. Why? Just like anything in life if we dedicate enough time it is easy to do. Think about math, you learn how to add, subtract, multiply etc at school and because you attention was only focused on that you get the general idea, the true definition and the main question: Where does it come from?

If we take this to the next level it would be with code. The teacher in most cases uses the projector to display the code and explains not in its entirety but most of the lines of code plus the questions the students may have.

A personal experience is with Java and OOP, one of the main reasons of why most students bail and move to another degree (boooo!)

I took the class with a teacher that took the time to explain even the smallest things but it was up to us to explore the code, use and understand how it works. If you did not practice enough or use the learnt code in other scenarios then you were screwed.

Let’s imagine that classes are a big sandbox in which anything is validated, after that the sandbox becomes a true test with no trial and error. If you missed you missed.

I truly believe that dedicating at least 3 hours to a class that you take two days a week is the minimum to have an idea of how things worked and of course how things are linked.

--Originally published at S' Nami Bog. Servitas Vitae

Throughout all my years at ITESM this has to be one of the very few essays I’ve read with passion of knowing more about it. I truly recommend it to anyone who has the desire of learning how the MIT and New Jersey operate.

There is a lot of information that could be part of this blog post but I think as mentioned before that the MIT and New Jersey are the most important topics of discussion.

MIT has always being of doing not the right thing but ‘what’s fair and square” and they showed it by using a consistent implementation. I also have to mention that consistent and complete implementation is what give its prestige. I mean, who does not want a simple interface?

Throughout the years we have seen some awful stuff but in time they implement new stuff and make it better. Like the song “started from the bottom now we here”, it is exactly the same thing for New Jersey, their ideology goes in that route. They (almost) identical to MIT tried to replicate the simple implementation as well the interface.

As we all know, the MIT is one if not the most prestigious university of the world. If getting admitted is difficult imagine the design they expect? Those are the major leagues, LISP is focused on that. They want consistent, good software and design. On the other side, New Jersey is backed up by C and Unix.

The “awful” implementation of New Jersey has seen the light many times in many ocassions. The long journey of updating and giving the proper service will always be welcomed even if the preview looked amazing.

I have to insist on this essay, they are right. There is a HUGE gap between software that is popular and the high Continue reading "Lisp, the Good news and most likely the Bad News" →

--Originally published at S' Nami Bog. Servitas Vitae

Have you ever wondered how time is relative and how a certain action can be done infinite amount of times? Something called State Diagrams are used for that.

State Diagrams are considered a behavioral diagram which helps to represent certain transitions of behavior. Throughout the readings we have learned that most of the time (if not all the time) software is never static but always dynamic, constantly changing in ways to help and improve our system that constantly changes a class.

In order to give a better approach to this whole diagram theme we will have to go deeper since there are two types of State Diagrams:

1. Behavior Diagram:

• Dynamic changes are always presented in software and this can be related to the commit done in over time. If we relate this with the commit done on Github are to reflect the modeling and of course the construction behind how the system works.

2. Structure Diagrams: 

• It was mentioned before that most of the time software is dynamic and in very weird cases it is static; nevertheless, the way structure diagrams are used could be with an object diagram.

Whenever we are working with diagrams we can have up to two types of diagramas, the first one being component diagrams and the other one being package diagrams. Both may sound similar but they share its unique set of characteristics and are easy to differentiate.

Component

The Component diagram is normally used to execute a very stereotype function, this sounds like a cliché in software but it is the reality. Some examples would be the documents, files and of course the famous libraries that are 99% of the time executed. In order to have a good connection it is necessary to connect the components; nevertheless, in order to work “correctly” Continue reading "UML Pt 2 – M #7" →

--Originally published at S' Nami Bog. Servitas Vitae

UML stands for Unified Modeling Language, it is considered by many a standard language (no wonder why we use it in almost every programming class). It is mainly to have an overall view of what one is working with. Moreover, it also works to start making a documentation, this could apply to database since building a UML based on DB is to store data etc.

UML was created by the OMG. Yes, the OMG which means Object Management Group. UML didn’t saw the light until its 1.0 version came out in 1997. One thing to have into consideration is that although you work with programming UML shouldn’t be compared with python or anything related with programming (actual code).

You could use UML as a starting point. Making a UML for a clock that divides the subclasses and its components such as elements,  behavior etc.

As mentioned before UML is mainly used for modeling and building the “end” product. See it as a blueprint that are used to build dry vans, houses and buildings. Some would even consider it a starting point and move from there. One thing people need to understand is that UML can be used for many things, not only programming. Take for instance a Zoo, you can classify the animals by reptiles, mammals etc. bigger classes that take a larger range of information.

What’s the verdict?

UML is used to create a starting point. It’s great to have a greater idea of what you are building and what you need to work with. In any case, not having all the elements is normal since UML also helps you to see what are you missing, what can you take out or modify. As history keeps moving more programming languages raised and it needs to be worked with Continue reading "UML Part 1 – MS #6" →