Esta es la primera entrada de una serie en la que analizamos el libro seven languages in seven weeks publicado por Bruce A Tate en el año 2010. Este interesante libro no pretende profundizar en el conocimiento de cada uno de los lenguajes, sino dar un vistazo rápido a los diferentes paradigmas que existen, así como los puntos fuertes y débiles de cada uno de los lenguajes que analiza.

En esta primera entrada vamos a centrarnos en el lenguaje de programación Ruby. Esto no es un tutorial. El objetivo de esta entrada es dar un vistazo a las características generales de este lenguaje, para poder comprender mejor algunas de sus caracterísiticas de diseño. Lee esta entrada sí. Tienes curiosidad por saber cómo son otros lenguajes o si tienes intención de aprende Ruby próximamente.

Introducción

Ruby es un lenguaje de programación interpretado, reflexivo y orientado a objetos, creado por el programador japonés Yukihiro "Matz" Matsumoto, quien lo presentó públicamente en 1995 y que se distribuye bajo una licencia Open Source. A partir del año 2006 se hace muy popular en la industria del desarrollo de software japonesa gracias a la irrupción del framework de desarrollo web Ruby on Rails.

Habitualmente los ingenieros cuando diseñan un lenguaje ponen toda la atención sobre el rendimiento. En contraposición a esto Matz, quiso poner toda la atención en la productividad del programador. A lo largo de esta entrada vamos a ver como este enfoque se plasma en diferentes características del lenguaje.

Mary Popins

El autor asigna un personaje a cada uno de los lenguajes del libro. En este caso Ruby es Mary Popins. La motivación es que los lenguajes anteriores eran rígidos y aburridos como las niñeras de principios de siglo. En ese momento aparece mary popins una niñera fabulosa y divertida.

Principales características

Interpretado

Ruby forma parte de los lenguajes interpretados. Esto implica que el ciclo de desarrollo es más rápido ya que no es necesario compilar cada iteración. El precio a pagar en los lenguajes interpretados es que ofrecen un rendimiento menor.

Paradigma

Ruby en un lenguaje de alto nivel y orientado a objetos. Soporta las características de encapsulamiento, herencia y polimorfismo.

Sintaxis

La sintaxis de Ruby está inspirada en los lenguajes de programación python y perl. A su vez Ruby ha inspirado la sintaxis de otros lenguajes como Elixir y de Coffeescript.

Es una sintaxis que está diseñada para facilitar la productividad al programador

Algunas partes destacables de su sintaxis son:

• No se require finalizar cada sentencia con un punto y coma.
• No se require declarar variables.
• Es sencillo trabajar con cadenas de texto.
• Se utilizan identaciones para delimitar bloques de código.
• No se requieren los parantesis en las llamadas y definiciones de funciones.

Todo es un objeto

Una característica muy apreciada de Ruby es que todo está definido como un objeto. Así podríamos hacer cosas del tipo.

puts 'hola mundo'.upcase

En contraposición a otros lenguajes, la api de ruby está muy bien diseñada, es consistente y con una muy buena orientación a objetos.

Tipado

Tipado dinámico significa que no necesitas declarar una variable antes de usarla. El intérprete inferirá el tipo de dato y lo asignará a la variable. Este tipo de tipado es muy utilizado en lenguajes de scripting.

foo = 1
foo = '1'

Duck typing se refiere a la características de algunos lenguajes en la que no se realiza comprobación de tipos, por ejemplo cuando se envía un objeto como argumento. En el momento de ejecución cuando se realice una llamada sobre ese objeto, el sistema verificará si está definido y si no llamará a un método especial llamado method_missing.

def method(foo)
  puts foo.upcase # si upcase no está definido se invocará method_missing
end

Simbolos

Ruby utiliza un tipo especial de cadenas de texto inmutables. Si diferentes variables definen el mismo símbolo todas ellas apuntan a la misma referencia.

foo = 'bar'
    foo = :bar # los símbolos ofrecen mejoras de rendimiento

Bloques

Un bloque es una conjunto de sentencias agrupadas. En otros lenguajes se les conoce como funciones anónimas.

odds = [1,2,3,4,5,6,7,8,9].select { |number| number % 2 != 0 }

Mixins

Ruby no soporta la herencia múltiple de forma directa. En lugar de ello utiliza mixins.

