lunes, 29 de enero de 2018

Nombres semánticos - Clean code

En el segundo capítulo de Clean Code de Robert C. Martin expone la importancia de usar nombres semánticos. Lo cual, es el primer paso para escribir un código más legible y comprensible, objetivo que persigue el libro Clean Code o código limpio.

Uso de nombres que revelan intención

En el desarrollo de software es frecuente el uso de nombres para variables, métodos, clases y otros, por ello, el uso de nombres que revelan con qué fin se está utilizando es fundamental para mantener un código limpio, sencillo de entender y, por ende, de mantener.

Si una variable, método o clase necesita un comentario para revelar su intención entonces se debería replantear el nombre de esa variable.


Evitar la desinformación

Se deben evitar nombres que no sean lo suficientemente explícitos. Las abreviaturas como tmp pueden llevar a confusión, ya que el lector podría entender que se trata de una variable temporal cuando en realidad es una variable que almacena temperatura (temperature).

Tampoco se deberían usar nombres específicos del lenguaje de programación como por ejemplo usersArray. Con este nombre la variable da la impresión de almacenar un listado de usuarios en una estructura de tipo array. Si en un futuro, el tipo de estructura cambia y deja de ser un array para convertirse en una clase que gestiona un grupo de usuarios y el nombre no cambia va a generar confusión pues la variable sigue dando a entender que sigue siendo una estructura array que almacena usuarios. Un nombre más semántico que evite el tipo de implementación podría ser usersGroup o simplemente users.


Hacer distinciones significativas

En los casos en los que un buen nombre sea una palabra reservada del sistema, como por ejemplo class) no se deben usar nombres similares que tengan faltas de ortografía (klass), cambiar letras por números (cl4ss), añadir un número (class2) ni ninguna otra ingeniosa creatividad que solvente el problema.

También deben evitarse las palabras sin sentido como pueden ser Data, Info, The, etc, que no añaden un significado concreto.

Las palabras que contienen significado para los programadores como pueden ser variable, table, string, Array,y Object, no deberían aparecer como parte de un buen nombre. Por ejemplo, NameString o NameObject no aportan un significado diferente a name.


Nombres que se puedan pronunciar

Un buen nombre debe poder pronunciarse y ser comprensible. Los nombres que son contracciones o partes de palabras no expresan adecuadamente el significado provocando confusión y no deben utilizarse.

El nombre genymdhms no tiene un significado concreto pero si renombramos a generationDate un lector podrá entender que el nombre hace referencia a una fecha en la que se ha generado algo.


Nombres que se puedan buscar

Si los nombres se pueden buscar es mucho más fácil localizarlos entre el código. Los nombres formados por pocas letras o números siempre son más complicados de buscar.

En general, los nombres más largos son mejores que los nombres más cortos y cualquier nombre es mejor que un número mágico en el código. Buscar el número mágico 7 en el código puede derivar en falsos positivos pero siempre será más fácil y eficaz encontrar el nombre de una constante como puede ser «const USER_STATUS_OK = 7». Además, nos resultará más fácil cambiarlo en todo el proyecto ya que sólo hay que modificarlo en un único sitio.


Evitar codificaciones

Al añadir más información al nombre de las variables se añade información extra que posteriormente supondrá un esfuerzo adicional para el programador que tendrá que descodificarla y mantenerla. Por ello, no es recomendable añadir información adicional a los nombres. Los nombres que usan estas codificaciones son raramente pronunciables lo que incumple la regla. Además si cambian su tipo sin renombrar la variable, esto genera confusión en el lector.

Notación húngara

En la notación húngara se añade un prefijo a la variable para indicar su tipo. Antiguamente, los programadores lo usaban para recordar los tipos de variables cuando los compiladores no comprobaban los tipos de estas.

En los nuevos lenguajes, los compiladores recuerdan y fuerzan los tipos. por lo que no es necesario el uso de esta notación.


Prefijos de miembro

