Refactorización/Definición

La refactorización es una técnica de la ingeniería de software que permite la optimización de un código previamente escrito, por medio de cambios en su estructura interna sin esto suponer alteraciones en su comportamiento externo;

Dicho de otro modo, la refactorización no busca ni arreglar errores ni añadir nueva funcionalidad, si no mejorar la comprensión del código, para facilitar así nuevos desarrollos, la resolución de errores o la adición de alguna funcionalidad al software.

Objetivo del refactoring

El refactoring tiene como objetivo limpiar el código para que sea más fácil de entender y modificar, permitiendo una mejor lectura para comprender qué es lo que se está realizando.

¿Cuando se debe acudir a la refactorización?

Un punto de partida puede ser cumplir las reglas que plantea el señor Kent Beck.

1. El conjunto de pruebas de la funcionalidad de nuestro Software funcionan correctamente.
2. No existe código duplicado.
3. El código permite entender el diseño.
4. Minimiza el numero de Clases y de Métodos.

Por otra parte se encuentran los code smells.

Code Smells

Los code smells son malas practicas a la hora de programar. Cosas que no se deben hacer y que ensucian nuestro código. Probablemente el código funciona a la perfección, pero se hace difícil de entender y de seguir. Ya que normalmente en el desarrollo de un programa intervienen varias personas es bueno mantener cierto orden en el código para que todo el que requiera usarlo lo pueda entender mas fácilmente.

Tipos de code smell

• Long Method

Un long method es un método excesivamente largo.No existe una manera concreta para detectarlo.

• God Class

Cuando una clase se empieza a hacer muy extensa es síntoma que se esta convirtiendo en una god class. Por lo general tienen muchas variables de instancia y asumen responsabilidades que en realidad deberían estar delegadas en otra clase.

Estos son algunos de los muchos code smells que existen.

Ejemplo refactorización

Antes de refactorizar

  class Program
   {
       static double radeon;
       static void Main(string[] args)
       {
        //Programa que calcula el area de un triangulo
           Console.WriteLine("Bienvenido");
           Console.WriteLine("Ingrese base del trinagulo: ");
           int amd= int.Parse(Console.ReadLine());
           Console.WriteLine("Ingrese altura del triangulo: ");
           int nvidia = int.Parse(Console.ReadLine());
           GTX(amd, nvidia);
           Console.WriteLine("El area de el triangulo es: " + radeon);
           Console.ReadKey();
       }
       static void GTX(int x, int y)
       {
           radeon = (x * y) / 2;
       }
   }

Después de refactorizar

class Program
   {
       static double Area;
       static void Main(string[] args)
       {
        //Programa que calcula el area de un triangulo
           Console.WriteLine("Bienvenido");
           Console.WriteLine("Ingrese base del trinagulo: ");
           int Base = int.Parse(Console.ReadLine());
           Console.WriteLine("Ingrese altura del triangulo: ");
           int Altura = int.Parse(Console.ReadLine());
           calcularAreaTriangulo(Base, Altura);
           Console.WriteLine("El area de el triangulo es: " + Area);
           Console.ReadKey();
       }
       static void calcularAreaTriangulo(int x, int y)
       {
           Area = (x * y) / 2;
       }
   }

Categorias De Refactoring:

1. (Re)Composición de métodos: En esta categoría se incluyen las técnicas que se basan en acortar métodos demasiado largos (de acuerdo a la funcionalidad), sustituir llamadas a los métodos por su código.

2. Movimiento de características entre clases: Bajo esta categoría se incluyen técnicas para reasignar las responsabilidades de una clase a otra, por ejemplo, separar una clase en varias, eliminar una clase, introducir uno o más nuevos métodos a una clase

3. Reorganización de datos: Esta categoría incluye las técnicas de refactoring que permiten facilitar el trabajo con datos, como la creación de accesos para consultar los propios atributos dentro de una clase, reemplazar ciertas estructuras de datos por objetos

4. Simplificación de expresiones condicionales: Esta familia de técnicas pretende facilitar la comprensión, depuración y mantenimiento del software mediante la simplificación de las estructuras condicionales, por ejemplo dividiendo una condicional compleja en varias, eliminando expresiones condicionales redundantes en estructuras complejas.

5. Simplificación de las llamadas a los métodos: Las técnicas de esta categoría pretenden simplificar la interfaz de una clase para que sea más fácil de usar. Incluye algunos refactorings como cambiar el nombre de métodos, eliminar o añadir parámetros a las signaturas de los métodos, etc.

6. Reorganización de la jerarquía generalización: Bajo esta categoría se engloban las técnicas que permiten mover métodos a lo largo de la jerarquía de herencia, como añadir un método de subclases a una superclase, añadir constructores a las superclases o dotar su cuerpo de mayor funcionalidad, crear nuevas sub/superclases, etc.

Ventajas de hacer refactoring

1. Si vamos haciendo refactoring sistemáticamente cada vez que veamos código feo, el código se mantiene más elegante y más sencillo. En fases más avanzadas de nuestro programa, seguirá siendo un código legible y fácil de modificar o de añadirle cosas.

2. Las modificaciones y añadido tardan menos y se pierde mucho menos tiempo en depurar y entender el código.

3. El código afectado es el mismo que el que se modificó para añadir la funcionalidad y por tanto se reduce o evita completamente los inconvenientes para otros desarrolladores

4. El tiempo que se debe dedicar es reducido dado que en ese momento se tiene un conocimiento preciso del código que se verá afectado

Referencias

http://www.scrummanager.net/bok/index.php?title=Refactorizaci%C3%B3n_del_c%C3%B3digo http://www.programacion.com/articulo/refactorizacion:_camino_hacia_la_calidad_221 http://www.taringa.net/posts/info/9199389/Code-smell-a-que-huele-tu-codigo.html