module MODULE_A
  def method_1
    puts "Module A method 1"
  end

  def method_2
    puts "Module A method 2"
  end
end

module MODULE_B
  def method_2
    puts "Module B method 2"
  end

  def method_3
    puts "Module B method 3"
  end
end

class Foo
  include MODULE_A
  include MODULE_B
end

foo = Foo.new()
foo.method_2 # Module B method 2

Reflexibidad

Una caracteristica que hace muy potente a Ruby es la capacidad para extender o modificar las clases en tiempo de ejecución.

a = 'fooBAR'
class String
  def upcase
    return self.downcase
  end
end

puts a.upcase # foobar

Conclusiones

Fortalezas

API Bien diseñada

Una de las características más destacables de Ruby es la fuerte orientacioón a objetos y su api consistente y bien diseñada.

Azúcar sintáctico

El azúcar sintáctico es un conjunto de características que se añaden a ciertos lenguajes, que sin añadir funcionalidad al mismo, mejoran el lenguaje en el sentido de hacerlo más fácil de escribir o de leer. Ruby tiene un montón de azúcar sintáctico.

Productivo

Por todo lo que hemos visto Ruby es un lenguaje muy flexible y orientado a la productividad del programador. Ruby es un lenguaje ideal para ser usado como lenguaje pegamento entre la increible cantidad de librerías disponibles, tanto para ser usado como lenguaje de scripting, como para el desarrollo web.

Debilidades

Rendimiento

Algunas de las características que hemos visto y que hacen de ruby un lenguaje tan productivo afectan a su rendimiento.

Seguridad

Sus caracterísiticas de tipado, como hemos visto hacen que programar sea muy rápido, pero también hacen que algunos errores no puedan ser detectados antes de pasar al entorno de producción.

Intellij IDEA junto con el resto de "sabores" del mismo como es PHPStorm, PyCharm, WebStorm es considerado por muchos el mejor entorno de desarrollo integrado que existe en la actualidad.

Esta entrada forma parte de una serie en la que vamos a aprender a usar este editor de forma profesional, a través del conocimiento de los diferentes atajos de teclado disponibles, así como de otras funcionalidades muy útiles para el día a día.

En esta entrada vamos a centrarnos en una de las características más potentes del IDE la refactorización.

Recomendaciones previas

No es necesario que te aprendas todos el primer día. Te recomendamos elegir dos o tres atajos de teclado. Los que te parezcan más útiles y los apuntes en un posit junto a la pantalla para que no se te olviden. Practica con ellos durante algunos días y una vez que los tengas dominados, continúes tu aprendizaje con otro grupo de dos o tres.

El primer atajo de teclado que vamos a recomendarte en cada una de las entradas, es encontrar una acción.

Encontrar una acción

ALT + SHIFT + A

Con este atajo podemos lanzar el menú de selección de acción. Este atajo es de los más útiles ya que te muestra el atajo de la acción que estás buscando por lo que puedes utilizarlo cuando no te acuerdes del atajo que quieres lanzar de forma que vas a poder aprenderlos poco a poco.

Refactorización con Intellij IDEA

Renombrar variable, función, método o clase

SHIFT + F6

Con este atajo podemos renombrar una variable, una función o método o una clase. El entorno de desarrollo buscará todas las apariciones de dicho elemento y los actualizará. Si se trata de una clase cambiará el nombre del fichero que lo contiene.

Extraer constante

CTRL + ALT + C

Con este atajo podemos extraer un valor a una constante de la clase.

Extraer propiedad

CTRL + ALT + F

Con este atajo podemos extraer un valor a una propiedad de la clase.

Extraer variable

CTRL + ALT + V

Con este atajo podemos extraer un valor a una variable del método.

Extraer parametro

CTRL + ALT + P

Con este atajo podemos extraer un valor a un parámetro del método.

Extraer método

CTRL + ALT + M

Con este atajo podemos extraer un bloque de código a un método de la clase. El entorno de desarrollo buscará coincidencias del mismo fragmento de código y nos ofrecerá reemplazarlas por el nuevo método.

Cambiar la firma de un método

CTRL + F6

Con este atajo podemos cambiar la firma de un método. El entorno de desarrollo buscará todas las llamadas a ese método y actualizará el código con la nueva firma.