No se necesita usar prefijos de miembro como «m_» ya que el tipo y la visibilidad de los mismos se deberían especificar mediante el propio lenguaje y con clases lo suficientemente pequeñas para que no haya dudas al respecto. Los IDE de desarrollo actuales usan colores para diferenciarlo.

Interfaces e implementaciones

Las interfaces no deberían incluir el prefijo “I” ya que ofrece información a los usuarios sobre la implementación de la variable, en este caso, de esta interfaz. En los casos en los que haya que crear una factoría y esta factoría sea diseñe creando una interfaz (por ejemplo shapeFactory) la implementación es la que debería incluir la codificación (CShapeFactory).

Evitar asignaciones mentales

Cuando un nombre no pertenece al dominio del problema ni al dominio de la solución el lector deberá inferir la intención de dicho nombre a medida que vaya comprendiendo el código. De esta forma, el lector habrá de realizar una asignación mental de ese nombre con la intención.

Por ejemplo, al usar la letra «u» para referirse a una URL, el lector del código tendrá que hacer una asignación mental de «u» con una URL. 


Nombres de clases

Las clases deberían tener por nombre sustantivos o frases de sustantivos pero nunca un verbo. Las palabras Manager, Processor, Data or Info no aportan un significado concreto y deberían evitarse.

Ejemplos: user, post, comment, etc.

Nombres de métodos

Los métodos son acciones que se producen en el objeto por ello siempre deberían ser verbos o frases con verbos.

Ejemplos: save, update, delete, load, isConfirmed, isPublished, etc.

Cuando los constructores están sobrecargados se aconseja usar métodos estáticos a modo de factoría con nombres que describan los argumentos del mismo. Haciendo el constructor privado se consigue forzar a usar estos métodos factoría.

Por ejemplo:

Point $point = new Point(12, 3);

Point $point = Point::createFromText(“12,3”);

Point $point = Point::createFromXAndY(12,3);

La primera instrucción crea una instancia de la clase Point con un constructor y dos parámetros. La segunda instrucción crea otra instancia desde un método estático de la clase y usa un parámetro de tipo string. La tercera instrucción crea otra instancia desde otro método estático a partir de dos valores como el primer método.


No excederse con las personalizaciones

Si los nombres son producto de alguna broma o gracia del momento esta sólo tendrá sentido para aquellos que la conozcan. Si un programador se encuentra en la clase user con un método FinishHim (a lo Mortal Kombat), cuyo fin es borrar un usuario, lo más probable es que no sepa lo que hace hasta que no haya investigado ese método. El nombre delete es un nombre más semántico que todo el mundo puede entender.

Elegir una palabra por concepto

A veces aparecen varios nombres para el mismo concepto como puede ser get, fetch, retrieve. Unificar en una palabra un mismo concepto ayuda a entender el código ya que palabras diferentes podrían tener funcionamientos diferentes. Por ello, es recomendable elegir una palabra y seguir esa directriz. 

No hacer juegos de palabras

Siguiendo la regla anterior se debe evitar usar la misma palabra para dos conceptos diferentes. Se considera un juego de palabras usar una palabra para referirse a dos conceptos distintos a pesar de ser semánticamente correcto. En estos casos hay que elegir un nombre diferente.

Si tenemos varias clases que tienen una función add la cual suma un valor a un atributo, la elección del nombre sería semánticamente correcta y el concepto sería el mismo en todas las clases. Si surge la necesidad de añadir un elemento a una lista aunque semánticamente add es correcto, se estaría utilizando para dos conceptos distintos: sumar y añadir a una lista. En consecuencia, para distinguir los conceptos, habría que usar otra palabra como podría ser append, insert, push.


Usar el nombre del dominio de soluciones

El código debería estar escrito para otros programadores por lo que al utilizar términos del ámbito de la programación como nombres de algoritmos, patrones de diseño, FIFO, Queue, etc, se facilita la transmisión de la intención del autor.

Usar el nombre del dominio de problemas

En los casos en los que no haya un término técnico o un nombre del dominio de soluciones se recomienda usar nombres del dominio de problemas ya que por lo menos habrá un experto al cual preguntar sobre el término.

