El código esta limpio si puede ser entendido fácilmente por todos en el equipo. Un código limpio puede ser leído y mejorado por un desarrollador que no sea su autor original. Con la comprensibilidad viene la legibilidad, la capacidad de cambio, la extensibilidad y la facilidad de mantenimiento.
- Siga las convenciones estándar.
- Mantenlo simple y estúpido. Lo más simple siempre es mejor. Reduzca la complejidad tanto como sea posible.
- Regla de los boy scouts. Deje el campamento más limpio de lo que lo encontró.
- Siempre encuentre la causa raíz. Busque siempre la causa raíz de un problema.
- Mantenga los datos configurables en niveles altos.
- Prefiera el polimorfismo a
if
/else
oswitch
/case
. - Código de múltiples subprocesos separado.
- Evite la configuración excesiva.
- Utilice inyección de dependencia.
- Siga la ley de Demeter. Una clase solo debe conocer sus dependencias directas.
- Sea consistente. Si hace algo de cierta manera, haga todas las cosas de la misma forma.
- Utilice variables explicativas.
- Encapsule las condiciones de contorno. Las condiciones de contorno son difíciles de seguir. Ponga el procesamiento de ellos en un solo lugar.
- Prefiera los objetos de valor dedicados al tipo primitivo.
- Evite la dependencia lógica. No escriba métodos que funcionen correctamente dependiendo de otra cosa en la misma clase.
- Evite los condicionales negativos.
- Utilice nombres descriptivos e inequívocos.
- Haga una distinción significativa.
- Utilice nombres pronunciables.
- Utilice nombres que se puedan buscar.
- Reemplaze los números mágicos por constantes nombradas.
- Evite las codificaciones. No agregue prefijos ni escriba información.
- Cortas.
- Hacen una cosa.
- Usar nombres descriptivos.
- Prefiera menos argumentos.
- No tener efectos secundarios.
- No use argumentos bandera. Dividir el método en varios métodos independientes que se pueden llamar desde el cliente sin la bandera.
- Siempre trate de explicarse con el código.
- No seas redundante.
- No agregue ruido obvio.
- No use comentarios de llaves de cierre.
- No comente el código. Simplemente elimínelo.
- Úselo para explicar la intención.
- Úselo para aclarar el código.
- Úselo para advertir de consecuencias.
- Separe los conceptos verticalmente.
- El código relacionado debe aparecer verticalmente denso.
- Declarar variables cercanas a su uso.
- Las funciones dependientes deben estar cerca.
- Las funciones similares deberían estar cerca.
- Coloque las funciones en dirección descendente.
- Mantenga las líneas cortas.
- No use alineación horizontal.
- Use espacios en blanco para asociar cosas relacionadas y disociar las relacionadas débilmente.
- No rompa la identación.
- Oculte la estructura interna.
- Prefiera las estructuras de datos.
- Evite las estructuras híbridas (mitad objeto y mitad datos).
- Debe ser pequeño.
- Debe hacer una cosa.
- Pequeño número de variables de instancia.
- La clase base no debería saber nada sobre sus derivadas.
- Es mejor tener muchas funciones que pasar un código a una función para seleccionar un comportamiento.
- Prefiera los métodos no estáticos a los estáticos.
- Una afirmación por prueba.
- Legible.
- Rápido.
- Independiente.
- Repetible.
- Rigidez. El software es difícil de cambiar. Un pequeño cambio provoca una cascada de cambios posteriores.
- Fragilidad. El software se rompe en muchos lugares debido a un solo cambio.
- Inmovilidad. No puede reutilizar partes del código en otros proyectos debido a los riesgos involucrados y al gran esfuerzo.
- Complejidad innecesaria.
- Repetición innecesaria.
- Opacidad. El código es difícil de entender.