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

Software Architecture


In a Software Architecture diagram, you show the “skeleton” of your software, is like thinking in layers were you separate by layer the functionality and each layer is intercommunicates with the others surrounding them by priority or programming level.

In this phase of the Software Development Life Cycle the main concern is “what” a system should do while software Design is about “how” a system achieves its goals.
Architecture is a higher level of abstraction and it scopes all of the system, not just the modules like in the design.

Software Architecture focuses more on the interaction between the externally visible components of the system where as the Design is about how the internal components of the system interact with each other. Software Architecture is more about what we want the system to do and Software Design is about how we want to achieve that. Software Architecture is at a higher level of abstraction than the Software Design. Software Architecture is concerned with issues beyond the data structures and algorithms used in the system.



Difference between Software Architecture and Software Design


What is software design?

In software design, you decide for what purpose you will create software, what you are going to make, how is going to look like and what steps or methodologies you are going to follow. Like I previously said in my post of software life cycle, software design is the second step and is like drawing the blueprints of a house.

Software design usually involves problem solving and planning a software solution. This includes both a low-level component and algorithm design and a high-level, architecture design.

Software design is really important, you can’t build something without knowing how you is going to look; remember the story of the beginning of this post, imagine that the box doesn’t have an image and it doesn’t contain the instruction manual, you are on your own to build a Lego castle with all those pieces; it will be impossible, you may build something similar but is not going to look like the one that was intended for.


Unified Modeling Language (UML)

UML specification defines two major kinds of UML diagram: structure diagrams and behavior diagrams.


Structure diagrams show the static structure of the system and its parts on different abstraction and implementation levels and how they are related to each other. The elements in a structure diagram represent the meaningful concepts of a system, and may include abstract, real world and implementation concepts.

In UML you design diagrams that can contain different elements of the software, for example, the most common is the one where you write the name of the class, its attributes and its methods. But it all depends of the diagram you use. In UML there are many different diagrams with different uses and elements that you can write.

Is not necessary to become an expert of UML because is not actually a must for learning actual coding, but is important to know about it because it helps in the design part of software. Creating an UML diagram is like drawing a sketch, is not that important and is unnecessary to put much effort on it, just with understanding the idea is enough.

There are many UML diagrams (13 to be exactly) so in the next section there are only the three most important.

Benefits of using UML:

  • Improves development time
  • Establishes concepts and executables
  • Creates a modeling language used by humans and machines
  • Improves support and control for project management
  • High reuse and reduced costs
  • Models systems using object oriented concepts