Mover una clase

F6

Este atajo nos va a permitir mover una clase a otro directorio. El entorno de desarrollo actualizará el namespace y buscará todas las referencias y las actualizará también.

En esta entrada vamos a centrarnos en como navegar de la forma más productiva posible es decir llegar en el menor tiempo posible al lugar al que queremos llegar, tanto si es a otro fichero como si es a una zona diferente del fichero en el que nos encontramos.

Recomendaciones previas

No es necesario que te aprendas todos el primer día. Te recomendamos elegir dos o tres atajos de teclado. Los que te parezcan más útiles y los apuntes en un posit junto a la pantalla para que no se te olviden. Practica con ellos durante algunos días y una vez que los tengas dominados, continúes tu aprendizaje con otro grupo de dos o tres.

El primer atajo de teclado que vamos a recomendarte en cada una de las entradas, es encontrar una acción.

Encontrar una acción

ALT + SHIFT + A

Con este atajo podemos lanzar el menú de selección de acción. Este atajo es de los más útiles ya que te muestra el atajo de la acción que estás buscando por lo que puedes utilizarlo cuando no te acuerdes del atajo que quieres lanzar de forma que vas a poder aprenderlos poco a poco.

Navegación entre ficheros

En el primer bloque vamos a aprender como desplazarnos entre diferentes ficheros para llegar lo antes posible al documento que queremos llegar.

Buscar la clase o archivo

CTRL + N / CTRL + SHIFT + N

Con este atajo podemos buscar la clase o el archivo al que queremos ir respectivamente. El buscador de archivos funciona incluso si el editor está indexando el proyecto.

Navegar a la referencia

CTRL + B / CTRL + CLICK

Con este atajo podemos navegar hacia la definición de una clase o método. Si existen varias disponibles, nos mostrará todas las opciones. Si tienes instalado y configurado el plugin de symfony te permite navegar entre rutas o definiciones de plantillas.

Navegar a hacia delante o hacia atrás

ALT + SHIFT + LEFT / ALT + SHIFT + RIGHT

Con este atajo podemos navegar hacia delante o hacia atrás en la navegación que hemos realizado.

Ver ficheros visitados recientemente

CTRL + E

Con este atajo podemos navegar entre los ficheros que hemos visitado recientemente.

Ver localizaciones visitadas recientemente

CTRL + SHIFT + E

Con este atajo podemos navegar entre los bloques de código que hemos visitado recientemente.

Navegación dentro de un fichero

A continuación vamos a ver los atajos que consideramos más interesantes y que nos van a permitir navegar dentro de un mismo fichero muy rápidamente y sin utilizar el ratón.

Ver estructura

CTRL + F12

Con este atajo nos abre la vista de estructura para poder navegar fácilmente entre los diferentes métodos de una clase.

Método anterior o siguiente

ALT + UP / ALT + DOWN

Con este atajo podemos desplazarnos entre los diferentes métodos de la clase.

Ir al siguiente error

F2

Con este atajo podemos desplazarnos al siguiente error dentro de un fichero.

Saltar a la línea

CTRL + G

Con este atajo podemos desplazarnos directamente a la línea a la que nos queremos mover.

Te recomendamos que leas todos los atajos disponibles tanto en la web de jetbrains como en la configuración de atajos de teclado de tu editor para que descubras por tí mismo todos los atajos disponibles.

Si te gustaría recibir una entrada como esta cada semana en tu bandeja de entrada: apúntate a nuestra academia.

Este es el primero de una serie de entradas en las que analizamos el libro pragmatic programmer from journeyman to master publicado en el año 1999 por Andrew Hunt y David Thomas. Puedes leer la serie en cualquier orden, o leer solamente las entradas que te interesen ya que son independientes entre sí.

Si te interesa, también puedes ver esta entrada en nuestro canal de youtube.

Una de las ideas que subyacen en todo el libro es la responsabilidad. Responsabilidad de tus acciones, de tu carrera, de los proyectos en los que trabajas. Es cierto que muchas cosas no dependen de tí, pero si depende de tí la actitud que tomas cuando te enfrentas a ellas.

En esta línea de pensamiento no debes tener miedo a reconocer que no sabes algo, y sobre todo no debes tener miedo a reconocer que te has equivocado. Si te dedicas al mundo del desarrollo de software puedes estar seguro que ambas situaciones se van a dar antes o después.

