User Interface Design

User Interfaces, or UIs, are what the user utilizes to interact with a piece of software, it often is graphical and displayed in a screen, but it can also be hardware, like a controller. They are the most important part of the software for end users.

For a UI to be useful and likeable by the user or customer, it must be easy to use, must attract the attention, easy and intuitive to use, consistent and responsive. There are two main user interface categories: Command-line interface and graphical interfaces.

Command-line interface (CLI)

It is the most basic interface and consists only of text characters on lines. The first computers used CLIs to interact not particularly for the ease-of-use, but for the minimal resources consumed by it and the simpleness that it has. The main input method for the CLI is the keyboard.
Advanced users often prefer command lines to execute some tasks, as a graphical interface would be too bulky and impractical.
Embedded and remote systems often use CLIs because of the low data rates that they produce and the fact that they can be channeled through a variety of protocols, from serial to over-the-internet SSH connections.

Source

Graphical User Interface

GUIs are what most common users today know to interact with a computer, they are graphical frameworks to interact with a program often in more simple and intuitive ways than CLIs, the disadvantage of graphical interfaces is that they consume more resources, and often require a graphics processor to generate what is on screen. The main input methods for GUIs are mouse and keyboard.

They are often comprised of "windows" that represent a particular instance of a program that is executing, they provide buttons, sliders and tabs that make navigation a breeze, and change and adapt in order to fit what the user wants to do at a particular moment, responsiveness is crucial for the computing experience to be good when using GUIs.

Source

Lastly, the GOLDEN RULES for GUI design are:

• Consistency: same commands and access methods used everywhere.
• Shortcuts: Users sould be able to use hotkeys or commands to navigate faster.
• Feedback: Even the click of a button should acknowledge the action that is made.
• Defined sequences: opening, usage and closing of a window should be well defined. 
• Simple error handling: Avoiding user errors and if they happen, handle them adequately. 
• Easy reversal: Allow for Ctrl-z
• Support user control: Make the user feel in control of the actions they execute.

Source: https://www.tutorialspoint.com/software_engineering/software_user_interface_design.htm

TC1019 Aug-Dec 2016 Review

First of all, lemme say THANK YOU Ken, for being such an awesome teacher. You are being innovative and have done what no other in Tec. 

My first class with Ken was Fundamentals of Programming almost three years ago, he always had these flipped learning ideas and education methods, but he adhered more to the standard teaching model that we are all used to. There were "normal" classes, "normal" exams and "normal" evaluations; maybe because of the nature of that course (?).

This semester, Ken has gone full #FlippedLearning, and I like it. Twitter is a very good idea for students to be connected and being able to simply "tweet" a new blog post (made when and were students are most comfortable) is very cool. Using a private hosting for the course rather than boring, old blackboard is nice, as more interactive features can be enabled, I like to see how classmates' posts begin to show up in the dashboard. Also, promoting new ways of communication such as Slack is very useful, now I see it everywhere, it happens like the Baader-Meinhof Phenomenon.

As a teacher, or rather, enabler for education, Ken is always trying to help his students succeed and everyone should at least once have a one-on-one talk to absorb personally the knowledge he has to offer. He is very acquainted with software and the industry standards.

Lastly, the course contents have served me as general culture, and are actually useful now that I started working. Had it not been for what I learned here, I would be lost when they mentioned the words "agile development", "scrum" or "stand-up meeting".

Thank you Ken and continue what you're doing :)

Software Design Patterns

Software Design Patterns are commonly used on object-oriented software development, they are previously defined methods to design and code programs, used commonly by experts and corporations that benefit from structured and unified ways to develop and execute. They serve as a common framework for developers and promote good coding practices.

Source

They were not developed intentionally, they were instead created by trial and error and the prevalent ones are the ones that, by natural selection, were proven to be the best ones.
The Gang of Four, are the ones that wrote a book and set the SDP principles down, the book is called "Design Patterns - Elements of Reusable Object-Oriented Software". The two main principles are:

• Program to an interface, not an implementation: Basically programming the classes in order for them to be implementable by other software, resuable and act as pieces of a bigger puzzle.
• Favor composition over inheritance: Classes should implement other classes to complete their functionality, rather than inheriting from them.

There are a lot of desing patterns and not one is always the "correct" one, nonetheless, four main pattern types are defined:

