Code reusability: don’t reinvent the wheel

As the title says, it is completely unnecessary to rewrite code that it has already been written, it is, most of the time, a waste of your time and effort. With all the open source code available nowadays, it is really probable that you find whatever you are looking for on sites like github, gitlab, bitbucket or any other site, and if you don’t find it, well, then now you know what’s going to be your next open source contribution. You should really focus on writing building on top of what others have already done, also, it is worth to notice that you should be writing reusable code as well.

Some tips on writing reusable code:

  1. Don’t repeat yourself: if you find yourself writing the same code several times, probably you should move that piece of god to a module or something alike.
  2. Make a class/method do just one thing: remember the Unix philosophy? write programs that do one thing and do it well, also, write these programs to work together, the secret is in writing generic code to accomplish one simple thing, then use the output of that as input of another program to accomplish a more complex task, don’t make code too generic tough, or it will be difficult to find a purpose to it.
  3. Write unit tests for your classes and make it easy to test classes.
  4. Remove the business logic or main code away from any framework code.
  5. Try yo think more abstractly and use Interfaces and Abstract classes.
  6. Write code that can be easily extended in the future, for code leverage of course.
  7. Don’t write code that isn’t needed, if you doubt if the code is needed, then it is not, just leave it out.
  8. Try to reduce coupling, avoid modules/classes depending on each other.
  9. code-reuse.jpg
    Continue reading "Code reusability: don’t reinvent the wheel"

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?

vandv

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.

Source:

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.

15857500937_0d43dc49fc_z

flickr photo by Isaac Kohane https://www.flickr.com/photos/52786697@N00/15857500937 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

Sources:

https://www.usability.gov/what-and-why/user-interface-design.html

http://graphicdesign.spokanefalls.edu/tutorials/process/gestaltprinciples/gestaltprinc.htm


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:

16382202136_375d300dbd_z

flickr photo by Pia https://www.flickr.com/photos/omgdolls/16382202136 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.

Sources:

http://swebokwiki.org/Chapter_5:_Software_Maintenance

https://www.tutorialspoint.com/software_engineering/software_maintenance_overview.htm


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 – http://es.gnu.org/~reneme/map/es/ – CC BY-SA 3.0

Here’s how to fix a linux computer

By the Oatmeal, have fun.

linux

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

8900391398_ff5e406e51_z

Flying Pig. Flick Foto by tsaiian. https://www.flickr.com/photos/tsaiian/8900391398/

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.

 

Source:

http://searchcrm.techtarget.com/definition/implementation


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.

code

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

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

  • 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

  • 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

  • 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

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

Behavioral

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

Software Architecture

architecture_venn

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.

software-architect

Resources:

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.

https://sourcemaking.com/design_patterns

https://en.wikipedia.org/wiki/Software_design#Modeling_language

41ec7b5f42e846885c66de22abe0a176