Añadir un contexto con significado

La mayoría de las veces los nombres no tienen un significado por si sólo por lo que hay que englobarlos en un contexto donde esté bien nombrado y tenga un significado semántico acorde a lo que se quiere expresar.

En los casos en los que esto no se puede o no queda claro se puede añadir un prefijo. Por ejemplo, si vemos una variable state, a priori, no sabemos si es parte de una dirección o de otro concepto. Añadiendo el prefijo addr el nombre quedaría como addrState y, de esta manera, podría inferirse que es parte de una dirección.

Aunque la mejor solución sería crear una clase Address y que state fuera un atributo, con lo que quedaría definido como parte de una dirección.


No añadir contextos gratuitos

No es una buena práctica añadir contextos que no aportan valor. Por ejemplo, si tenemos un blog llamado eltortuganegra.com no aportaría nada añadir el prefijo ETN a los nombres del sistema. Por ejemplo, ETNUser o ETNPost no aportan ningún valor específico y complican la comprensión de la justificación de dicho prefijo.

Conclusiones

Una buena elección de nombres depende de la habilidad descriptiva del programador y del trasfondo cultural que comparta con el resto de programadores.

No es usual que, una vez desarrollado el código, haya un cambio en los nombres, aunque esto no debería ser excusa para no elegir nombres adecuados.


Bibliografía

Clean Code de Robert C. Martin

Cómo escribir un mejor código

Llevo un tiempo dándole vueltas y posponiendo algunas cosas importantes por cosas urgentes. No obstante, he decidido posponer las cosas urgentes y dedicarle un poco más de tiempo a algunas cosas importantes que tenía pendientes. Uno de ellas es el libro Clean Code de Robert C. Martin.

También dicen que como mejor se aprende algo es cuando tienes que transmitir ese conocimiento a otra persona. Por ello, voy a dedicar un tiempo adicional a crear una serie de publicaciones basadas en los distintos temas del libro. 


jueves, 14 de diciembre de 2017

Curso TDD con codium.team

Hace un par de días tuve la oportunidad de asistir al curso sobre Test Driven Development (Desarrollo orientado a Test o TDD, por sus siglas en inglés) que impartieron Luis Rovirosa y Jordi Anguela a través de codium.team.

Antes del curso desarrollé un pequeño proyecto personal con Ruby on Rails y realizando test Unitarios, así como test a los controladores e incluso algunos test de integración que abarcaban procesos como: el de registro, el de recuperación de la cuenta y el de inicio de sesión .

El curso me ha parecido muy revelador porque, a pesar de tener algunas nociones básicas, haber basado el proyecto anterior en el libro Agile Web Development with Rails 4 y haberme iniciado un poco en el mundo de los test, bastaron unos simples ejercicios para ser consciente de la magnitud del trabajo que implica realizar un buen TDD y no meros test.

Dicho de otro modo: «Los árboles no te dejan ver el bosque.»

En mi caso, me centré en realizar algunos test de varios tipos pero, debido a la falta práctica, los basaba en el diseño y no al revés. De este modo, cambia enfoque lo que dificulta la comprensión del proceso.

El curso tiene una duración de 2 días y está dividido en una parte teórica y una parte práctica organizada en torno a una kata. Durante la parte práctica, ambos instructores tratan de hacerte reflexionar acerca de los problemas planteados.

Las katas se hacen en parejas en la máquina de uno de los dos componentes y realizando rotación de compañeros en cada ejercicio. Este método resulta especialmente enriquecedor, ya que todos los alumnos comparten su enfoque a la hora de solucionar cada problema, utilizando diversos lenguajes de programación que no siempre son conocidos por todos los alumnos, lo que permite abstraerse del lenguaje y centrarse en problema que plantea la kata.

El principal descubrimiento durante las katas es lo lejos que se está a veces de la solución más sencilla para un determinado requisito. En mi opinión, esto ocurre debido a la tendencia generalizada a anticipar el proceso, complicando así  más de lo necesario el diseño.

