Modernizando aplicaciones PHP: antipatrones más comunes

A lo largo de mi carrera he tenido la oportunidad de “meter las narices” en unas cuantas aplicaciones… a algunas de ese aplicaciones podríamos llamarlas “legacy” en el sentido de que son aplicaciones que necesitan algo de “cariño”. Recuerdo una pregunta en una ¿Y tu cómo te enfrentas a aplicaciones legacy? mi respuesta fue Con paciencia. Así que hoy escribiremos sobre antipatrones más comunes cuando nos enfrentamos a una aplicación legacy. Este artículo no vamos a reescribir todo en <el fancy framwork que sea>,sino que veremos como hacer nuestras aplicaciones un poco más mantenibles.

Si quieres profundizar más sobre el legacy este artículo titulado “Mi código en producción ya es legacy” de Fran Iglesias es genial.

Continúa leyendo “Modernizando aplicaciones PHP: antipatrones más comunes”

Curso de Refactoring en PHP

Este es un post un poco especial, voy a impartir este curso sobre refactoring en PHP y me gustaría contar un poco como ha sido todo este proceso desde que empecé como alumno en geekshubs academy hasta que nos pusimos manos a la obra para grabar un curso.

Aunque Internet es una fuente inagotable de información. En la red hay miles de artículos, blogs, wikis, listas de distribución sobre programación, testing, docker,… no terminaba de encontrar un curso que de verdad me aportase algo más. Estaba buscando mejorar mis habilidades como programador, que fuese en español, con comunicación directa con los profesores.

rrss.jpg

Un día casi por casualidad, encontré un post de Xavi Gost hablando sobre el curso “De refactoring a patrones” impartido en GeeksHubsAcademy, la verdad es que era escéptico sobre los cursos en video, pero me convenció el hecho de hacer hangouts para poder resolver dudas y además @islomar me dio un empujón en forma de descuento 😉

Continúa leyendo “Curso de Refactoring en PHP”

Mejorando la kata FizzBuzz

Hace unos días hicimos nuestro primer video haciendo la kata FizzBuzz, esto fue un primer acercamiento de como empezar con TDD y buenas prácticas. Ahora reflexionamos sobre la solución de la kata y veremos que introducimos ciertos code smells que en una segunda iteración intentaremos ir solucionándolos para hacer llegar a un código más robusto.

Enunciado de FizzBuzz

Escribe un programa que imprima los números del 1 al 100, pero aplicando las siguientes normas:
Devuelve Fizz si el número es divisible por 3.
Devuelve Buzz si el número es divisible por 5.-
Devuelve FizzBuzz si el número es divisible por 3 y por 5.

fizzbuzz.png
FizzBuzz in CSS

El código de la primera iteración es este.

Continúa leyendo “Mejorando la kata FizzBuzz”

Haciendo testing unitario al 100

Haciendo testing unitario al 100%. Hace unos días estuvimos hablando de como refactorizar controladores para separar responsabilidades. Ahora llega la hora de dar un paso más y testear unitariamente las clases que creamos.

La idea detrás de este post es que modifiquemos una clase ya construida y funcional, llenarla de tests y refactorizarla para que los test solo testeemos una clase y no necesiten más que phpunit, ni base de datos ni más clases de las necesarias.

Continúa leyendo “Haciendo testing unitario al 100”

Refactorizando controladores: Separando responsabilidades

Una de las cosas más complicadas para los programadores es tomar consciencia sobre las como modelar situaciones y objetos del mundo real y aplicarlos al mundo de la programación. De vez en cuando, es necesario dar un paso atrás y pensar en lo que se ha estado haciendo.

Así es como al final, acabamos dándonos cuenta de que llenar un controlador de lógica es como crear un monstruo. Últimamente he leído mucho sobre refactoring y más de un post hablando sobre que llenar el controlador de código es algo malo, así que hoy vamos a ver de primera mano como solucionarlo.

Pongamos como ejemplo un controlador como este:

Continúa leyendo “Refactorizando controladores: Separando responsabilidades”

Skinny Controller: moviendo la lógica del controller

Cuando empecé a utilizar PHP, yo incluía bastante cantidad de lógica en el controller, entonces empecé a leer sobre refactoring y me topé con skinny controller fat models, el código de mis controlllers se reducía bastante y la lógica estaba en los modelos, pero lo único que hacía era mover el problema de sitio. Ahora … Continúa leyendo Skinny Controller: moviendo la lógica del controller

Refactorizando el cliente de “Cat API” – Parte 3 –

Esto es una traducción libre de Refactoring the Cat API client – Part III

En la primera y segunda parte hemos estado trabajando en separar las preocupaciones que teníamos al principio combinadas en una sola función.

Los principales “personajes” en el escenario ya han sido identificados: un httpClient y una caché, utilizadas por diferentes implentaciones de CatApi para poder testar y realizar un cliente para The Cat Api

Continúa leyendo “Refactorizando el cliente de “Cat API” – Parte 3 –”

Refactorizando el cliente de “Cat API” – Parte 2

Esto es una traducción libre de Refactoring the Cat API client – Part II

El mundo un sitio seguro

Cuando estas ejecutando test unitarios, no quieres que el resto del mundo este involucrado en tus tests. Ejecutar consultas en bases de datos reales, hacer peticiones HTPP, escribir en ficheros, nada de esto es deseable: harán que tus tests sean lentos e impredecibles. Si el servidor en el que estas haciendo tu petición está caído, o responde de manera inesperada tus test unitarios fallarán por razones equivocadas. Un test unitario solo debería fallar si tu código no hace lo que se supone que debería hacer.

Como hemos visto en el post anterior de la serie, tanto la clase CachedCatApi como RealCatApi de alguna manera dependen del mundo. La primera escribe ficheros en el sistema de ficheros, la segunda hace peticiones HTTP. Además, la creación de fichero y las peticiones HTTP son cosas de bastante bajo nivel, para lo cual las clases no utilizan las mejores herramientas disponibles. De la misma manera, un montón de casos límite no están siendo tenidos en cuenta.

Continúa leyendo “Refactorizando el cliente de “Cat API” – Parte 2″

Refactorizando el cliente de “Cat API” – Parte 1

Esta es una traducción libre de Refactoring the Cat API client – Part I

Mattias Noback tenía la idea de hacer una serie de videos sobre “Principles of Package Design book” pero finalmente en vez de videos hizo una serie de post con el material que tenía pensado presentar en los videos.

Para empezar esta es una pequeña pieza de código:

class CatApi
{
    public function getRandomImage()
    {
        if (!file_exists(__DIR__ . '/../../cache/random') 
            || time() - filemtime(__DIR__ . '/../../cache/random') > 3) {
            $responseXml = @file_get_contents(
                'http://thecatapi.com/api/images/get?format=xml&type=jpg'
            );
            if (!$responseXml) {
                // the cat API is down or something
                return 'http://cdn.my-cool-website.com/default.jpg';
            }

            $responseElement = new \SimpleXMLElement($responseXml);

            file_put_contents(
                __DIR__ . '/../../cache/random',
                (string)$responseElement->data->images[0]->image->url
            );

            return (string)$responseElement->data->images[0]->image->url;
        } else {
            return file_get_contents(__DIR__ . '/../../cache/random');
        }
    }
}

Como se puede adivinar, la función getRandomImage devuelve una URL de la imagen aleatoria (y que existe) de Cat API. Cuando llamamos a la función en dentro de una ventana de tiempo de 3 segundos, se devuelve la misma URL para que el servicio sea más rápido, así como para no abusar de Cat API.

Continúa leyendo “Refactorizando el cliente de “Cat API” – Parte 1″