lunes, 25 de mayo de 2020

Ejemplo de uso de Firebase. Accediendo a una BD.

Una de las tendencias actuales en cuanto a la explotación de sistemas web o apps, pasa por no tener que ocuparse de los servidores desde los cuales se suministra la funcionalidad del sistema a los usuarios. Y no solamente no ocuparse del hardware que aloga los servicios que implementan la funcionalidad de la web o app, tampoco del software de infraestructura. Es decir: base de datos, dependencias, sistema operativo, marcos de prueba, SEO, etc.

Estas plataformas se ocupan de que el hardware y software que da soporte al sistema en producción esté siempre a punto, actualizado y correctamente dimensionado según la demanda de los usuarios.

Una de las plataformas de este tipo es Firebase de Google teniendo otras compañias plataformas similares. Amazón dispone de AWS Lamda o Microsoft dispone de Azure Functions.

Esta forma de computación se viene llamando Serverless y está muy bien descrita en  https://www.genbeta.com/desarrollo/que-serverless-que-adoptarlo-desarrollo-tu-proxima-aplicacion

Es este artículo se presenta un ejemplo de utilización de Firebase. El objetivo es explicar de forma rápida a modo introductorio cómo se usa Firebase para que el lector se pueda hacer a la idea de las posibilidades que suministra este tipo de plataformas de forma rápida y sencilla.

El ejemplo consiste en una página html que contiene una función javascript que accede a los datos de una base de datos alojada en un proyecto Firebase. Para construir el ejemplo se han realizado las siguientes acciones:

  1. Crear un proyecto Firebase. Dentro del proyecto crear una base de datos con una colección y un documento con datos.
  2. Agregar una aplicación al proyecto Firebase.
  3. Desarrollar la aplicación, en este caso codificar la página html y la función javascript. La página está desplegada y se puede consultar en https://miprimerproyecto-e2f9e.web.app/paginafirebase.html 
  4. Desplegar la aplicación en Firebase. Para ello:
    • Se instala firebase tools con el comando "npm install -g firebase-tools". Para hacer esto es necesario tener instalado node y node package manager.
    • Se inicia sesión en Firebase con el comando "firebase login".
    • Se inicializa la aplicación para que sea desplegable en firebase con el comando "firebase init".
Para más detalles visitar la documentación de Firebase https://firebase.google.com/docs/web/setup?authuser=0#create-project 

Una vez hecho esto se puede probar la aplicación en local. Para ello se arranca el servidor con el comando "firebase serve". Una vez probada, para desplegar la aplicación en producción en la plataforma Firebase se usa el comando "firebase deploy". Y voilà, la aplicación está en producción lista para su utilización.

domingo, 5 de abril de 2020

Cómo usar Git y GitHub


Git es un repositorio distribuido. Esto quiere decir que cada desarrollador tiene un repositorio instalado en local. Además hay un repositorio común donde compartir el código, en el caso que nos ocupa el repo común será un proyecto en GitHub.

El proyecto GitHub tiene una rama principal llamada master, esta va a contener la última versión del código funcionando. Se pueden crear ramas para distintos desarrollos pero en esta forma de uso solo se va a trabajar con la rama master.

Pasos a seguir para trabajar con Git y GitHub en el proyecto politicagitgithub:


Primera vez. Para crear el repositorio local git y descargar el contenido del repositorio de GitHub a local

-     Instalar Git. Para ello descargar un fichero ejecutable desde https://git-scm.com/downloads, el fichero a descargar depende del sistema operativo en el que queremos instalar Git. Se ejecuta y para asegurar la correcta instalación, ir a una pantalla de comandos y ejecutar el comando git --versión,  el sistema muestra la versión de Git instalada.

-          Para contener el repositorio local del proyecto se crea una carpeta en el sistema de archivos. En esta carpeta se crea el repositorio local con git clone de la siguiente manera:

1.       Acceder a la URL https://github.com/MarisaAfuera/politicagitgithub.
2.       Pulsar  el botón  "Clone or download"y entonces se muestra la pantalla:

 
3.     Copiar la URL y abrir una ventana de git bash que se habrá instalado con git. Situarse en la carpeta del proyecto yejecutar el comando:

git clone https://github.com/MarisaAfuera/aficionbaloncesto.git


Para el trabajo del día a día

Cuando un desarrollador va a empezar un trabajo sobre el código, lo primero que hace es traer (pull) a su repo local la última versión que hay en la rama master de GitHub. Para ello utilizar el  comando git pull origin master.

Después en local (su equipo) crea una rama para empezar a desarrollar lo que corresponda. Para crear la rama en la que va a trabajar usa el comando git checkout –b .

Trabaja añadiendo, modificando y borrando código en la rama creada en local. Cuando acaba ejecuta los comandos:


  •  git add . Este comando añade al repositorio local en la rama actual los ficheros nuevos, elimina los borrados y cambia los modificados.
  •  git commit –m “<motivo de los cambios>”. Este comando compromete (los da por buenos)  los cambios en local y los marca con el mensaje que escribimos en “motivo de los cambios”.
