Aprendiendo a Usar Git: Parte 2

Continuando con la parte 1 de este tutorial, en esta oportunidad veremos como crear ramas (branch) y como combinarlas (merge) en su formato más sencillo (fast-forward).

Para modificar la presentación de nuestro blog, crearemos una hoja de estilo llamada base.css dentro de la carpeta “css”.

Para vincular nuestro archivo index.html con la hoja de estilo recién creada agregamos el enlace en la cabecera del documento.

Luego de estos cambios, ejecutamos el comando “git status” para ver el estado de nuestro repositorio.

Git nos informa lo siguiente:

  • El archivo index.html ha sido modificado pero aun no se ha cargado dentro del escenario.
  • GIt detecto que existe una nueva carpeta llamada css que no está siendo rastreada por nuestro repositorio.

Para cargar el archivo index.html y el base.css dentro del escenario, ejecutamos el comando “git add”.

Es importante notar que este comando acepta tanto archivos como directorios. Al usar directorios, “git add” actúa de forma recursiva y carga en el escenario todos los archivos ubicados dentro de dicho directorio.

Ejecutamos nuevamente “git status” para verificar el estado del repositorio.

En este momento tenemos dos archivos en el escenario, uno de ellos ya se encontraba previamente en el repositorio y ha sido modificado (index.html) y otro se cargará por primera vez (base.css).

Al ejecutar un commit, cargamos ambos “cambios” dentro del repositorio.

Ha llegado el momento de definir la paleta de colores de nuestro blog. Nuestro cliente, Juan, nos ha solicitado que le presentemos dos opciones de paletas de colores para que el decida cual es más apropiada para su blog. Ante esta situación, decidimos crear dos “ramas” de desarrollo, una llamada “colorido” en donde usaremos colores contrastantes, y otra llamada “sobrio” en donde usaremos tonalidades más neutras.

Para crear una nueva rama usamos el comando “git branch” y luego, para movernos a la rama recién creada, usamos el comando “git checkout”. Comenzaremos creando la rama “colorido”.

Una vez en esta rama, modificamos la hoja de estilo para definir una paleta colorida.

Estamos listos para guardar estos cambios en un nuevo commit. Como ya sabemos, el procedimiento normal para guardar una fotografía de nuestro directorio de trabajo requiere que primero agreguemos las modificaciones realizadas al escenario y luego ejecutemos un commit. El comando “git commit” permite ejecutar ambos comandos simultáneamente usando la bandera  -a (por add). Al combinar esta bandera con la bandera -m (de mensaje) tendremos la bandera combinada -am

Para ver el histórico de los commits realizados por el sistema, usamos el siguiente comando:

Hasta ahora tenemos solo 3 commits.

Volvamos nuevamente a la rama principal o “master” y observemos el histórico de cambios

Con esto verificamos, que en la rama master solo hay dos commits, es decir, hemos vuelto atrás en el tiempo. Podemos comprobarlo observando nuestra hoja de estilo.

La hoja de estilo vuelve a estar tal como la dejamos antes de crear la rama “colorido”.

 

 

 

 

 

 

 

 

 

 

 

 

Aprendiendo a Usar Git: Parte 1

Mi intención con esta serie de artículos es cubrir los fundamentos de Git por medio de un tutorial muy sencillo en donde usaremos los comandos más básicos de esta fantástica herramienta.

En este tutorial asumiremos el rol de un desarrollador web que ha sido contratado por un amigo (Juan) para que le cree un blog muy simple. Como somos personas precavidas, decidimos usar Git para llevar un histórico de las modificaciones que vamos realizando en el sistema y así no correr riesgos en caso de meter la pata con el código o borrar archivos accidentalmente.

Nota: Se asume también que como programadores serios, estamos trabajando en alguna versión de Linux. En mi caso, Ubuntu 12.10.

El primer paso en nuestra aventura es instalar Git

