Podcast #11 – El concepto de abstracción en el desarrollo de software

En este podcast hablare de un tema que no muchos hablan, sobre el concepto de abstracción en el desarrollo de software, y como se obtiene está conforme pasan los años.

Abstracción en la Programación – Curso de Programación Orientada a Objetos en 10 minutos #6

La abstracción es un tema poco visto cuando estamos en la universidad y estudiamos programación orientada a objetos. Se nos mencionan las clases abstractas, pero esto solo es parte de lo que es la abstracción. He decidido incluir este tema brevemente en este curso, ya que para mí esto es lo que hace la diferencia de un programador bueno de un programador malo, y no cuantos lenguajes de programación domine.

A lo largo de mi experiencia, he llegado a la conclusión que la abstracción nunca termina por mejorarse, y al momento que miras código tuyo de uno o dos años atrás y ves que es un desorden, esto quiere decir que has mejorado.

En breves palabras la abstracción es resumir o disminuir un elemento a lo que lo define sin incluir otros elementos, en este caso los objetos de la Programación Orientada a Objetos (POO). Para explicar esto siempre recurro al triangulo y al círculo, los dos son figuras geométricas, un triángulo tiene 3 lados y siempre tendrá 3 lados aquí y al otro lado del universo, y un circulo siempre será una línea conectada, esto es abstracción, se definen las figuras en una o dos líneas de descripción sin llegar a meternos en más detalle.

¿Pero esto para que nos sirve o qué? Sirve para hacer la diferencia de un mal programador a un buen o magnifico desarrollador de sistemas.

Ya dejando atrás el círculo y el triángulo veamos un ejemplo de día a día cuando se desarrolla un sistema.

Un sistema de ventas:

  • El cliente pide un sistema que tenga usuarios.
  • Los usuarios pueden ser clientes o vendedores o administradores.
  • Los usuarios tendrán un password para acceder al sistema.
  • Los clientes compran, los vendedores venden.

Lo que un programador con bajo nivel de abstracción hará es:

Creará una clase Administrador, una clase Cliente y una clase Vendedor y las tres tendrán el campo password el campo usuario y los métodos para autentificarse.

Por ejemplo:

Clase Administrador

class Administrador{
string usuario="";
string password="";

//todos los atributos de administrador por ejemplo
string nombre;
string apellido;

//etc

public bool Ingresar(string usuario, string password){
//codigo ingreso
}

public bool Salir(){
//codigo salir
}

//aqui metodos de administrador etc...
}

Clase Cliente

class Cliente{
string usuario="";
string password="";

//todos los atributos de cliente por ejemplo
string nombre;
string apellido;
string empresa;
//etc

public bool Ingresar(string usuario, string password){
//codigo ingreso
}

public bool Salir(){
//codigo salir
}

//metodos de cliente
}

Clase Vendedor

class Vendedor{
string usuario="";
string password="";

//todos los atributos de vendedor por ejemplo
string nombre;
string apellido;
string email;
decimal comision;
//etc

public bool Ingresar(string usuario, string password){
//codigo ingreso
}

public bool Salir(){
//codigo salir
}

//metodos de vendedor
}

Y esto es normal, funcionara y el sistema para el usuario estará perfecto, el problema viene cuando vienen los cambios en el sistema, por ejemplo nos piden modificar el método de acceso al sistema, digamos antes se hacía la conexión directa, ahora se hará por un webservice y utilizar un certificado. Entonces la cosa se convierte en un cambio en 3 sitios distintos, más trabajo por falta de abstracción, y si es más trabajo es más tiempo por lo cual es más caro y por lo cual es más crítico a darse errores.

Cuando una persona tiene un nivel más alto de abstracción podrá pensar en métodos alternativos para evitar estos problemas, estos métodos nacen por la experiencia que se tienen en sistemas hechos anteriormente y es cuando hacemos cosas más organizadas con un nivel más alto de abstracción como el siguiente ejemplo, que nos ayudaremos de la herencia:

Clase Usuario

class Usuario{
string usuario="";
string password="";
public bool Ingresar(string usuario, string password){
//codigo ingreso
}

public bool Salir(){
//codigo salir
}
}

Clase Administrador

class Administrador : Usuario{

//todos los atributos de administrador por ejemplo
string nombre;
string apellido;
}

Clase Cliente

class Cliente : Usuario{
//todos los atributos de cliente por ejemplo
string nombre;
string apellido;
string empresa;
//etc

//metodos de cliente
}

Clase Vendedor

class Vendedor : Usuario{

//todos los atributos de vendedor por ejemplo
string nombre;
string apellido;
string email;
decimal comision;
//etc

//metodos de vendedor
}

Nota: Los dos puntos (:) en c# sirven para heredar, lo mismo que en java es extends.