• Creational: Create objects on the go as they are being used.
• Structural: The composition of objects is of most importance, mix and match to obtain new functionality.
• Behavioral: Communication between objects is prioritized.
• J2EE: Presentation layer.

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

Software Design & Software Architecture

These two parts are essential to software-making, they are sequential steps that ensure a program meets the specifications needed and solves a particular problem, let's start with Architecture.

Source

Software architecture deals with the abstraction part of design, it analyzes the problem and sets a methodolgy to solve it, commonly using blocks. The software architect must be very acquainted with the challenge that he is facing, along with the technologies that can be used to solve it. Nonetheless, the SA doesn't do coding, he gives the product owner a thorough analysis and the underlying structure of the program that must be made, including a design blueprint and the attributes and connections of each part that has to be implemented later.

Software Architecture is, in essence, delivering a structured solution to a problem.

Software Design, on the other hand, deals with the technical details of the implementation of the system. They take into account the environment, adapting the development process to it, incluiding software and hardware constraints. They design and guide the coding process, including testing and debugging, in order for the process to be orderly and ensure success.

Software Design creates the functional part of the archutecture plan.

Unified Modelling Language

Commonly abbreviated UML, it is a language, but not a programming one.
It is used to design software and processes from the functionality and structure perspective, using diagrams in an object-oriented environment.
It is maintained and endorsed by the Object Management Group (OMG).

It can be used to model complex systems, and the graphical facilities make it easy for anyone to understand the flows and sub-systems that comprise what is being designed.

UML is based on conceptual models rather than technical ones. Using concepts, it is easy to describe how blocks interact in real life. The blocks are organized and connected using standards defined by the language.

Because it uses object-oriented concepts, it includes all the characteristics relating to them, such as attributes, methods, classes and inheritance. This enhances the power to represent complex models.

To use an object-oriented language, the system must be analyzed from this perspective, this process is called Object-Oriented (OO) Analysis and Design. There are three main steps:
- Identify the objects.
- Identify relationships between objects.
- Design the system and implement it.

After identifying which objects the system involves, relationships between them should be defined precisely, in order to determine the connections and flow of data between the blocks, after that, this design can be used to implement a solution. Although UML is not a programming language, because of its object-oriented nature, it can be easily implemented using OO languages like Java or Python.

Using this method of design and analysis, UML can be implemented. The main focus of UML is to aid in the design and implementation of object-oriented software.

UML uses four types of diagrams: class, object, collaboration and interaction. They will not be described in this article, but more info is available here. This modelling language seems like a good organization method for projects, specially if implemented correctly on a large organization. Finally, an example of an UML diagram can be seen next:

