¿Cómo puedo definir y medir la simplicidad en el código?

13

Hay muchas respuestas en mi pregunta anterior sobre simplicidad relacionada con la legibilidad eso me ayudó a ver que mi definición y comprensión de la simplicidad en el código era, posiblemente, incorrecta.

¿Cómo puedo definir la simplicidad en el código? ¿Qué medidas y métricas de software están disponibles para medir la simplicidad del código?

    
pregunta Richard 06.12.2011 - 15:46

3 respuestas

16

Las métricas más comunes para medir la complejidad (o simplicidad, si consideras que la simplicidad es lo opuesto a la complejidad) son Complejidad ciclomática de McCabe y las Métricas de la complejidad de Halstead .

La complejidad ciclomática mide el número de rutas distintas a través de una unidad dada, generalmente un método o función, aunque también se puede calcular en una clase. A medida que aumenta el número de rutas, se hace más difícil recordar el flujo de datos a través de un módulo dado, que está relacionado con el concepto de trabajo memoria . La alta complejidad ciclomática tiende a indicar dificultades en la capacidad de probar un módulo; se requieren más casos de prueba para cubrir los distintos caminos a través del sistema. También se han realizado estudios que han relacionado la alta complejidad ciclomática con las altas tasas de defectos. Por lo general, una complejidad ciclomática de 10 indica que una unidad debe revisarse y posiblemente volver a ser modificada.

Las medidas de complejidad de Halstead utilizan las entradas de operadores y operandos totales y distintos para calcular el volumen, la dificultad y el esfuerzo de una pieza de código. La dificultad, que es el (número de operadores únicos / 2) * (número total de operandos / número de operandos únicos), está vinculada a la capacidad de leer y comprender el código para tareas como aprender el sistema o realizar una revisión de código. Nuevamente, puede contar esto en un nivel de sistema, un nivel de clase o un nivel de método / función. Hay algunas publicaciones sobre cómo calcular estas medidas aquí y here .

Simplemente contar las líneas de código también puede darle una idea de la complejidad. Más líneas de código significa que hay más para leer y comprender en un módulo. Dudaría en usar esto como una medida independiente. En su lugar, lo usaría con otras medidas, como la cantidad de defectos en un módulo dado para obtener la densidad de defectos. Una alta densidad de defectos podría indicar problemas al escribir pruebas y realizar revisiones de código, lo que puede o no ser causado por un código complejo.

Fan-in y fan-out son otras dos métricas, relacionadas con el flujo de datos. Como se define aquí , fan in es la suma de los procedimientos llamados, los parámetros leídos y Las variables globales leídas y desplegadas son la suma de los procedimientos que llaman a un procedimiento dado, los parámetros escritos (expuestos a usuarios externos, pasados por referencia) y las variables globales escritas. Una vez más, un alto número de entradas y salidas puede ser indicativo de un módulo que podría ser difícil de entender.

En paradigmas específicos, puede haber otras medidas o métricas que también son útiles. Por ejemplo, en el mundo orientado a objetos, el acoplamiento de monitoreo (deseo bajo), la cohesión (deseo alto) y la profundidad de la herencia (deseo bajo) se pueden usar para evaluar qué tan simple o complicado es un sistema.

Por supuesto, es importante darse cuenta de que muchas medidas y métricas son simplemente indicadores. Debe usar su criterio para determinar si es necesario refactorizar para aumentar la simplicidad o si no vale la pena el esfuerzo de hacerlo. Puede realizar las mediciones, calcular las métricas y conocer su código, pero no desea diseñar su sistema a partir de los números. En última instancia, haz lo que tenga sentido.

    
respondido por el Thomas Owens 06.12.2011 - 16:59
7

En lugar de ver un modo formal de definir la simplicidad, me gustaría definir la simplicidad como un atributo de la calidad de la escritura de código.

No estoy poniendo un poco de simplicidad, pero ¿cuándo llamas a algo simple o no?

1. Recorrido del código:
¿Qué tan fácil es navegar a través del código? ¿Es fácil detectar dónde se escriben las funciones de la API? ¿Es fácil entender los flujos de llamadas, por ejemplo, qué métodos están llamando a otros (y por qué) - hay implementadas máquinas de buen estado o algoritmos claramente identificados?

Cuando el recorrido del código es sencillo, el código es simple a seguir.