Como vemos los métodos de ingresos quedan en la clase Usuario de la cual todas las otras clases: Cliente, Administrador, Vendedor heredan, y esto ya muestra más madurez que las clases anteriores, ya que si surge un cambio en el ingreso solo tendríamos que modificar el metodo en la clase Usuario. Pero aun así podemos mejorarlo más analizando las similitudes de nuestras clases y viendo cómo podemos crear otra entidad por ejemplo una clase Persona que tenga el atributo nombre y apellido los cuales comparten las otras clases y a su vez que herede de Usuario.

El propósito de esta entrada es que ustedes como programadores no tomen a la ligera la manera que hacen y organizan su código, ya que esto puede ser la diferencia en ser un programador malo a uno bueno, a parte que si su código es formal y elegante puede ser fácil entendible por otro programador.

Con esto doy por terminado este curso de Programación Orientada a Objetos en 10 minutos, cualquier duda o comentario hágamelo saber en el apartado de comentarios o en el formulario de contacto.

Todo esto que hago es para todo los programadores que comienzan o de una u otra forma llegaron a un problema que yo ya solucione, y los comentarios son una motivación para mí. Gracias lector por visitar mi sitio web.

Ir Capítulo Anterior (5.- Polimorfismo)

1.- Introducción a la Programación Orientada a Objetos (POO) – Curso de Programación Orientada a Objetos en 10 Minutos #1

La Programación Orientada a Objetos (POO así la abreviaremos) nace por la necesidad de representar el mundo en el que habitamos (junto a sus problemas) por medio de objetos como nosotros los percibimos, con sus propiedades y funcionalidades, de esta forma es más fácil para los programadores organizar su código y tener una manera elegante con la cual realizar los sistemas. Uno de los lemas de este paradigma de programación es: “divide y vencerás”, lo cual nos da a entender que no tenemos que llenar líneas y líneas de códigos con funciones y perder el hilo de lo que estamos haciendo (como solía ser en la programación estructurada), si no que organizamos los objetos del sistema de forma abstracta junto a las acciones que pueden hacer y las iteraciones que tienen con los demás objetos.

Para darnos una idea rápida de que trata este paradigma, imaginemos que deseamos representar un medio de transporte (avión, barco, automóvil), el sentido común del humano rápidamente nos dice que nos sirve para trasladarnos, que se mueve a cierta velocidad, que frena, que tiene pasajeros, ruedas, alas o hélices, y de manera fácil podemos listar todas sus acciones y propiedades, siendo las acciones el moverse y el frenar, siendo las propiedades: el número de pasajeros, el numero de ruedas, numero de hélices etc.

Con la POO representamos rápidamente estos objetos del mundo real por medio de clases que nos sirven de moldes para crear los objetos que tendrán funcionalidad en nuestros sistemas.

Para ello pasemos de la teoría a la práctica y comencemos a entender rápidamente este paradigma y sus ventajas en el siguiente capitulo.

Ir Capítulo Siguiente (2.- Clases y Objetos)

Curso de Programación Orientada a Objetos en 10 Minutos

Este curso, me basare en una descripción del paradigma Orientado a Objetos, general y brevemente, y te prometo que en menos de 10 minutos habrás comprendido lo mas importante de esta forma de programación.

Para el curso utilizo el lenguaje de programación C# .Net, el cual es fácil de comprender (por si nunca lo han utilizado) y solo servirá para explicar el paradigma, no para que aprendan C#.

El curso consta de los siguientes capítulos:

1.- Introducción a la Programación Orientada a Objetos (POO)

2.- Clases y Objetos

3.- Constructor

4.- Herencia

5.- Polimorfismo (Sobrecarga y Sobreescritura)

6.- Abstracción en la Programación

5.- Programación Orientada a Objetos (POO) – Curso Básico De #Javascript #5

La programación orientada a objetos, es el paradigma hoy en día mas utilizado en los lenguajes de programación, esto debido a su facilidad de organizar las cosas, y dividir la funcionalidad. Para aquellos que no han escuchado este término, se los explico brevemente (ya que lo explico en un breve curso: curso de Programación Orientada a Objetos en 1o minutos), la programación orientada a objetos (POO) nace por la necesidad de representar el mundo en el que habitamos (junto a sus problemas) por medio de objetos como nosotros los percibimos, con sus atributos y funcionalidades, por ejemplo un objeto auto, sabemos por sentido común que tiene llantas, tiene volante, tiene ventanas, puertas, a esto le llamamos atributos (variables), los cuales pueden variar de un auto a otro, pero la mayoría de autos deben tener todo esto para ser autos, de igual manera sabemos que un auto camina y frena, y a esto le llamamos funcionalidad la cual se representa por métodos (funciones). Este es un concepto breve y que servirá para el propósito que tenemos en este capítulo, el cual es representar objetos del mundo físico en javascript por medio de la POO(Programación Orientada a Objetos).