Me resultó especialmente divertida la kata password-validator en la que, a medida que desarrollábamos los distintos test, Luis aparecía de pronto para realizar un transgresor refactor borrando parte de nuestro código (la mayoría de las reglas) y todos los test seguían en verde. No pude evitar sonreír ante la habilidad del profesor.

Por consiguiente todos los test deben tener un determinado objetivo. Los objetivos de los que nos ocupábamos mi compañero y yo no eran de utilidad, es decir, nos encontrábamos desarrollando unos test inútiles en la práctica.

También tuvimos la oportunidad de hacer prácticas en materia de creación de test de seguridad sobre un código legado para más tarde hacer un refactor con cierta seguridad sin modificar el comportamiento observable. Sin duda fue uno de los ejercicios más didácticos del curso.

En otro orden de cosas, ampliaron nuestra perspectiva en materia de realización de test sobre librerías de terceros con herramientas como stub, mock, spy, etc, tanto de manera manual como con librerías especializadas como Prophecy.

En la última kata utilizamos un enfoque diferente donde el diseño Outside-in (Escuela de Londres) en el que se empieza por la funcionalidad final y se implementa poco a poco todo lo necesario.

En conclusión, el curso da pequeñas pinceladas de un amplio proceso de desarrollo de software, que puede servir de base para los más osados que decidan meterse más en harina y especializarse en este ámbito.

viernes, 8 de diciembre de 2017

TDD - Test Unitarios

Introducción

Cuando desarrollamos software, antes o después (y más bien durante), tendremos que probar nuestro código para verificar si lo estamos implementando de acuerdo a la especificación. De esta forma, una vez que vamos desarrollando nuestra fantástica pieza de software vamos haciendo debugs de la misma hasta cumplir con las especificaciones marcadas. Hasta aquí todo correcto. Tenemos nuestro código probado y funcionando.

¿Qué pasa si tenemos que desarrollar una segunda funcionalidad sobre el código ya desarrollado? No pasaría nada si la nueva funcionalidad no tiene impacto sobre esta pieza inicial, pero en el caso de no ser así, lo cual suele ser habitual, podría ser preciso cambiar algo cambiar un elemento en la implementación actual necesario para el buen funcionamiento de esta nueva funcionalidad en la implementación actual, pero podría no funcionar para la primera funcionalidad que se desarrolló. Con lo que disfrutaríamos del típico “A wild bug has appeared!”.

Como es de esperar, el peor momento para que aparezca ese bug salvaje es producción. ¿Quién no ha disfrutado alguna vez de la oportunidad de tener que resolver un bug en producción? Es fantástico, ¿verdad? Nada como un poco de estrés para mantener vivo el espíritu de lucha (o supervivencia en algún caso).

Por ello, la única manera de garantizar que no se produzca un impacto negativo es volver a probar la primera funcionalidad. Esta estrategia funciona cuando hay pocas funcionalidades, pero a la larga lo más normal es que se abandone la práctica y sólo se pruebe la nueva funcionalidad o a lo sumo alguna funcionalidad crítica.
Afortunadamente hay otra estrategia que consiste en hacer test para cada una de las pruebas y que estos se ejecuten de forma automática cada vez que se desarrolla un nuevo requisito de la especificación.

¿Qué es un test?

Un test es una prueba donde se verifica el correcto funcionamiento de una pieza de código en un entorno controlado. Esta puede ser una función en programación estructural o un objeto en programación orientada a objetos.

Cada test define qué debería hacer la pieza de software que se va a desarrollar. Por ejemplo los datos de entrada que va a tener, el nombre y parámetros de la pieza de código que se va a probar y qué salida debería tener.

¿Cómo hago un test?

Dependiendo del lenguaje de programación existen diversos framewoks para desarrollar los test.

