What is Cloud Computing?


Cloud computing or just “the cloud” is the delivery of computing services over the Internet on a pay-for-use basis.

It enables companies to consume a compute resouce instead of havingo to build and mantaing hardware. It also provices self-service provisioning, elasticity and pay per use services.


  • Private cloud: the services are delivered from a business’ data center to internal users.
  • Public cloud: a third-party provider delivers the cloud service over the Internet.
  • Hybrid cloud: companies run sensitive applications on the private cloud while using the public cloud for bursting workloads that must scale on demand.


  • Software-as-a-Service (SaaS): applications run on distant computers that are owned and operated by others and that connect to users via the Internet.
  • Platform-as-a-Service (PaaS): provides an environment with everything required to support the lifecycle of delivering web-based applications.
  • Infrastructure-as-a-Service (IaaS): it provides companies with computing resources including servers, networking, storage, and data center space.

There are a few arguments against cloud computing, such as: it represents a high cost for companies, it can generate many problems, intellectual property issues. This trend is very recent and we should wait and see what else it has to offer. In my opinion, so far so good.


Software Verification and Validation


Verification and Validation are important during the Software Lifecycle because they help us to find and correct errors as soon as possible, thus preventing the delivery of a faulty product to a costumer. Is it a good product or not?

There are two aspects of V&V tasks:

  • Confirms to requirements
  • Fit for use

It’s important to outline the difference between these two terms:

  1. Verification:
    1. Process to evaluate the mediator products to check wheter the products satisfy the conditions imposed during the beginning of the phase.
    2. “Are we building the product right?”
    3. It uses static testing.
    4. A verifier stablishes that the product implements all the requirements documented in the SRS.
  2. Validation: 
    1. Process of evaluating the final product to check if it meets the business needs.
    2. “Are we building the right product?”
    3. It uses dynamic testing.
    4. The validator establishes that the SRS is a true reflection of the user’s needs.


User Interface Design


User Interface Design can be resumed in one word: anticipation. We are all users and when we design an interface we should remember: what is the user going to need to do? are the elements easy to access, understando and to use?

What are the best practices for designing an interface?

  • Keep the interface simple. Best interfaces are invisible, if the design is successful the user can focus in their own goals.
  • Create consistency and use common elements. Create patterns in language, layout and design throughout the site to facilitate efficiency.
  • Strategically use color and texture. Color should not determine much in an interface, it can be used for highlighting.
  • Use typography to create hierarchy and clarity.
  • Interfaces exists to enable interaction, they are designed to do specific jobs.
  • Conserve attention at all costs.
  • Keep users in control by infoming them about the system status.
  • Every screen we design should support a single action of real value to the user.
  • Provide a natural next step, anticipate what the next interaction will be.
  • Appearance follows behavior, someone should be able to predict how an interface element will behave merely by looking at it.


Don’t forget Maintenance


In the software development lifecycle, the last phase (but not least) is Maintenance. Once you delivered software, defects are uncovered, environments might change and new requirementes will appear; thus, software maintenance is necessary. Its objective is to modify existing software while preserving its integrity. It’s also important to apply maintenance activities before the final delivery of software.

Maintenance consumes a major share of the financial resources in a software life cycle. I suppose its because it has no end (or until Retirement).

Preventative categories

There are key issues that must be covered to ensure a good maintenance, basically they are:

  • Technical issues
  • Management issues
  • Cost estimation
  • Measurement


Techniques of Software Maintenance:

  • Program comprehension: To read and understand programs in order to implement modifications.
  • Reengineering: To alterate software to reconstitute it in a new form and to implement it. Refactoring is a reengineering technique that reorginizes the program without changing its behavior.
  • Reverse engineering:  To identify software’s components and their relantionships to reach higher levels of abstraction. Its purpose is to produce graphs from source code.
  • Migration: To modify software so it can run in different enviroments.
  • Retirement: When software reaches the end of its useful life. A previous analysis must be done to make the retirement decision.

As you can see, maintenance can be the most important phaste of the lifecycle, without it, the previous steps won’t be used to the maximum.


Why is open source good for you?


Open source is software with source code that anyone can inspect, modify and enhance. A reason why software engineering has grown so much is open source. Because this type of sofware lets other people  improve and utilize code that can be useful for themselves and for the owner of that software. That leads us to a circle of improvement and innovation in this discipline.

There are also another reasons why people like open source software, such as:

  • Control: you can examine the code and modify it as much as you want to.
  • Training: it helps people to become better programmers. The accessibility of this type of software let programmers to study and learn to make better software.
  • Security: Because anyone can view and modify open source software, then it is fixed, updated and upgraded more quickly than propietary software.