Lo importante es cómo te enfrentas a estas situaciónes. Aunque no lo creas, cuando has metido la pata, también es un buen momento para demostrar que eres un gran profesional.

Podemos estar orgullosos de las habilidades que tenemos, pero también podemos estar orgullosos de cómo manejamos la situación cuando nos equivocamos.

¿Cual es la forma correcta de actuar?

1. Sé honesto y directo.
2. Avisa lo antes posible.
3. Nadie quiere saber cuales son tus excusas.
4. Ahora no importa quien es el culpable, tampoco importa lo que no puede hacerse.
5. Lo único que importa es que puede hacerse para paliar los daños y para volver a una situación normal lo antes posible.

Analizar qué ha ocurrido

Una vez que la situación de crisis ha pasado, ahora toca analizar que es lo que pasó.

1. Sigue sin ser importante de quien fue la culpa, probablemente varias personas tienen una parte de culpa.
2. Importa que es lo que puedes hacer tú para que no vuelva a pasar.

Apuntaté a nuestra academia si quieres recibir un consejo como este cada semana en tu bandeja de entrada.

Elige tu estilo

En mi opinión no tan importante que reglas utilices para organizar tus clases. Lo que sí es muy importante, es que elijas unas y te comprometas con ellas. También es muy importante que no seas dogmático y que estés dispuesto a añadir o modificar tus reglas si es que aparecen otras mejores.

No hay nada más frustrante que tratar de explicar a un desarrollador una forma mejor de hacer las cosas, y que no sea capaz de salir de sus trece, pero que tampoco sea capaz de argumentar un motivo.

Dentro de las reglas que elijas ten en cuenta que nada debe quedar al azar, si no que se note que todo está de una forma determinada por un motivo determinado y no simplemente por que ha quedado así.

Nuestro estilo

Nosotros utilizamos la guia de estilo oficial para symfony ya que es el framework con el que trabajamos. Además es muy sencillo configurar el editor para que las aplique automáticamente.

A continuación vamos a explicar el resto de reglas que utilizamos nosotros y que no son exactamente iguales a las que describe el autor en el libro. Pero que vamos a argumentarte los motivos que hemos tenido en cuenta para elegirlas.

Para ello vamos a analizar la clase Rectangle que ya conocemos de entradas anteriores.

Casi todo lo que vamos a ver son esos pequeños detalles que forman parte de nuestra política de no dejar nada al azar, y que probablemente no supongan una gran diferencia por sí sólos, pero que en conjunto y adoptadas por todo el equipo, nos permiten generar una base de código de calidad en todos nuestros proyectos.

Vamos a describir las reglas leyendo la clase de arriba a abajo.

Cabecera

La cabecera es normalmente un fragmento de código comentado que se pone encima de cada fichero. Debería indicar a que proyecto pertenece, que tipo de licencia aplica y que personas han intervenido en ella.

Lo más habitual es utilizar alguna herramienta para asegurar que todos los ficheros tienen la cabecera correcta y esta está actualizada a la última versión.

/*
 * This file is part of the clean code example package.
 *
 * Copyright (c) 2016-2020 Devtia Soluciones.
 * All rights reserved.
 *
 * @author Daniel González <daniel@devtia.com>
 */
final class Rectangle
{
    //..
}

La definición de la clase

Nosotros intentamos por defecto ser lo más restrictivos posible, y luego ir abriendo la visibilidad según sea necesario. Por eso siempre declaramos nuestras clases por defecto como final. Una palabra reservada que nos permite indicar que la clase no puede extenderse.

Las constantes de clase

Nosotros habitualmente separamos las constantes en clases independientes. Por ejemplo, si quisiéramos poner los colores como constantes, es mejor crear una clase diferente para contenerlos. De esta forma mejoramos la semántica del dominio.

final class Color
{
    const WHITE = 'FFFFFF';
    const BLACK = '000000';
}

Atributos

Como norma general declaramos todos atributos como private. Si fuera necesario cuando realizamos un diseño, algunos de estos los declaramos como protected y evitamos siempre los atributos public salvo cuando se trata de DTOs.

Si tenemos atributos de diferente visibilidad dentro de una clase los agrupamos según su visibilidad.

