Software Verification and Validation

Validation and verification are two different concepts in software engineering, each one can be abbreviated to the questions: are we building the right system? and are we building the system right?


Validation is concerned with checking that the software actually satisfies the customer’s needs and its objective is to demostrate that the product fulfills its intended use when placed in its intended enviroment, whereas verification is the process which checks if the software is functioning correctly and its objective is to ensure that work products meet their specified requirements.


The difference between Verification and Validation

Verification vs Validation


User Interface Design

User Interface Design focuses on anticipating what users might need to do and ensuring that the interface has elements that are easy to access, understand and use to facilitate those actions.

The reaction or the experience of the user when ising software doesn’t only depend on the functionality and the aesthetically design, what more influences the user to feel comfortable or not is the user interface.


Gestalt Design Principles

Similarity: occurs when objects look similar to one another.

Continuation: occurs when the eye is compelled to move through one object and continue to another object.

Closure: occurs when an object is incomplete or a space is not completely enclosed.

Proximity: occurs when elements are placed close together.

Figure and Ground: The eye differentiates an object from its surrounding area. a form, silhouette or shape is naturally perceived as figure, while the surrounding area is perceived as ground.


flickr photo by Isaac Kohane shared under a Creative Commons (BY-SA) license

Best practices for User Interface Design

  • Keep the interface simple
  • Create consistency and use common UI elements
  • Be puposeful in page layout
  • Strategically use color and texture
  • Use typography to create hierarchy and clarity
  • Make sure the system communucates what’s happening
  • Think about the defaults


Software Maintenance

Software maintenance stands for all the modifications done after the delivery of a software product. A software maintenance is needed in order to mantain our software up to date.

Modifications in the software may be required because of changes in the market conditions, changes in the client requirements or even host modifications.

There are some types of maintenances based on their characteristics:


flickr photo by Pia shared under a Creative Commons (BY-SA) license

Corrective Maintenance:

This includes modifications and updates done in order to correct or fix problems, which are either discovered by user or concluded by user error reports.

Adaptative Maintenance:

This includes modifications applied to keep the software product up-to date and tuned to the ever changing world of technology and business environment.

Perfective Maintenance:

This includes updates done in order to keep the software usable over long period of time. It includes new features, new user requirements for refining the software and improve its reliability and performance.

Preventive Maintenance:

It aims to attend problems, which are not significant at this moment but may cause serious issues in future.


Open Source Software

Open Source Software (OSS) is software which source code and other rights, that normally belong exclusively to those who have author rights, are published under a software license compatible with the Open Source Definition or are part of public domain.

Now users are able to use the software for free, change, improve and redistribute the software.

There are several Open Source licenses, such as GNU General Public License (GPL), MIT,  Apache License 2.0, Mozilla Public License 2.0 etc.

Mapa conceptual del software libre

Mapa conceptual del software libre – René Mérou – – CC BY-SA 3.0

Here’s how to fix a linux computer

By the Oatmeal, have fun.


How to fix a Linux Computer – The Oatmeal

Software implementation

Implementation is carrying out, execution, or practice of a plan, a method, or any design, idea, model, specification, standard or policy for doing something. It also is the action that must follow any preliminary thinking in order for something to actually happen.

Software implementation encompasses all the post-sale process involved in something operation properly in its environment, including analyzing requirements, installation, configuration, customization, running, testing, systems integration, user training, delivery and making necessary changes. Sometimes “deployment” is used to mean the same thing as “implementation”.

Usually it starts with negotiating a contract with a vendor. After a contract is agreed to and a project timeline is established, key business units must meet to discuss the organization’s future roadmap.

Each department must agree on clear, quantifiable and well-defined goals for the project and what they each hope to gain out of using


Flying Pig. Flick Foto by tsaiian.

the new technology.

Key players in the implementation process typically meet regularly to discuss the project’s progress, voice concerns and augment procedures as necessary.

After the process for any hardware or software implementation moves through the planning stage, companies should gradually test the new system until it is ready to fully go live.

A subsection of tech-savvy workers within a company is enlisted to try the new system because they would be most keen on picking out glitches or shortcomings of the system to further help the implementation process.

Software implementations should always be designed with the end user in mind and the implementation process usually benefits from the user involvement and support from managers and other top executives in the company.