Para PHP está PHPUnit, Ruby tiene Minitest, Python PyUnit, Java Junit, .Net NUnit,  entre otros muchos. Cada uno de ellos tiene su correspondiente manera de instalarse.
En el caso de PHP y una vez instalado PHPUnit podremos hacer un test sencillo.
Por ejemplo, se podría tener la siguiente especificación para desarrollar una calculadora sencilla.

Especificación

Se quiere realizar una calculadora simple que tenga los siguientes requisitos.

Requisito: sumar dos números.
La calculadora tiene que poder sumar dos números y devolver el resultado de la suma.

Pues de esta especificación podremos implementar el test más sencillo.

CalculatorTest.php

use PHPUnit\Framework\TestCase;

final class CalculatorTest extends TestCase
{
   public function testSum(): void
   {
       $expectedValue = 2;
       $parameterA = 1;
       $parameterB = 1;

       $calculator = new Calculator();
       $result = $calculator->sum($parameterA, $parameterB);

       $this->assertTrue($expectedValue, $result, '1 + 1 should be 2');
   }

}

Si ejecutamos la prueba fallará, ya que no hemos creado todavía la clase Calculator ni su método sum para que pase el test. De hecho el primer paso sería crear la clase Calculator, que implemente  un método sum con sus dos parámetros el cual devuelve la suma de los mismos. 

Sería recomendable que la especificación definiera la casuística lo más detalladamente posible con los casos límite para comprobar que funciona correctamente. En el ejemplo continuaremos simplificándolo y probaremos varios casos fáciles para comprobar que dos números se suman correctamente. De momento evitaremos que los números puedan ser nulos o que no sean enteros naturales.

CalculatorTest.php

final class CalculatorTest extends TestCase
{
   public function testSum(): void
   {
       $calculator = new Calculator();
     
       // Test: 1 + 1 = 2
       $expectedValue = 2;
       $parameterA = 1;
       $parameterB = 1;
       $result = $calculator->sum($parameterA, $parameterB);
       $this->assertTrue($expectedValue, $result, '1 + 1 should be 2');

       // Test: 2 + 1 = 3
       $expectedValue = 3;
       $parameterA = 1;
       $parameterB = 2;
       $result = $calculator->sum($parameterA, $parameterB);
       $this->assertTrue($expectedValue, $result, '2 + 1 should be 3');

       // Test: 2 + 2 = 4
       $expectedValue = 4;
       $parameterA = 2;
       $parameterB = 2;
       $result = $calculator->sum($parameterA, $parameterB);
       $this->assertTrue($expectedValue, $result, '2 + 2 should be 4');
   }  

}
 

Las tres leyes

Según Robert C. Martin en su libro Clean Code se consideran las siguientes leyes:
 
Primera Ley
No se puede escribir código de producción hasta no haber escrito un test unitario que falle.

Segunda Ley
No se puede escribir más de un test unitario que falle y no compilar también es fallar.

Tercera Ley
No se puede escribir más código de producción que el suficiente para pasar el test que está fallando actualmente.


El ciclo para escribir código de producción pasa por escribir primero un test y acto seguido el código que abarca ese test. De esta manera todo el código de producción estaría cubierto por los test.
 
Mantener los test limpios
Los test requieren un esfuerzo extra tanto en lo referente a la creación de los mismos como en lo tocante al mantenimiento, ya que son tan importantes o más que el código de producción.

Los test nos aseguran que cualquier cambio que hagamos sobre el código de producción, ya sea un desarrollo nuevo, como una refactorización, y aunque hayamos hecho un nuevo test para el nuevo cambio, el resto del código funciona como debería y no hemos introducido un nuevo bug.

En el caso de tener un juego de test que no esté bien mantenido al final se plantean dos opciones, hacer el esfuerzo de actualizarlo o desecharlo arriesgándonos a no saber cuándo puede surgir un bug debido a un cambio en el código fuente.

Cómo mantener los test Limpios

Lo más importante para mantener los test limpios es la legibilidad del código al igual que en producción.
 
La legibilidad se consigue a partir de la claridad y la simplicidad del código, así como de la densidad de expresión. O dicho de otro modo, en un test se debe tratar de decir mucho con pocas expresiones.