Dentro de cada grupo, ordenamos los atributos por orden de importancia. Los más importantes arriba. También tratamos de agruparlos por tipo, para que estén todas las fechas juntas, todos las colecciones juntas, ...

final class Rectangle
{
    /* @var Point */
    private $topLeft;

    /** @var Color */
    private $backgroundColor;

    /** @var Color */
    private $borderColor;

    /* @var float */
    private $border;

    /* @var float */
    private $height;

    /* @var float */
    private $width;

    //..
}

El constructor y el resto métodos mágicos

A continuación de los atributos escribimos el constructor de la clase. Una clase no debería encontrarse en una situación inconsistente. Por eso el constructor debería recibir todo aquello que la clase necesita para existir. De esta forma evitamos por ejemplo la existencia de un Rectangle cuya altura está sin definir.

final class Rectangle
{
    //..
    public function __construct(Point $topLeft, float $height, float $width)
    {
        $this->topLeft = $topLeft;
        $this->height = $height;
        $this->width = $width;
    }
    //..
}

Los metodos mágicos son métodos que están definidos para todas las clases en php, y que son invocados cuando ocurre una circustancia concreta. Nosotros los definimos por orden alfabético después del constructor.

Los métodos públicos

Nosotros ordenamos los métodos agrupándolos por visibilidad. Arriba del todos los métodos public luego todos los protected y finalmente todos los private.

El autor nos indica que se deberían ordenar según su importancia y mantener los métodos relacionados cerca entre sí. Nosotros creemos que esto podría tener sentido en el momento de publicar el libro, pero es una regla dificil de aplicar, cuando por ejemplo un mismo método se llama desde diferentes métodos, ¿junto a cual lo pones?

Los editores modernos nos permiten navegar con facilidad entre métodos aúnque no estén cercanos entre sí, asi que nosotros simplemente los ordenamos alfabeticamente y configuramos el editor para que haga esto automáticamente por nosotros.

El resto de métodos

Los métodos que no son public deberían declararse private a menos que exista una buena razón para ello. Los ordenamos también por orden alfabético y dejamos que el editor se encarge de esta tarea.

Bloques de código

Para explicar esto es necesario traer un ejemplo un poco más complejo. Veamos un ejemplo real de uno de nuestros proyectos.

final class ProposalController extends AbstractProposalController
{
    //..
    public function copyAction(Project $proposal)
    {
        $this->throwNotFoundExceptionIfNotIsPublicProposal($proposal);

        $copyManager = $this->get('app.service.project_copy_manager');
        $publicProposal = $copyManager->generatePublicProposal(
            $proposal,
            null,
            \AppBundle\Entity\Project\Type::PUBLIC_PROPOSAL_CLIENT_VERSION
        );

        $manager = $this->get('app.service.project_manager');
        $manager->update($publicProposal);

        $this->addFlash('success', 'proposal successfully updated');

        return $this->redirectToRoute('_public.proposal.view', ['hash' => $publicProposal->getHash()]);
    }
    //..
}

Si ves el ejemplo anterior puedes ver que cada concepto está separado por un salto de línea. Lo primero que hacemos es la validación o cláusulas de guarda, de las que hablaremos en otra entrada más adelante.

Lo siguiente que hacemos es obtener una copia de la propuesta a través del servicio correspondiente. Después actualizamos esa copia, mensaje de éxito y redirección a la nueva propuesta.

Cada concepto está separado por un salto de línea facilitando su entendimiento al lector.

Ni un salto de línea de más

El último detalle. Ya hemos visto donde sí debemos poner un salto de línea. En nuestra opinión no se deben añadir saltos de línea adicionales, porque dan la sensación de estar ahí por que sí, en lugar de porque tienen que estar.

¿Pruebas automáticas?

Las pruebas o la batería de pruebas es un software que debe escribirse en paralelo a nuestro propio software y cuya responsabilidad es comprobar que nuestro software funciona correctamente. Básicamente es software que prueba nuestro software.

Puede que intuitivamente pienses que construir una batería de pruebas, es trabajo adicional, ya que probablemente tardarás más tiempo y por lo tanto tu trabajo será más caro para tus clientes pero esto no es así.