2. Nombramiento
Mientras que otros estándares de codificación ayudan a hacer que el código se vea más limpio, lo más importante es la denominación de las clases / instancias de objeto / Variables / métodos. El uso de nombres claros e inequívocos claramente tiene un gran impacto en la Simplicidad del código. Cuando es difícil identificar un nombre simple, es una señal de que es posible que desee volver a pensar que la idea es esa variable / método.

3. Interpretación y referencias
¿Cada uno de tus métodos tiene un papel claro que desempeñar? ¿Cada variable / atributo es fácil de determinar el rol que están jugando? Cuando un fragmento de código hace algo que implica suposiciones o afecta a un conjunto de variables no relacionadas, puede convertirse en una pesadilla de mantenimiento.

4. Dependencia o acoplamiento
Esto es difícil de juzgar con solo mirar el código, pero se vuelve muy evidente si alguien trata de corregir sus errores. Cuando algunas otras cosas cambian en algún otro objeto, ¿la operación aquí cambia? ¿Son esos cambios obvios? ¿Necesita cambiar la API tan a menudo para acomodar cosas? Esto sugiere que las relaciones entre módulos no son simples

5. Entradas de usuario o aplicaciones
Finalmente, ¿qué tan simples son las entradas de usuario o la aplicación se aceptan en la API / UI? Cuando varios usuarios / aplicaciones posibles (para diferentes propósitos) deben proporcionarle, ¿son obvios? ¿Hay estados / detalles que no están relacionados con la abstracción superior pero que aún se remontan a la interfaz?

Una pregunta simple que generalmente haría es la siguiente: Si en lugar de un programa, si hubiera pedido la misma función a ser realizada por un humano, habría llenado esta información en un formulario en papel ? Si no, no soy simple suficiente aquí.

No diré que esta lista es exhaustiva, pero supongo que el criterio es lo fácil o difícil que es usar y modificar el software. Eso es simple

    
respondido por el Dipan Mehta 06.12.2011 - 17:45
0

No conozco ninguna buena métrica existente para la simplicidad del código (no significa que no existan, solo que no conozco). Podría proponer algunas, tal vez algunas ayuden:

  • Simplicidad de las características de lenguaje utilizadas: si el idioma tiene características que podrían considerarse "avanzadas" y "simples", podría contar el número de ocurrencias de las características avanzadas. Cómo definir "avanzado" podría ser un poco más subjetivo. Supongo que algunos podrían decir que esto también es como medir la "inteligencia" de un programa. Un ejemplo común: algunos podrían decir que el operador ?: debería ser una característica "avanzada", otros podrían estar en desacuerdo. No sé cuán fácil sería escribir una herramienta que pueda probar esto.

  • Simplicidad de las construcciones dentro del programa: puede medir el número de parámetros que aceptará una función. Si tienes > n % de todas las funciones con > m parámetros, puede elegir contarlos como no simples, dependiendo de cómo defina n y m ( tal vez n = 3 y m = 6?). Creo que hay algunas herramientas de análisis estático que pueden medir esto. Creo que JTest simplemente mide las funciones con > m parámetros.

  • Podría intentar contar el número de bucles anidados o estructuras de control. Creo que esto no es en realidad una mala métrica y creo que hay un nombre para ella (no puedo recordar la parte superior de mi cabeza). De nuevo, creo que hay herramientas (de nuevo, como JTest) que pueden medir esto, hasta cierto punto.

  • Puedes intentar medir "refactorabilidad". Si su código contiene muchos fragmentos de código que podría ser refactorizado pero no , tal vez eso podría no ser simple. También recuerdo desde el momento en que trabajé con JTest que intenté medir esto también, pero recuerdo que no solía estar de acuerdo con esto en este caso, por lo que YMMV.

  • Puede intentar medir el número de capas entre diferentes partes de su sistema. Por ejemplo: ¿cuántas piezas diferentes de código tocarán los datos que provienen de un formulario web antes de que se almacene en la base de datos? Esto podría ser difícil de medir correctamente ...

respondido por el FrustratedWithFormsDesigner 06.12.2011 - 17:07

Lea otras preguntas en las etiquetas

Comentarios Recientes

David. Me encanta el código. Lo encuentro increíblemente divertido, fácil de leer y siempre actualizado. A veces esto lleva a que mi código exceda su potencial humano. Tener que manejar miles de sustituciones variables que no tengo idea de cómo hacerlo ahora no funcionará bien en una aplicación real. Sin embargo, a menudo uso una combinación de interpolación de contexto, salto de cursor, alertas IF o ELSE y cientos de otras técnicas que ayudan a mejorar mi legibilidad. Aquí hay una métrica de legibilidad... Lee mas