Software Testing

Testing? Who has time for that? Said most programmers in history.

Testing is actually one of the most important steps in the software development life cycle, software testing is the process of executing an application or program with the intent of
finding software bugs. It also can be used to see if the intentions of the software were made, validate or verify that the program works as expected.


Via 9gag :v

Testing can be classified in two types, static and dynamic. Static is the examination of the program’s source code, is somewhat implicit because text editors automatically check  source code and syntax, so the program is not needed to be running for this kind of testing. On the contrary, dynamic testing involves the examination of the software when is running, and is used to verify that the program works according to the functional requirements.

There are different software testing approaches and I’ll only cover a few here, these test are implemented in the order specified:

  1. Unit test
    • The most basic testing mechanism at the developer level.
    • Narrow and well defined scope.
    • Isolate the code from outside interaction.
    • Focuses on very small unit of functionality.
    • Dependencies are hard coded while testing.
    • We need to check further that when these units are combined they work in a cohesive manner which lead us to the next testing approach.
  2. Integration test
    • Developer level.
    • Mechanism to test the inter-operation of smaller units.
    • Test modules which access network, databases and file systems
    • Reveal the issues related to network modules or databases, and more importantly, in the connections between smaller units of code.
  3. Functional test
    • Check for the correctness of the output with respect to the input defined in the specification.
  4. Smoke test
    • A simple test is done from the start typically after a fresh installation and newer input values.
    • Crashes are there to indicate trouble.
  5. Regression test
    • TBugs that typically which affect the core areas of the system.
    • Retest all the modules of the system.
  6. Acceptance test
    • Every feature is checked from the user’s perspective by the testing team and the feature is marked accepted or rejected.
    • Test the application from end user’s perspective like detecting crashes after going through a certain flow.
    • The results of these tests are very subjective in nature and it takes a while to figure out the exact issue in the code.


6 Different Types of Software Testing Methodologies

Software Design patterns

What are Design patterns?

Design patterns are optimized, reusable solutions to an everyday programming problem. A design pattern is not code and it is not language specific, it is a template that has to be implemented in the correct situation. You have to pick the right design pattern that fits your situation, otherwise it could lead to disastrous results.

There are three basic kinds of design patterns:

  • Structural
  • Creational
  • Behavioral

Why should we use them?

Design patterns are, by principle, well tough out solutions to programming problems. Many programmers have encountered these problems before, and have used these solutions to remedy them. These solutions are tested and proven to work well in the right conditions.

Structural design patterns

These design patterns are all about Class and Object composition. Structural class-creation patterns use inheritance to compose interfaces.


  • Adapter
    • Match interfaces of different classes
  • Bridge
    • Separates an object’s interface from its implementation
  • Composite
    • A tree structure of simple and composite objects


  • Decorator
    • Add responsabilities to objects dynamically
  • Facade
    • A single class that represents an entire subsystem
  • Flyweight
    • A fine-grained instance used for efficient sharing
  • Private Class Data
    • Restricts accessor/mutator access
  • Proxy
    • An object representing another object

Creational design patterns

These are about class instantiation. This pattern can be further divided into class-creation patterns and object-creational patterns.

  • Abstract Factory
    • Creates an instance of several families of classes
  • Builder
    • Separates object construction from its representation


  • Factory Method
    • Creates an instance of several derived classes
  • Object Pool
    • Avoid expensive acquisition and release of resources by recycling objects that are no longer in use
  • Prototype
    • A fully initialized instance to be copied or cloned


  • Singleton
    • A class of which only a single instance can exist.


These design patterns are about Class’s objects communication. Specifically concerned with communication between objects.

  • Chain of responsibility
    • A way of passing a request between a chain of objects
  • Command
    • Encapsulate a command request as an object
  • Interpreter
    • A way to include language elements in a program
  • Mediator
    • Defines simplified communication between classes
  • Memento
    • Capture and restore an object’s internal state
  • Null Object
    • Designed to act as a default value of an object
  • Observer
    • A way of notifying change to a number of classes
  • State
    • Alter an object’s behavior when its state changes


  • Strategy
    • Encapsulates an algorithm inside a class
  • Template method
    • Defer the exact steps of an algorithm to a subclass
  • Visitor
    • Defines a new operation to a class without change


Images from:–net-12752