Luego de esto, debemos crear un directorio en donde vivirán todos los archivos de nuestro blog

Iniciamos el repositorio de Git en la carpeta activa (website)

Usualmente, el primer archivo que se crea para cualquier página web es el “home” o la página de inicio. Tradicionalmente, a esta página se le llama index.html

En este punto podemos observar el estado de Git usando el comando git status

Git nos está informando varias cosas:

  1. Estamos actualmente en la rama “master” ( On branch master )
  2. El primer commit que hagamos, será el primero de nuestro repositorio ( Initial commit )
  3. Existen archivos que no están siendo “rastreados” por el repositorio ( Untracked files ), en particular, el archivo index.html
  4. Si intentamos hacer un commit ahora, nada entrará en el repositorio pues no tenemos nada cargado en el escenario ( nothing added to commit )

Si observamos con cuidado, veremos que Git nos indica como agregar al escenario, los archivos que no están siendo rastreados (use "git add <file>..." to include in what will be committed) . Como deseamos agregar el archivo index.html al escenario, ejecutaremos el comando de la siguiente forma:

Ejecutando nuevamente “git status”, podemos observar que el archivo index.html ya está siendo rastreado por el nuestro repositorio y está en la lista de cambios que serán almacenados en el repositorio durante el próximo commit.

Finalmente, para almacenar nuestro archivo index.html en el repositorio, ejecutaremos un commit

Todo mensaje de commit debe estar acompañado de un mensaje explicativo de los cambios que se están almacenando, es por ello que usamos la bandera -m (por message) en el comando, seguido del mensaje en si “El primer commit”.

La salida de este comando nos da información importante:

  1. Nos indica el valor hexadecimal que identifica a este commit dentro del repositorio ( c701efc )
  2. La cantidad de archivos que han cambiado desde el último commit ( 1 file changed ). Para Git, cualquier acción (crear, editar o eliminar) cuenta como una “modificación”
  3. La cantidad de líneas de código que han sido modificadas en total desde el último commit ( 11 insertions (+) ). En nuestro caso, refleja las 11 líneas que tiene nuestro pequeño archivo index.html que han sido agregadas al repositorio (por eso el símbolo +)

Si ejecutamos una vez más git status, veremos que el último commit del repositorio se corresponde exactamente a nuestro directorio de trabajo (working directory)

Para listar el histórico de cambios en el repositorio, hacemos uso del comando “git log”

Acá podemos observar:

  1. El hash que identifica al commit. Este valor hexadecimal es tan largo (para evitar duplicados o colisiones), que usualmente solo se usan los primeros 7 caracteres c701efc . Este es el mismo valor que nos mostró el comando “git commit” en el paso anterior y sirve como alias para identificar un commit en particular.
  2. El nombre y correo de la persona que ha realizado el commit
  3. La fecha y hora del commit, incluyendo la diferencia horaria respecto a UTC (-0430 por ser Venezuela)
  4. El mensaje del commit

Hasta acá llega la primera parte del tutorial, muy pronto estaré montando la segunda parte.

Cómo instalar y usar GAWK en Windows

GAWK es un lenguaje simple pero muy útil para procesar logs de información. Aunque originalmente fue desarrollado para Linux, es posible usarlo en Windows gracias a la aplicación cygwin, que no es más que un emulador del terminal de Linux corriendo dentro de Windows.

Para instalar cygwin solo debemos seguir los siguientes pasos:

1) Ingresar a la página http://www.cygwin.com/

2) Descargar el archivo setup.exe que encontramos en dicha página y ejecutarlo

Dibujo1

3) Al ejecutar setup.exe aparece un cuadro de diálogo y se debe hacer clic en “Siguiente”

 cygwin1

4) Usar la selección por defecto y hacer clic en “Siguiente”

cygwin2

5) Usar la selección y la ruta de instalación por defecto y hacer clic en “Siguiente”

cygwin3