“Open source vaules and principles apply to the world beyond software. We like to think of open source as not only a way to develop and license computer software, but also an attitude” (From opensource.com)

The relevance of open source is to share. Sharing is what helping this industry to become better everyday.


Software implementation


Software implementation is all about bringing clarity in the code, improving its efficiency, reducing coding time and helping others to understand it.

There are different programming techniques, such as:

  • Structured programming: it encourages the developer to use subroutines and loops instead of using simple jumps in the code.
  • Top-down analysis: the problem is broken down into small pieces and each one is solved individually.
  • Modular programming: the code is broken into smaller group of instructions.
  • Structured coding. it sub-divides the modules into further smaller units of code.
  • Functional programming: it uses the concepts of mathematical functions. Functions can be first class and high order, pure, recursive, strict…

Clearly, these techniques are related and can be used in the same code.

Also, is very important to have a good programming style, which is set of coding rules followed by all the programmers to write the code. Most of the time, programmers must work with other people, who will use codes written by other developers. So it’s relevant to make programs readable and understandable.


Design is everything


While I was doing a research abour sofware design, I found a really interesting article by Jack Reeves, who describes a new perspective about this topic.

What do we think about when we hear software design? Well, I think about design patterns and diagrams, which it’s okay. But the article says something different that I like more.

In the software lifecycle we have design, implementation, testing,… And the coding part seems to be in the software implementation, but with extreme programming everything changes, because while you’re implementing you also design, then test, redesign, and so on.

The author of the article says that “real software runs on computers[…] it is not a program listing in C++”. That means the program itself represent a software design. Makes sense? So, practically every sept of a software project is part of the design process.

This idea matches the one discussed in my post about software being an engineering or a craft. The important thing is to know that the real purpose is to help people accomplishing a task.


Software Testing


Software Testing can be defined as the process of executing a program with the purpose of finding bugs, but the fact is that this process is just one part of what a complete Software Testing is. Besides of debugging, testing includes validating and verifying that a software meets the business and technical requirements, works as expected and can be implemented.

I’d like to list some important characteristics of software testing:

  • Testing is a process rather than a single activity.
  • To design tests early in the life cycle can prevent you from having defects in the code. That’s a reason why Agile Development is so cool!
  • Testing can be Static, it can test and find defects without executing code, it includes reviewing documents.
  • Or it can be Dynaminc, the code is executed to see the results of running tests.
  • From the beginning, it’s important to choose what testing we will do, by selecting test conditions and designing test cases.
  • We evaluate to check the results and the completion criteria.
  • Blackbox testing ignores the internal mechanism and focuses on the output generated.
  • Whitebox testing takes into account the internal mechanism.

There are many types of testing:

  • Unit Testing.
  • Integration Testing.
  • Functional Testing.
  • System Testing.
  • Stress Testing.
  • Performance Testing.
  • Usability Testing.
  • Acceptance Testing.
  • Regression Testing.
  • Beta Testing.

You can read more about them here.




Design Patterns


Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides are the authors of the book “Design Patterns: Elements of Reusable Object-Oriented Software”, they are known as the Gang of fourThe book describes development techniques and provides 23 design patterns.

A design pattern is a general repeatable solution to a commonly occurring problem in software design. It is a template that can be used in different situations.

The patterns are clasified in three types:

  • Creational: They are all about class instantiacion.
    • Abstract Factory
    • Builder
    • Factory Method
    • Prototype
    • Singleton
  • Structural: They are all about class and object composition.
    • Adapter
    • Bridge
    • Composite
    • Decorator
    • Facade
    • Flyweight
    • Proxy
  • Behavioral: They are all about class’s object communication.
    • Chain of Responsibility
    • Command
    • Interpreter
    • Iterator
    • Mediator
    • Memento
    • Observer
    • State
    • Strategy
    • Template Method
    • Visitor



Software Architecture

3481530Software architecture is the process of defining a structured solution that meets all of the technical and operational requirements, while optimizing common quality attributes. As many other definitions, it seems simple and irrelevant, but what’s the real meaning of this this concept?

It’s easy to explain what software architecture is. I bet all of us think about houses and buildings when we read the word “architecture”, and I think it’s an adequate analogy. Before you build a house, you have to design the structure and consider all the elementss you need to acomplish the building, and don’t forget about the environment. Well, that’s the same thing with software, before you build it, you need to have a base.

Software must have a solid foundation, it’s important to think about key scenarios, common problems, long term consequences. You must consider RISKS. A poor architecture will take your software to failure.

Build to change instead of building to last!!!

In this industry, everything changes soooooo fast. And your software must be flexible enough to support those changes. I mean, nobody’s perfect, duh. Also, people love updates, specially if they’re curious (like me).