Kishorekumar 62 [GFDL (http://www.gnu.org/copyleft/fdl.html) or CC BY-SA 3.0 (http://creativecommons.org/licenses/by-sa/3.0)], via Wikimedia Commons

Software Requirements

In order to define what a piece of software can do, you have to define clearly the functions and requirements that it must contain for the customer to be satisfied and your team to know what to do and how.

The goal is to arrive at a Software Requirements Specification (SRS) Document, a spec sheet that details what the software can do.

Photo by Nathanael Coyne on Flickr. CC BY-NC-ND

Requirement Engineering is a discipline that aims towards understanding client's requirements and translating them into technical and detailed specifications for the developers, it consists of four basic steps:

1. Feasibility Study: Knowing if what the client wants is possible, taking into account technical, economical, and organizational aspects. This stage outputs the feasibility study report.
2. Requirement Gathering: Getting the expectations of what the software should do from the client and end-users. Requirements must be clear, correct, consistent, coherent, modifiable, verifiable, unambiguous, traceable, and from a credible source.
3. Software Requirement Specification: After collecting information from all the people involved, an engineer creates the SRS, where the client's specifications are expressed in natural language, and all the technical aspects of the project are detailed in order for it to be useful for the development team, including pseudo code and GUI sketches.
4. Software Requirement Validation: Between the developer and client, the specifications are reviewed to verify that they are correct, within scope, and achievable.
5. 
   

REQUIREMENT ELICITATION

It is an organized process to gather requirements for the software, it has four steps.

First the developer gets the requirements from the client, then they are prioritized and categorized, next they are reviewed with the stakeholders to remove any ambiguity or doubts about the requirements, finally, they are documented correctly for the next phases of development.

One or more of these methods can be used in the elicitation phases, each one with its ups and downs:

• Interviews
• Surveys
• Questionnaires
• Brainstorming
• Prototyping
• Observation

Hope y'all learned something from this :)

Sources:

Tutorialspoint: Software Requirements

Mind-blowing! What are APIs? You will be amazed when you find out!!!!

API means Application Programming Interface and they are, in essence, a way to communicate with a certain software or service, in order to integrate it into another application. It defines specifications on how software interacts with each other.

APIs are like building blocks for programs.

They range from the most fundamental functions, like interfacing with an operating system in order to use its functions, to enabling the interactive content and seamless integration that the web experience has to offer these days. 

APIs can be seen often in everyday life, from the apps on your phone to the sites you visit when browsing, it's hard to find a digital resource that doesn't use an API to integrate some sort of content, often making it easier for the user and creating a better experience overall.

For example, the google maps API can be seen in a lot of apps and sites that include geolocation data. The Waze app can pull google maps data and locations using an API, and lots of Android apps use it to display graphics that otherwise would have taken a lot of time to develop, in these cases, the API just takes the data, does its magic, and delivers displayable results instantly. In one example, the google maps API can be seen like this:

You provide the information, it provides the framework.

Here are some of the most popular APIs and their functions:

• Facebook: social networking, authentication, content sharing.
• Twitter: statistics, feed visualization, content sharing.
• Youtube: video sharing, statistics, advertising.
• Amazon products: advertising.
• Linkedin: business networking.

As you can see, APIs can be very useful and, as a tool for programmers, they are very valuable in order to help them create better applications.

Sources and read more:
http://readwrite.com/2013/09/19/api-defined/http://readwrite.com/2013/09/19/api-defined/
http://www.webopedia.com/TERM/A/API.html
http://www.programmableweb.com/news/most-popular-apis-least-one-will-surprise-you/2014/01/23

Software Lifecycle - Waterfall Method

If you remember last week's Software Lifecycle post, at the end I wrote that there are methodologies to follow the steps defined in the SDLC.

Today in this TC1019's express blog post, I will write about the Waterfall Model (WM), a software development methodology. This is a very simple topic.

The WM is called like that because each step is executed lineally and individually, with the output of one step being the input of the other, if you put it in a diagram, it would look like this:

Source

Hence the name waterfall method, it is the most basic and widely used model, also the first one to appear. Its application is recommended when the software requirements are well defined, the project is short and customer input is not usually required. The software definition must be stable.

Here are the advantages and disadvantages of this model:

Advantages	Disadvantages
Simple and easy Well-defined stages and deliverables Non-overlapping phases Good for small and well-understood projects.	Once finished, the application cannot be changed easily. The product is delivered at the end, no minimum viable product to test. Not good for complex and long-running projects. Specification changes are not easily incorporated.

Hope you learned something today :) 

Sources:

http://www.tutorialspoint.com/sdlc/sdlc_waterfall_model.htm

http://istqbexamcertification.com/what-is-waterfall-model-advantages-disadvantages-and-when-to-use-it/

What the hell is SCM?

At first, I didn't really know what it was or anything about it, but with some google-fu and midnight reading I will share with you my findings about SCM.

SCM stands for Software Configuration Management, sometimes called Software Control Management, it is a framework for organizations to manage software and its changes, updates, errors, versions, tests, and code; all of this in a clean and organized manner.

SCM is the process that defines how to control and manage change.

It is needed with software that involves large organizations and a lot of programmers, it defines who is allowed to make changes, how they make them, and when they can. Software configuration management benefits all the stakeholders in a software project, making their jobs easier. Among the beneficiaries are: developers, testers, support, management, and investors.

Source

SCM consists of four Configuration stages:

1. Identification
• Made up of configurable items (CI), that is, the programs that make up the SW project.
• Baselines are contemplated, they are the status of the CIs at a given point, a version.
• A baseline must have a complete documentation that includes the capabilities of the software, bugs and testing, and a unique footprint.
• On each baseline, the CIs are at an specific version-controlled stage.
2. Control
• Implementing the approved changes to the CIs.
• Process to get to a new baseline.
3. Status Accounting
• Tracking the changes made from the old baseline to the new one.
• Describes the current version and how it came to be.
• The "what's new" section that you see when updating an app in your cell phone, only more detailed.
4. Authentication
• Making sure that the previous processes are complete and correct.
• Testing the software.
• If the tests are passed, then comes the release.

Source

I think, on the grand scale, that's about it. SCM seems like a good way to manage a project, and, if applied correctly, a tool that enables good software to get to the hands of people and businesses, in order to make the world better.

Sources:
https://www.techopedia.com/definition/24583/software-configuration-management-scm
http://ibiblio.org/gferg/ldp/SCM-OpenSource/index.html

Agile Development

Agile is an ideology for software development that aims towards a practical and more efficient way for teams to make software, the four principles are valuing:

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

Source

Methodologies that are considered agile are:

• DSDM (Dynamic Systems Development Method)
• One of the first agile methodologies (before the "agile" term was used).
• Centered in teamwork.
• A common framework in the industry.
• Probably helped diminish the late-software problem that arose in the beginning of software development.
• Crystal methods
• Adaptable to the type of project.
• Strives towards creating a set of principles that are ad hoc to the project.
• Many types: crystal clear, crystal yellow, crystal orange...
• Extreme Programming
• Continuous and fast software development.
• Customer oriented, many changes, testing and planning.
• Feedback is continuous and welcome. 
• Based in small releases, simple code and design, and good software practices.
• Scrum
• Task-oriented.
• Information transparency.
• Based on current problems, not predicted ones.

This blog post was written by Enrique García and Katia Chumakova, check out her blog at http://www.katiachumakova.com/

agile based code continuous customer define deliver depicted design development disciplined estimates eur feedback form frequent high-quality integration involvement iteration-by-iteration lightweight loops maximize metaphor original ownership pace planning popular practices programming provide rapid recipe releases simple simplicity small software standards stories supportive sustainable team tests typically user wells working xp

created at TagCrowd.com

Sources:

• http://www.allaboutagile.com/what-is-agile-10-key-principles/
• https://www.versionone.com/agile-101/what-is-scrum/
• https://www.versionone.com/agile-101/agile-methodologies/

About Software Lifecycle

SDLC - Systems development life cycle

It is a framework used by professional software developers to make good quality software on a time-bound and client-oriented context. ISO/IEC 12207 defines systems lifecycle processes.

If you are not a reader, you may be interested in this video:

It includes 6 basic steps to develop, maintain, replace or alter software:

• Planning
• Defining
• Designing
• Building
• Testing
• Deploying

There are also more detailed steps for the SDLC:

• Communication
• Requireent Gathering
• Feasibility Study
• System Analysis
• Software Design
• Coding
• Testing
• Integration
• Implementation
• Operations and Maintenance 
• Disposition

I will summarize in more detail the steps of the SDLC that is divided in 6 parts:

1. Planning and Requirement Analysis: It is done between the developing company's experts and the client to determine the specifications and feasibility of a project, there are also risks that have to be taken into account. This includes not only the software aspect, also economic and operational aspects are reviewed.
2. Defining Requirements: Doing a Software Requirement Specification (SRS) document that includes the clearly defined features, it must be approved by the customer.
3. Design: The architects define clearly the solution to the problem, based on the SRS, in the Design Document Specification (DDS), it is reviewed by important stakeholders that take into account risks, robustness, modularity, and budget and time constraints.
4. Building: Programmers code the application according to the DSS, using the tools that they are provided and appropriate high-level languages.
5. Testing: The software is tested and corrected in order for it to comply to the specifications described in the (SRS).
6. Deploying: The software is released to its meant environment, sometimes this stage includes field testing to correct and further improve the experience.

These are basic steps, but there's much more to software development than that, there are specific strategies to follow the steps that are standardized. I will post about them later this week.

Hope you learned something from this :)

Software Engineering discussion

Participants, left to right:
Enrique, José Manuel, Frida, José Carlos

We discussed the topic on question and the following things surfaced:

• It is a engineering branch that is dedicated to make software.
• It includes developing, testing and maintaining software.
• Software engineering is involved in design so it could be considered an art, in this aspect, the limit is the software engineer's imagination.
• It is an applied science, and thus includes a methodology that can be followed in order to be successful.
• Methodology is not all, there is also the developer's criteria that enables a project to be successful.
• It can be used for a wide variety of things, from low-level stuff like compilers to big user software.
• The applications are almost everything, some examples are: medicine, administration, construction, education, governments, etc.

We concluded that software engineering can be basically a methodology, but there a lot of possibilities that can expand the engineer's potential, it is one of the most flexible areas in engineering because it creates solutions to everyday problems, from the most simple to the craziest applications.

Test Post

This is the first post for the TC1019 Fundamentals of Software Engineering course blog. :)