Test me!

“Testing is the process of evaluating a system or its component(s) with the intent to find whether it satisfies the specified requirements or not.” (TutorialsPoint, 2016)

Software needs to be tested to determine if all requirements were met. If there are any errors, bugs, mistakes, or gaps in the system.

Who does testing?

The more the better. Different points of view are required in this process: Normally, there is a software testing team; however, software developers, managers, and users also participate.

It is important to implement this phase throughout the development.

Why? To save time, reduce costs and errors.

Testing never ends

This means that there is always some improvement to the system; therefore, testing is needed to see if there is something to be improved.

Types of testing:

There are lots of testing types including compatibility, performance, usability, security, recovery, comparison, stress, unit, load, regression, system, etc.

Most known testing types are alpha testing which is done at the end of the development phase, where the software is almost complete; beta, where end-users are the ones testing the system supposedly finished; and black-box which tests if the system covers requirements.

Video:

Complete tutorial:

https://www.tutorialspoint.com/software_testing/index.htm


Let’s talk about GOF baby!

So here you are again. If this is your first time, welcome to my blog, and congratulations for trying to learn something new.

What am I talking about?

Software Design Patterns, which are solutions to typical problems that software developers face during development. Trial and error was the method in which these solutions were obtained. A lot of time has been invested in Design Patterns.

What is GOF, and why is it important?

GOF or Gang of Four is the name of the crew that began this movement. Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides published their book Design Patterns – Elements of Reusable Object-Oriented Software in 1994. Their method in two basic methods of OOP (objected-oriented programming):

  • Program to an interface not an implementation
  • Favor object composition over inheritance

For more information visit tutorialspoint

Video:

Short explanation on theory of design patterns in JAVA

Resources:

https://www.tutorialspoint.com/design_pattern/design_pattern_overview.htm


User Interface Design

In my opinion, a high percentage of success that a piece of code can have is based on its user interface design. There might be great programs that are helpful by doing what they’re capable to do but people might just not feel attracted to these due to the lack of an interesting and design that makes users to take a look and try the program itself.

Users experience with technology must be neat and when talking about programming, our programs should have elements that are easy to access, easy to understand and should be useful for the ones that will be using it.

Some of the elements that can be involved when designing an interface could be:

  • Input Controls
  • Navigational Components
  • Informational Components
  • Containers

There are lots of more types of elements but the importance here is giving the users the ones that will let them achieve what you intend to, without making the process too complicated.

The US Government recommends the following practices for designing an interface:

  • Keep the interface simple
  • Consistent and common UI elements
  • Be purposeful in page layout
  • Strategically use of colors and textures
  • Hierarchy and clarity

pexels-photo1As I said before, success in a program can be achieved by great user interface designs. If the program itself works but isn’t attractive, organized and clear for the user, it won’t succeed as we would like to.

If you’d like to check more on the US Government’s recommendations, please click here.


Software design

This entry will be short because it is just a defining post. In the following posts, I will explain software design details.

What is software design? It is indeed the first step of the SDLC. But aside from that, what is it? Well, desingning software means transforming requirements (oh, the important requirements) into something more concrete.

There are different levels of design, from more abstract to more concrete:

  • Architectural: components of the software
  • High level: modularization of the components
  • Detailed: interaction between components
flickr photo by ViaMoi https://flickr.com/photos/viamoi/3638697162 shared under a Creative Commons (BY-NC-ND) license
flickr photo by ViaMoi https://flickr.com/photos/viamoi/3638697162 shared under a Creative Commons (BY-NC-ND) license

Understanding Software Architecture

Software Architecture is the representation of the program that helps to understand how the software will behave. It serves as a guide for the design and the implementation teams. And is the first line of the system’s quality, such as performance, modifiability, and security. None of these could be done without an architectural vision.

61391451

By building effective architecture, you can identify design risks and mitigate them early in the development process. It also gives an approach of the final design.

Like any other complex structure, software should be done on a solid foundation. Any failure in the future could result a risk for the application.

The most important part of it, is to always consider three things: The User, The System & The Business.

Finding a valance between the desire and specifications of each will result on a good architecture, and this will lead on a great application.

But unfortunately there are major problems that are hard to decode. That’s why we always need to think about this major concerns:diossimpson20120507053705

  • How will the users be using the application?
  • How will the application be deployed into production and managed?
  • What are the quality attribute requirements for the application, such as security, performance, concurrency, internationalization, and configuration?
  • How can the application be designed to be flexible and maintainable over time?
  • What are the architectural trends that might impact your application now or after it has been deployed?

The goal of architecture is to identify the things that affect the structure and functionality of the application. Good architecture reduces the business risks associated with building a technical solution.f63aea5b2c0ca768e0cb9d4c0af1a1c40f546b808664bd13da42b6d5899af4b8

The architecture is important in everything, and when talking about software, it’s the base for a good one; you don’t want the users to be mad at you.

 

Source:

http://www.sei.cmu.

Continue reading "Understanding Software Architecture"

Building software

What is it?

“The software architecture of a program or computing system is a depiction of the system that aids in the understanding of how the system will behave.” (SEI|CM, 2016)

Basically, Software architecture is the process of creating a blueprint of your program. What will be its functionalities, applications, method, designs, etc. The main difference between Software Architecture and Software Design is that the architecture will demonstrate what the system will do, and the design will show how it will do it. Software architecture is represented on a high-scale abstract style; henceforth, is just a guide to show developers what the system is intended to do, and what it needs to work.