Cuando tienes una buena batería de pruebas, la primera "derivada" es que vas a cometer menos errores. Menos errores supone menos tiempo arreglando errores y más tiempo programando. Además supone menos frustración en los usuarios.

La segunda derivada es que puedes hacer cambios con mayor confianza, y esto te hace ir más rápido. Las pruebas detectarán que has roto, y simplemente tendrás que arreglarlo, un equipo con una buena batería de pruebas termina trabajando mucho más rápido que un equipo que no las tiene.

Hay una tercera derivada y es que al desarrollar tu batería de pruebas te va a permitir diseñar mejor software, pero esto es algo en lo que profundizaremos en una entrada más adelante.

¿Si es tan bonito por que no todo el mundo hace pruebas automáticas?

Cuando escribes pruebas debes ser tan cuidadoso cómo con el código de producción. Todo lo que hemos comentado ya en esta serie sobre elegir buenos nombres, funciones, argumentos, etc son cosas que también aplican a las pruebas automáticas.

Escribir buenas pruebas requiere cierta técnica y ocurre que muchos programadores o equipos comienzan haciendo pruebas, y al no ser pruebas de calidad terminan teniendo una batería de pruebas que supone más un problema que una solución. Tras esta mala experiencia desisten, por eso en esta entrada vamos a explicarte cómo escribir buenas pruebas.

Escribe tus pruebas "PRIMERO"

FIRST o PRIMERO es un acrónimo que se utiliza para describir las características que debería tener una prueba.

Fast o Rápidas

Una prueba, así como la batería de pruebas a la que pertenecen deberían ser tan rápidas cómo sea posible. ¿Cuánto? Pues depende del tipo de prueba y del proyecto. El autor no se moja en este aspecto, pero en mi opinión deberías mantener cada prueba por debajo de 1 segundo.

Independent o independientes

Unas pruebas no deberían depender de otras. Esto te permitirá ejecutar aisladamente las pruebas que fallen en lugar de tener que ejecutar toda la batería o un conjunto de pruebas.

Repeatable o repetibles

El resultado de una prueba debería ser siempre el mismo y no variar si la ejecutas varias veces. De esta forma, podrás ejecutar una prueba una y otra vez, hasta que arregles el error. De lo contrario tendrías continuamente errores que luego no vas a poder reproducir.

Self-validating o validación automática

Lo que quiere decir esta regla es que las pruebas no deberían depender de una revisión, por ejemplo que el resultado fuera un texto que luego necesitarás leer para saber si es correcto o no. La prueba debe pasar o no pasar, no debería haber otro resultado posible.

Timely o en el momento correcto

El autor introduce en este capítulo las reglas del ciclo de TDD: rojo, verde y refactorización, pero no quiero profundizar mucho sobre este aspecto aquí, porque tendremos el libro "Test Driven Development: By Example" por en este blog y en el canal de youtube más pronto que tarde.

Show me the code

Supongamos que tenemos la clase rectangulo que vimos en el capítulo de estructuras vs objetos.

class Rectangle
{
    private $height;
    private $width;

    public function __construct(float $height, float $width)
    {
        $this->height = $height;
        $this->width = $width;
    }

    public function area(): float
    {
        return round($this->height * $this->height, 2);
    }
}

Escribir una prueba es una tarea muy sencilla, normalmente es simplemente una clase que tiene que extender de algún tipo de framework de pruebas, así es como se hace con phpunit

class RectangleTest extends \PHPUnit\Framework\TestCase
{
    public function test_area()
    {
        $rectangle = new Rectangle(1.11, 2.22);
        $this->assertSame(2.46, $rectangle->area());
    }
}

Fácil, pero ¿que ocurre al ejecutarlo?

Efectivamente había un error en el código. En este caso lo hemos introducido a posta, pero es un tipo de error que se puede cometer fácilmente.

¿Has visto cual?

Veamos un ejemplo con la clase responsable de notificar a los usuarios de la academia que hay un nuevo contenido disponible. En el método send recibiremos un usuario y la entrada que debe serle notificada.

Partiremos de este primer ejemplo donde la gestión de errores ensucia el código para ver cuales son las diferentes mejoras que podemos ir realizando.