6) Usar la ruta por defecto y hacer clic en “Siguiente”

cygwin4

7) En caso de estar tras un proxy (como en el caso de mi máquina en Movilnet), se debe seleccionar la opción “Use HTTP/FRP Proxy” y definir el host “proxy” y el puerto “80”. En cualquier otra circunstancia (la máquina del hogar por ejemplo), usar la opción “Direct Connection”

cygwin5

8) Esperar mientras el instalador busca los “mirrors” disponibles

cygwin6

9) Seleccionar el mirror “http://box-soft.com” y hacer clic en “Siguiente”

cygwin7

10) Dejar las opciones por defecto y hacer clic en “Siguiente”

cygwin8

11) Esperamos mientras se descargan todos los paquetes. Este proceso puede tardar bastante tiempo dependiendo de la velocidad de conexión

cygwin9

12) Usar las opciones por defecto y hacer clic en “Finalizar”

cygwin10

13) Accedemos al terminar haciendo doble clic en el ícono “Cygwin Terminal” en el Escritorio para que se creen los archivos base de nuestro usuario

cygwin11

14) Ingresamos a la carpeta C:\cygwin\home. En esa carpeta existirá una carpeta con nuestro nombre de usuario (en mi caso es dbarre03). Creamos un acceso directo de dicha carpeta en el escritorio para facilitar el trabajo.

cygwin12

Listo, cada vez que querramos procesar un archivo, podemos meter en dicha carpeta tanto el log como el archivo con el código awk y al ejecutar el Cygwin Terminal, tendremos acceso a la consola de Linux dentro de Windows.

El misterio del error de precisión de los números de punto flotante

Finalmente he podido entender el misterio del error de precisión de los números de punto flotante que afecta a todos los lenguajes de programación. Para explicarlo, voy a emular el trabajo que realiza el computador para almacenar y leer el número decimal 0.1

Como los computadores almacenan todos los números y caracteres en binario, el primer paso es transformar el número decimal 0.1 a su representación binaria. Para ello se sigue un algoritmo sencillo:

1) Se toma el número a transformar y se multiplica por 2:

0.1 * 2 = 0.2

2) Se separa la parte entera de la decimal del valor resultante

La parte entera de 0.2 es 0
La parte decimal de 0.2 es 0.2

3) La parte entera se toma como el primer dígito significativo del número binario

0.0______

3) Se repiten los pasos 1 y 2 usando la parte decimal obtenida del paso anterior.

Este proceso se repite hasta que el resultado de sea cero o se obtenga una secuencia periódica.

Si ejecutamos este proceso completo para el número 0.1 obtenemos lo siguiente:

0.1 * 2 = 0.2 -> 0
0.2 * 2 = 0.4 -> 0
0.4 * 2 = 0.8 -> 0
0.8 * 2 = 1.6 -> 1
0.6 * 2 = 1.2 -> 1
0.2 * 2 = 0.4 -> 0 (vuelve a reiniciarse la secuencia)

Con esto obtenemos que la representación binaria de 0.1 es:

0.00011... periódico

Como las computadoras tienen una cantidad finita de bits para almacenar cualquier número, los números periódicos se almacenarán truncados. Si asumimos que nuestra computadora solo almacena el valor 0.00011 y no 0.000110011001100110011... (hasta el infinito), la conversión de binario a decimal de este número sería:

0.00011 = 1/16 + 1/32 = 0.09375

Y con esto hemos comprobado como surge un problema de precisión pues 0.1 no es igual a 0.09375, es solo un valor aproximado.

Breve resumen del libro “Clean Code – A Handbook for Agile Software Craftmanship”

Recientemente leí el libro “Clean Code – A Handbook for Agile Software Craftmanship” de Robert C. Martin y decidí compartir algunos apuntes interesantes sobre lo que el autor considera como buenas prácticas de programación. Continue reading Breve resumen del libro “Clean Code – A Handbook for Agile Software Craftmanship”