Video:

References

http://www.sei.cmu.edu/architecture/


Beautifully covering requirements

What am I talking about? Software design. Helping the programmer in software implementation, it is a process that transform user requirements into a suitable form.

What we know?

If you’ve been following my blog posts, we’ve already talked about SDLC, and SRS where we discussed that a document is created to specify user and software requirements. It is important to make it specific, and make use of software terms. The first step in SDLC is Software Design, which changes the view of problem into solution.

Levels

slide_7

  • The architectural design is the most superficial and abstract version of the system. It identifies software as a bunch of components that interact with one another. This is were developers take an idea of a proposed solution.
  • The high-level design breaks the “multiple components” concept of the architectural design, where a view of modules is portrayed and it shows where they interact with each other.
  • The detailed design deals with the implementation part, and its sub-systems, bringing together both previous designs. Defines the logical structure of each module.

Modules?

Modularization is used to divide a system into multiple and independent modules. These modules are expected to carrying out independent functions, and may work as the base for the entire system.

Want to know more?

Read this blog post, where there is a more thorough explanation on the topic.

Video:

Reference

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


Why use Design Patterns

Design patterns are a great solution to common problems during software design . These patterns aren’t a finished design that can be directly transformed into code but a sort of template one can use to solve a problem that can be applied and customized to specific situations.

Design Patterns help speed up the development process because they provide tested development paradigms, they provide solutions for issues that are not always visible at the beginning of the development process, sometimes these issues are only visible when the projects are implemented, this makes patterns a great way to avoid certain risks during and after the Software Development Life Cycle.

Patterns are based on iteration, so code can be reused to improve readability and understandability of the program in general, to avoid problems by providing general solutions that are documented.

There are three main design pattern types:

-Creational Design Patterns
These are mostly about instantiation and the creation of classes and objects by using inheritance and delegation effectively & efficiently.

Here are some examples:
• Abstract Factory
• Builder
• Factory Method
• Object Pool
• Prototype
• Singleton

-Structural Design Patterns
These patterns are about pattern composition and structure so functional interfaces can be composed.

Here are some examples:
• Adapter
• Bridge
• Composite
• Decorator
• Façade
• Flyweight
• Private Class Data
• Proxy

-Behavioral Design Patterns
These are patterns centered on object communication between objects.
• Chain of Responsibility
• Command
• Interpreter
• Iterator
• Mediator
• Memento
• Null Object
• Observer
• State
• Strategy
• Template Method
• Visitor

Sources:

Design Patterns

Designing our surroundings

Software Design focuses on the way internal modules or components of a system interact with each other so it is not the same thing as Software Architecture. This the “how” phase of the Software Development Life Cycle.

This process transforms the user requirements into a developer friendly understandable and specific format that the programmer(s) can later code and implement.
An SRS (Software Requirement Specification) document should be created to assess user requirements, and the design phase finds a solution to the problems planted during the requirement gathering phase.

Charis Tsevis - Calling...
Charis Tsevis –
Calling…
A mozaic with Apple products since 1998. (Best viewed large)
All photos courtesy by Apple
Made in Synthetik Studio Artist, Adobe Photoshop and Apple QuickTime Pro with custom scripts.

There are several design levels to be considered:

-Architectural Design: highest level of abstraction or a general blueprint.
-High-Level Design: a less abstracted view that focuses on how the components of a system can be implemented in modules.
-Detailed Design: Detailed designs of systems and subsystems that defines a logical structure for each module and the communication interfaces.

Some keys for good software design are:
-Modularization: Often used as a technique to divide a software system into many small segments called modules that should carry out independent tasks.
-Concurrency: Changing sequential execution into concurrent means splitting the software into independent modules that can be executed in parallel.
-Coupling: a measure for defining the level of inter-dependability between modules, for example: content, common, control, stamp and data.
-Cohesion: A measure for defining the intra-dependability of the elements of a module, for example: co-incidental, logical, temporal, procedural, etc.

Sources:

Difference between Software Architecture and Software Design

Software Design Basics

Software Development Brief

Hi there! Let´s take a look about what steps needs to be covered to Develop software:

http://www.computerhope.com/jargon/s/softdeve.jpg

Prerequisites

First, you need to set up what needs to be done, how and maybe where.

This is commonly forgiven for the students to are starting in Software Development Process. Is always the “Let´s do it” and not the “How” what we think about.

So first, check what are going to be the main characteristics of your project, the main idea and stablish a work plan.

Design

Once you´ve set up a Prerequisites list/work plan, you need to start designing, it doesn´t mean having all the project in one area or all the idea stabliushed. Remember, Development is changing ideas and evolving this ideas thorough the process. Design means start with the idea, it can be pseudo-code or a draft code.

Implementation

Then, you need to clean your draft code, so the result can be implemented in the application phase. This is due to the excesive existence of bad code on the world and if you want to be a good SD´per you need to make the thing a good way.

Testing/Debugging

Here, maybe the hardest of the phases, at least for me, in this step you need to “patch” all the mistakes or fix all the bugs the code or the project has. This is harder because if you are keeping all the bugs to the final you are going to be losed in a bunch of bugs. Let´s have a time to debug in each step, and in this phase you can make your project be more efficient.

Documentation

This is one of my favorites, in this phase you need to explain what you made, Even if it is in the code (I prefer that) or in a special document. Please follow

Continue reading "Software Development Brief"