Para crear un objeto en javascript necesitamos de lo que en POO, llamamos clase; una clase es el molde para crear el objeto; la clase define que atributos debe tener el objeto  y cuál es su funcionalidad y para ello vamos a ver un ejemplo de cómo representaríamos un Libro en javascript  utilizando la POO, y la clase Libro se hace de la siguiente manera:

//clase Libro
function Libro(nombre,autor){
this.nombre=nombre;
this.autor=autor;
}

Podemos observar que su sintaxis es la misma que la de una función, excepto que dentro tenemos algo nuevo para nosotros, la palabra this, esto indica que dentro de esta función existen dos atributos, los cuales adquieren su valor por los parámetros enviados al invocar la función, estos atributos pueden ser utilizados posteriormente por nuestro objeto creado, pero para facilitar las cosas vamos a un ejemplo de cómo utilizar la clase creada anteriormente, y como acceder a sus datos:

//Objeto LibroTerror creado con la clase Libro
var LibroTerror= new Libro("En las montañas de la locura","Lovecraft");
alert(LibroTerror.nombre);
//esto mostraría en un alert  nombre "En las montañas de la locura"

De esta manera queda claro cómo podemos crear estructuras para plasmar el mundo físico en javascript, pero que pasa con la funcionalidad, también nuestros objetos tienen funcionalidad, para ello vamos a crear una clase biblioteca, a la cual se le agregan libros, y para nuestra ventaja, con un método también podríamos saber que libros hay en la biblioteca(sin estar viendo en todos los libreros de esta, ¡bendita programación!), para ello veamos el siguiente ejemplo:

//clase Biblioteca
function Biblioteca(nombre){
this.nombre=nombre
//atributo arreglo para guardar los libros
this.Libros= new Array();
//metodo que agrega libros a nuestra biblioteca
this.addLibro=function addLibro(libro){
this.Libros.push(libro)
}

//método que muestra todos los libros utilizando un foreach en el arreglo Libros de esta clase
this.muestraTodosLosLibros=function muestraTodosLosLibros(){
var cadenaLibros="";
this.Libros.forEach(function(libro){
cadenaLibros+=libro.nombre+"n";
})
//regresamos los nombres de los libros concatenados
return cadenaLibros;
}
}

Ahora vemos que dentro de una función (que utilizamos como clase), existen otras funciones, estas funciones pueden ser llamadas por el objeto, también en una clase de javascript podemos tener arreglos, y a estos agregarle objetos los cuales nosotros creamos con anterioridad, y si somos cuidadosos, podemos observar que el método muestraTodosLosLibros() utiliza el forEach del capítulo anterior.

Pasemos a la parte divertida, ver como se utiliza la clase Biblioteca, para ello, pondré el código completo, el cual contiene comentarios parte por parte, pueden copiar y pegar en un archivo de texto con extensión html y abrirlo en un navegador, el código es el siguiente:


//clase Libro
function Libro(nombre,autor){
this.nombre=nombre;
this.autor=autor;
}

//clase Biblioteca
function Biblioteca(nombre){
this.nombre=nombre
//atributo arreglo para guardar los libros
this.Libros= new Array();
//metodo que agrega libros a nuestra biblioteca
this.addLibro=function addLibro(libro){
this.Libros.push(libro)
}

//metodo que muestra todos los libros utilizando un foreach en el arreglo Libros de esta clase
this.muestraTodosLosLibros=function muestraTodosLosLibros(){
var cadenaLibros="";
this.Libros.forEach(function(libro){
cadenaLibros+=libro.nombre+"n";
})
//regresamos los nombres de los libros concatenados
return cadenaLibros;
}
}

//creamos libros para nuestra biblioteca
var LibroTerror1= new Libro("En las montañas de la locura","Lovecraft");
var LibroTerror2= new Libro("Llamada del Cthulhu","Lovecraft");
var LibroNegro1= new Libro("El Psicoanalista","John Katzenbach");

//creamos un objeto de tipo Biblioteca
var BibliotecaPublica = new Biblioteca("Biblioteca Publica");

//Agregamos los libros a la biblioteca por medio del metodo addLibro()
BibliotecaPublica.addLibro(LibroTerror1);
BibliotecaPublica.addLibro(LibroTerror2)
BibliotecaPublica.addLibro(LibroNegro1)

//invocamos el metodo muestraTodosLosLibros del objeto Biblioteca
alert(BibliotecaPublica.muestraTodosLosLibros())

Para ver este código en acción den clic aquí.

En este capítulo vimos como crear clases para ser moldes de objetos, también vimos como dentro de nuestras clases podemos agregar atributos simples y complejos (arreglos), otra cosa que resalta es el poder poner funcionalidades a nuestros objetos, y de esta manera organizar nuestro código, de una manera elegante y formal.

Ir Capítulo Siguiente (6.- Eventos)

Ir Capítulo Anterior (4.- Arreglos)