class SendCommand extends AbstractCommand
{
    private function send(User $user, Post $post): void
    {
        $code = $this->mailer->sendTemplate(
            [$user->getEmail() => $user->getName()],
            $post->getName(),
            '@App/Command/Academy/Mailing/Post/post.html.twig',
            [
                'user' => $user,
                'post' => $post,
            ]
        );

        if (Code::TIMEOUT == $code) {
            sleep(20);
            $this->send($user, $post);
        } elseif (Code::ADDITIONAL_DATA_REQUIRED == $code) {
            $this->log(
                sprintf(
                    'message [%06d] for user "%s" could not be sent because was unavailable',
                    $post->getId(),
                    $user->getEmail()
                )
            );
        } elseif (Code::ADDITIONAL_DATA_REQUIRED == $code) {
            $this->log(
                sprintf(
                    'message [%06d] for user "%s" could not be sent because additional space was needed',
                    $post->getId(),
                    $user->getEmail()
                )
            );
        } elseif (Code::INBOX_IS_FULL == $code) {
            $this->log(
                sprintf(
                    'message [%06d] for user "%s" could not be sent because the inbox was full',
                    $post->getId(),
                    $user->getEmail()
                )
            );
        }
    }
}

Como se puede ver este ejemplo inicial tiene bastante que mejorar.

Evita utilizar códigos de error

Los códigos de error son difíciles de manejar. En general van a requerir un montón de estructuras if / else para poder lidiar con los diferentes códigos de error.

Además siempre cabe la posibilidad de que se añada un nuevo código de error que nosotros no tengamos capturado. En lugar de códigos de error sería conveniente utilizar excepciones.

A continuación vemos exactamente el mismo código pero utilizando excepciones:

class SendCommand extends AbstractCommand
{
    private function send(User $user, Post $post): void
    {
        try {
            $this->mailer->sendTemplate(
                [$user->getEmail() => $user->getName()],
                $post->getName(),
                '@App/Command/Academy/Mailing/Post/post.html.twig',
                [
                    'user' => $user,
                    'post' => $post,
                ]
            );
        } catch (TimeoutException $e) {
            sleep(20);
            $this->send($user, $post);
        } catch (AdditionalDataRequiredException $e) {
            $this->log(
                sprintf(
                    'message [%06d] for user "%s" could not be sent because was unavailable',
                    $post->getId(),
                    $user->getEmail()
                )
            );
        } catch (ServiceUnavailableException $e) {
            $this->log(
                sprintf(
                    'message [%06d] for user "%s" could not be sent because additional space was needed',
                    $post->getId(),
                    $user->getEmail()
                )
            );
        } catch (InboxIsFullException $e) {
            $this->log(
                sprintf(
                    'message [%06d] for user "%s" could not be sent because the inbox was full',
                    $post->getId(),
                    $user->getEmail()
                )
            );
        }
    }
}

De momento no hemos mejorado mucho y nuestro código sigue teniendo una pinta terrible, pero estamos un paso más cerca de tener nuestro código bastante más elegante.

Separar lógica y gestión de errores

Lo que vamos a hacer ahora es separar la responsabilidad en dos métodos. Uno de ellos contendrá la lógica de negocio y el otro contendrá la gestión de errores. Este sencillo cambio hace nuestro código mucho más legible y fácil de mantener.

class SendCommand extends AbstractCommand
{
    private function handleSendException(User $user, Post $post, \Exception $exception): void
    {
        try {
            throw $exception;
        } catch (TimeoutException $e) {
            // ..
        } catch (AdditionalDataRequiredException $e) {
            // ..
        } catch (ServiceUnavailableException $e) {
            // ..
        } catch (InboxIsFullException $e) {
            // ..
        }
    }

    private function send(User $user, Post $post): void
    {
        try {
            $this->mailer->sendTemplate(
                [$user->getEmail() => $user->getName()],
                $post->getName(),
                '@App/Command/Academy/Mailing/Post/post.html.twig',
                [
                    'user' => $user,
                    'post' => $post,
                ]
            );
        } catch (\Exception$exception) {
            $this->handleSendException(user, $post, $exception);
        }
    }
}

Evita los detalles de implementación

Nuestro código ha mejorado bastante, pero todavía tiene un problema. Nuestro comando conoce los detalles de implementación del sistema de envío de correo. Esto supone un problema, si en el futuro quisiéramos enviar el correo o las notificaciones con otra librería o a través de otro medio, nuestro comando dejaría de funcionar.