Ahora hay que integrar los cambios con el código de los demás desarrolladores llevando los cambios al repositorio remoto, en este caso GitHub. Para ello se  comunica al equipo que se va a realizar un “merge” a master de GitHub. El objetivo es que mientras se hace este merge, ningún otro integrante del equipo interfiera haciendo cambios a master. Para integrar los cambios realizados con el código que hay actualmente en master se ejecutan los siguientes comandos:

  •  git checkout master. Para volver a master del repo local.
  •  git pull origin master. Para traer al repo local los últimos cambios a master del repo compartido en GitHub.
  •  git merge nombre-de-rama. Para mezclar los cambios de la rama del repo local con el código en master.  Pueden surgir conflictos que se deben resolver para realizar el merge, algunos conflictos tendrán que ser resueltos en colaboración con otros integrantes del equipo.
  •  git push origin master. Para llevar los cambios a master de GitHub.

Conclusión

Esta es una posible forma de uso de Git y GitHub para el control de versiones del código y la documentación de un proyecto. Esta en una forma muy sencilla de uso de estas herramientas. La política de uso que se emplee en cada caso será algo que los equipos de desarrollo deben acordar cuando aborden un proyecto de desarrollo.
 

lunes, 16 de marzo de 2020

Diseñando Inversion de control e injección de dependencias


Invertir el control consiste en cambiar el sentido de las "invocaciones"entre módulos. Es decir, si el módulo A llama o invoca al módulo B, hacer que B sea el que llame o invoque a A. En los lenguajes bajo el paradigma de orientación a objetos, esta inversión es posible gracias a los módulos de tipo interface o prototipo. Estos módulos permiten definir contratos de comportamiento, de forma que no contienen la implementación de dicho comportamiento. Solo contienen los argumentos necesarios para llevar a cabo el comportamiento y marcan el tipo de resultado que se va a obtener después de realizar ese comportamiento.

El siguiente ejemplo escrito en java muestra lo explicado

public interface Sport {
    void practice();
}

public class Basketball implements Sport {
    @Override
    public void practice() {
        doIt();
    }

El módulo Sport es una módulo de tipo interface. El módulo Basketball implementa esta interface y por ello está obligado a implementar el método practice() que no recibe argumentos y devuelve void como así prescribe la interfaz. Al implementar una interface es obligatorio implementar los métodos prescritos, usando el nombre, argumentos y tipo de retorno establecido.

¿Para qué es esto útil y como se relaciona con la inversión de control? Imaginemos que se requiere construir una app que gestiona partidos de diferentes deportes, su objetivo es llevar el calendario de eventos deportivos. El sistema debe tratar los eventos (Match), de los distintos deportes (Football y Basketball), por ejemplo se puede plantear el siguiente escenario:



El tipo Match crea y usa objetos de tipo Sport. Sport que es una interface, declara que todos los tipos que lo implementen tienen que tener un método practice(). En el ejemplo estos dos tipos obligados por la interfaz a implementar practice() son Football y Basketball.

En una primera instancia se podría haber pensado en el siguiente diseño:


Este diseño puede parecer más sencillo, pero establece un acoplamiento fuerte entre Match y los distintos deportes que se vayan a gestionar en la App. Es decir cada vez que se añada un deporte nuevo habrá que modificar Match. Además como no está regulada la implementación por ningún tipo de interfaz cada deporte se puede comportar de forma distinta, de manera que el tratamiento de cada deporte será diferente.

Para ilustrar esto veamos como queda la implementación de Match en el diseño con interfaz:

 public class Match {

    private final List sports;

    public Match(List sports) {
        this.sports = sports;
    }

    public void implement() {
    sports.forEach(s -> {
            s.practice();
        });
    }
}

Se observa que los deportes se tratan de forma uniforme independientemente de su tipo. Siempre se usa practice().

En este ejemplo queda por ver que tipo es responsable de crear los deportes. Y ese tipo es App, que tiene la siguiente implementación:

public class App {

     public static void main(String[] args) {

       Football football = new Football();
       Basketball basketball = new Basketball();
       List sports = new ArrayList();
       sports.add(football);
       sports.add(basketball);
       Match m = new Match(sports);
       m.implement();

    } 

}


Esta clase crea los deportes y se los injecta a Match a través de su constructor. Y aquí está el ejemplo del segundo concepto anunciado en el título del post "injección de dependencias". Esto quiere decir que las dependencias no las crea directamente Match, es decir no hace ni new Football(); ni new Basketball();. Los objetos de tipo Football y Basketball son creados por App y enviados como argumentos en una lista al constructor de Match. En el caso de necesitar incorporar nuevos deportes se creará su tipo y se implementara practice() como sea oportuno para ese deporte. Luego lo que habrá que modificar será App, Match quedará inmutable.

Este tipo de diseños está encaminado a que las clases de alto nivel, en este caso Match, no dependan de las de bajo nivel, en este caso Football y Basketball. Con lo que se han invertido las invocaciones. En este caso no s Match el que invoca a Football y Bascketball, es App quien invoca a Match y le inyecta los deportes a través del constructor.

Conclusión

Las dependencias son un asunto de la máxima importancia cuando se trata de sistemas informáticos compuestos por multitud de módulos. Estos colaboran entre ellos para llevar a cabo la misión para la que se han construido y para colaborar necesitan establecer dependencias. A todo esto en ingeniería del software se le llama acoplamiento y cuanto menor sea el acoplamiento entre módulos mejor es el sistema. Esto se debe a que sistemas con módulos poco acoplados permiten hacer cambios de forma más sencilla debido a que un cambio en un módulo no provoca que haya que cambiar los módulos que dependen de él y/o los módulos que dependen de él son los mínimos posible. En el caso de este ejemplo es menor el acoplamiento entre Match y Football y Backetball haciendo uso del interface Sport.

El código completo de este ejemplo se puede descargar en https://github.com/MarisaAfuera/inversionofcontrol