Es recomendable no utilizar las funciones del sistema directamente, sino crear utilidades para utilizar las funciones del sistema. De esta forma se consigue que los test sean más fáciles de escribir y leer.

Una aserción por test

Es una buena práctica disponer de una aserción por test, ya que facilita la legibilidad del propio test y el lector no tiene que detenerse a entender por qué existen varias aserciones y lo que implica cada una de ellas.

Si continuamos con el ejemplo de la calculadora.

CalculatorTest

final class CalculatorTest extends TestCase
{
   public function testSum1And1ShouldReturn2(): void
   {
       $calculator = new Calculator();
       $expectedValue = 2;
       $parameterA = 1;
       $parameterB = 1;
     
       $result = $calculator->sum($parameterA, $parameterB);

       $this->assertTrue($expectedValue, $result, '1 + 1 should return 2');
   }

   public function testSum2And1ShouldReturn3(): void
   {
       $calculator = new Calculator();
       $expectedValue = 3;
       $parameterA = 1;
       $parameterB = 2;

       $result = $calculator->sum($parameterA, $parameterB);

       $this->assertTrue($expectedValue, $result, '2 + 1 should return 3');
   }

   public function testSum2And2ShouldReturn4(): void
   {
       $calculator = new Calculator();
       $expectedValue = 4;
       $parameterA = 2;
       $parameterB = 2;

       $result = $calculator->sum($parameterA, $parameterB);

       $this->assertTrue($expectedValue, $result, '2 + 2 should return 4');
   }

}

 

F.I.R.S.T

Según Robert C. Martin en su libro Clean Code los test limpios siguen las siguientes reglas que forman el acrónimo que figura como título de este apartado:

Fast
Los test deberían correr rápido. Por cada cambio en el código deberían ejecutarse todos los test del proyecto. Si los test son lentos no se ejecutarán en cada cambio del código y propiciarán la aparición de bugs en el código.

Independent
Los test deberían ser independientes entre sí y poder ejecutarse en cualquier orden. En caso de que los test dependan unos de otros, podría darse el caso de que un primer test fallar y haciendo fallar el resto en consecuencia, lo haría necesario trabajar más para hallar el problema.

Repetible
Los test deberían ser repetibles en cualquier entorno. Es decir, deberían ser capaces de ejecutarse en cualquier entorno ya sea nuestro propio ordenador, el entorno de desarrollo, test, QA o incluso producción.

Self-Validating
Los test deberían tener sólo dos resultados cuando se ejecutan: “pass” o “fail”. Cualquier otro resultado del test como un log o similar donde haya que buscar manualmente el resultado del test no es una buena práctica.

Timely
Los test necesitan escribirse en el momento oportuno, es decir, antes de escribir el código de producción.

martes, 18 de octubre de 2016

[Bitbucket] Configurar multiples identidades SSH en Linux


Toda la información reproducida se puede encontrar en la sección Configure multiple SSH identities for GitBash, Mac OSX, & Linux de la documentación  de Bitbucket.
https://confluence.atlassian.com/bitbucket/configure-multiple-ssh-identities-for-gitbash-mac-osx-linux-271943168.html

Paso 1: Crear una identidad

Para crear una nueva identidad vamos a utilizar el comando: ssh-keygen.

En el siguiente ejemplo la identidad se va a llamar red-ribon-c18-project: 
ssh-keygen -f ~/.ssh/red-ribon-c18-project -C "red-ribon-c18-project"
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/eltortuganegra/.ssh/red-ribon-c18-project.
Your public key has been saved in /home/eltortuganegra/.ssh/red-ribon-c18-project.pub.
The key fingerprint is:
f8:54:08:6f:6f:d4:59:73:45:b1:4d:df:49:f5:aa:10 red-ribon-c18-project
The key's randomart image is:
+---[RSA 2048]----+
|      .       o+X|
|       o . . o.+B|
|        + E o  o=|
|       o + .   . |
|      . S +   .  |
|       o . . .   |
|        .   .    |
|                 |
|                 |
+-----------------