Para ello es conveniente evitar conocer los detalles de implementación ( las excepciones ) que contiene el sistema de envío, con lo que nos debería quedar algo así.

class SendCommand extends AbstractCommand
{
    private function handleSendException(User $user, Post $post, \Exception $exception): void
    {
        $this->log(
            sprintf(
                'message [%06d] for user "%s" with message "%s"',
                $post->getId(),
                $user->getEmail(),
                $exception->getMessage()
            )
        );
    }

    private function send(User $user, Post $post): void
    {
        try {
            $this->mailer->sendTemplate(

                [$user->getEmail() => $user->getName()],
                $post->getName(),
                '@App/Command/Academy/Mailing/Post/post.html.twig',
                [
                    'user' => $user,
                    'post' => $post,
                ]
            );
        } catch (\Exception$exception) {
            $this->handleSendException($user, $post, $exception);
        }
    }
}

Empezemos describiendo los motivos por los que no deberías hablar con extraños: muchas veces cuando tenemos una clase que a su vez está formada por objetos de otras clases y estas a su vez por otras, tenemos una estructura de clases. Hasta aquí todo bien, pero: ¿qué ocurre cuando estas estructuras se vuelven complejas? Veamos un ejemplo que podría darse en un comando de symfony.

class CustomCommand extends Command
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $this->getApplication()->getKernel()->getContainer()->getCustomService()->getManager()->execute();

        return 1;
    }
}

Como puedes ver, estamos acoplando de forma innecesaria nuestro código a todas las clases que aparecen en la cadena de llamadas. Cualquier cambio en estas clases o en las relaciones entre ellas podría suponer que nuestro código dejase de funcionar. Para que esto no suceda viene al rescate la ley de demeter.

La ley de demeter

La ley de demeter fue descrita por primera vez dentro del proyecto demeter en 1987. Como curiosidad quiero contarte que Demeter, hace referencia a la diosa griega de la agricultura. Querian hacer referencia a algo así como "cultivar" software en contraposición a "construir" el software.

La ley indica que desde un método solo deberías "hablar" con aquellos a quien conozcas bien. Y estos son:

• Métodos de la misma clase.
• Métodos de los objetos de la clase.
• Métodos de los objetos creados en la misma función.
• Métodos de los objetos pasados como argumento a la función.

¿Y cómo lo soluciono?

Ya hemos detectado que es lo que no debes hacer, te voy a proponer ahora tres opciones a tener en cuenta cuando detectes este problema en tu código.

No hacer nada

La primera es no hacer nada. Es la solución más sencilla, y la peor de las tres que vamos a ver, pero como ya vimos en la entrada sobre los dogmas en el desarrollo de software, si crees que las clases que estás llamando y sus relaciones están muy consolidadas, podrías permitirte el lujo de realizar este tipo de llamadas en cadena.

Usar atajos

La segunda consiste en hacer atajos que permitan evitar estas llamadas encadenadas. Esta es una solución bastante rápida, que te puede permitir salir del paso en algún momento.

Por ejemplo en CustomService podríamos añadir el método executeManager.

class CustomService
{
    public function executeManager(): void
    {
        $this->getManager()->execute();
    }
}

Esta solución como puedes imaginarte tampoco es la mejor. Te permite abstraer parte de esa cadena de llamadas y por lo tanto es una opción mejor que al principio, ya que si la relacion cambia sólo tendrás que cambiar en este punto las llamadas.

El problema de esta solución es que puedes encontrarte con tu código con un montón de estos métodos atajos, que realmente por diseño no deberían encontraser ahí, pero están simplemente para hacer cumplir la ley de demeter.

Inyectar dependencias

La solución buena, como probablemente ya te venías imaginando es inyectar las dependencias. Veamos un ejemplo.

class CustomCommand extends Command
{
    public function setCustomManager(CustomManager $customManager)
    {
        $this->manager = $customManager;
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $this->manager->execute();
    }
}

Hemos añadido como dependencia la clase CustomManager que era la que realmente necesitamos, y se la hemos inyectado a través de un setter, pero hemos eliminado toda la cadena de dependencias y las relaciones entre sí.

Con este sencillo cambio hemos podido eliminar fácilmente todas las dependencias sobrantes.