Podemos comprobar que la clave se ha creado correctamente:
ls -lah ~/.ssh
-rw-------  1 eltortuganegra eltortuganegra 1.7K Oct 18 13:37 red-ribon-c18-project
-rw-r--r--  1 eltortuganegra eltortuganegra  403 Oct 18 13:37 red-ribon-c18-project.pub
  

Con este procedimiento podemos crear tantas identidades como necesitemos.

Paso 2: guardar la key en Bitbucket

Para poder acceder a esta funcionalidad hay que tener los permisos suficientes. Una vez logados en Bitbucket y seleccionado el proyecto objetivo hay que ir a la sección de "settings" y allí buscar en el submenú "deployment keys".

Aquí podremos ver la página de "deployment keys" y tendremos la posibilidad de añadir nuevas.

Para añadir una nueva pinchamos el botón "add key" y rellenamos el formulario con un nombre descriptivo y con el contenido de la "key.pub". 

Paso 3: crear un fichero de configuración SSH

El fichero de configuración va contener la configuración las identidades a las cuales las podemos definir un alias. El fichero de configuración se encuentra en:
~/.ssh/config
En el caso de que no exista se crea con un editor de texto.
Aunque las opciones de configuración son varias, en este ejemplo se va a utilizar la siguiente plantilla:
Host alias
HostName bitbucket.org
IdentityFile ~/.ssh/identity
Por lo que en nuestro ejemplo la configuración quedaría:
Host red-ribon-c18-project
HostName bitbucket.org
IdentityFile ~/.ssh/red-ribon-c18-project
 En el caso de tener más de una identidad esta se añade al fichero. En el ejemplo:
Host red-ribon-c18-project
HostName bitbucket.org
IdentityFile ~/.ssh/red-ribon-c18-project

Host red-ribon-c17-project
HostName bitbucket.org
IdentityFile ~/.ssh/red-ribon-c17-project

Paso 4: configurar el repositorio de git

Una vez creada la clave de la identidad hay que configurar el repositorio para que utilice esta clave. Para ello hay que editar el archivo:
/path/project/.git/config
Si el proyecto estuviera ubicado en:

/var/www/c18
Tendriamos que editar el archivo:
/var/www/c18/.config/config

Bitbucket dispone de varias maneras de identificar la url del repositorio por lo que, dentro del archivo, hay que sustituir la variable url por el siguiente formato:
url = git@alias:<accountname>/<reponame>.git

Por lo que si el projecto se encuentra en la cuenta "red-ribon"  y el projecto es c18" la url quedaría:
url = git@red-ribon-c18-project:red-ribon/c18.git
Nota: ojo a los ":" que pueden dar algún quebradero de cabeza (true history).



miércoles, 4 de mayo de 2016

RFC for the 7XX Range of HTTP Status codes - Developer Errors

Me he cruzado con estos códigos de estado y no me ha quedado otra que compartirlo con todos aquellos compañeros de batalla y partirnos de risa con algunos.

Fuente: RFC for the 7XX Range of HTTP Status codes

At Railscamp X it became clear there is a gap in the current HTTP specification.
There are many ways for a developer to screw up their implementation, but no code to share the nature of the error with the end user.
We humbly suggest the following status codes to be included in the HTTP spec in the 7XX range.

  • 70X - Inexcusable
    • 701 - Meh
    • 702 - Emacs
    • 703 - Explosion
    • 704 - Goto Fail
    • 705 - I wrote the code and missed the necessary validation by an oversight (see 795)
  • 71X - Novelty Implementations
    • 710 - PHP
    • 711 - Convenience Store
    • 712 - NoSQL
    • 718 - Haskell
    • 719 - I am not a teapot
  • 72X - Edge Cases
    • 720 - Unpossible
    • 721 - Known Unknowns
    • 722 - Unknown Unknowns
    • 723 - Tricky
    • 724 - This line should be unreachable
    • 725 - It works on my machine
    • 726 - It's a feature, not a bug
    • 727 - 32 bits is plenty
  • 73X - Fucking
    • 730 - Fucking Bower
    • 731 - Fucking Rubygems
    • 732 - Fucking Unic:hankey:de
    • 733 - Fucking Deadlocks
    • 734 - Fucking Deferreds
    • 735 - Fucking IE
    • 736 - Fucking Race Conditions
    • 737 - FuckThreadsing
    • 738 - Fucking Bundler
    • 739 - Fucking Windows
  • 74X - Meme Driven
    • 740 - Computer says no
    • 741 - Compiling
    • 742 - A kitten dies
    • 743 - I thought I knew regular expressions
    • 744 - Y U NO write integration tests?
    • 745 - I don't always test my code, but when I do I do it in production
    • 746 - Missed Ballmer Peak
    • 747 - Motherfucking Snakes on the Motherfucking Plane
    • 748 - Confounded by Ponies
    • 749 - Reserved for Chuck Norris
  • 75X - Syntax Errors
    • 750 - Didn't bother to compile it
    • 753 - Syntax Error
    • 754 - Too many semi-colons
    • 755 - Not enough semi-colons
    • 756 - Insufficiently polite
    • 757 - Excessively polite
    • 759 - Unexpected T_PAAMAYIM_NEKUDOTAYIM
  • 76X - Substance-Affected Developer
    • 761 - Hungover
    • 762 - Stoned
    • 763 - Under-Caffeinated
    • 764 - Over-Caffeinated
    • 765 - Railscamp
    • 766 - Sober
    • 767 - Drunk
    • 768 - Accidentally Took Sleeping Pills Instead Of Migraine Pills During Crunch Week
    • 769 - Questionable Maturity Level
  • 77X - Predictable Problems
    • 771 - Cached for too long
    • 772 - Not cached long enough
    • 773 - Not cached at all
    • 774 - Why was this cached?
    • 775 - Out of cash
    • 776 - Error on the Exception
    • 777 - Coincidence
    • 778 - Off By One Error
    • 779 - Off By Too Many To Count Error
  • 78X - Somebody Else's Problem
    • 780 - Project owner not responding
    • 781 - Operations
    • 782 - QA
    • 783 - It was a customer request, honestly
    • 784 - Management, obviously
    • 785 - TPS Cover Sheet not attached
    • 786 - Try it now
    • 787 - Further Funding Required
    • 788 - Designer's final designs weren't
    • 789 - Not my department
  • 79X - Internet crashed
    • 791 - The Internet shut down due to copyright restrictions
    • 792 - Climate change driven catastrophic weather event
    • 793 - Zombie Apocalypse
    • 794 - Someone let PG near a REPL
    • 795 - #heartbleed (see 705)
    • 797 - This is the last page of the Internet. Go back
    • 799 - End of the world

martes, 3 de noviembre de 2015

Crear una simple aplicación en node.js

Una vez instalado node.js, lo primero que vamos a necesitar es crear el archivo package.json que define nuestra aplicación.

La manera más fácil es utilizar la herramienta npm que hará el trabajo por nosotros mientras nos va preguntando. Para utilizarla solo tenemos que ir al directorio donde queremos empezar el proyecto y teclear:

 > npm init


La herramienta nos irá haciendo una serie de preguntas relacionadas con el archivo package.json que iremos respondiendo.

Entre las preguntas estará cual va a ser el archivo main (el principal o punto de entrada) de nuestra aplicación. Aquí cada uno puede poner lo que quiera aunque un nombre bastante semántico sería applicacion.js o main.js. En mi caso me gusta llamarlo application.js.

Una vez finalizado la herramienta habrá creado el archivo package.json:


A continuación podemos crear nuestro archivo applicacion.js. A partir de aquí ya podemos empezar a añadir nuestras flamante código al archivo:

application.js
 console.log('Hola mundo');  

Y si ejecutamos la aplicación:
 > nodejs application.js;  

Nos devolverá un bonito: "Hola mundo".