metrics - that - ¿Cuándo, si alguna vez, es la "cantidad de líneas de código" una métrica útil?
metrics traduccion (30)
Cuando el codificador no sabe que está contando líneas de código, no tiene ninguna razón para agregar deliberadamente código redundante al juego del sistema. Y cuando todos en el equipo tienen un estilo de codificación similar (por lo que existe un "valor" promedio conocido por línea). Y solo si no tiene una mejor medida disponible.
Algunas personas afirman que el peor enemigo del código es su tamaño, y yo tiendo a estar de acuerdo. Sin embargo, todos los días escuchas cosas como
- Escribo líneas de código bla en un día.
- Tengo x líneas de código.
- Windows es x millones de líneas de código.
Pregunta: ¿Cuándo es útil "#lines of code"?
ps: Tenga en cuenta que cuando se hacen tales declaraciones, el tono es "más es mejor".
Cuando está refabricando una base de código y puede mostrar que eliminó las líneas de código, y todas las pruebas de regresión aún pasaron.
Cuando presumiendo a amigos.
Diría que es cuando eliminas el código para que el proyecto funcione mejor.
Decir que eliminaste "X número de líneas" es impresionante. Y mucho más útil que agregar líneas de código.
En competiciones
En realidad, las líneas de código no son tan útiles, y si la administración lo utiliza como una métrica, esto lleva a los programadores a realizar muchas refactorizaciones para aumentar sus puntajes. Además, los algoritmos pobres no son reemplazados por algoritmos cortos claros porque eso lleva a un recuento LOC negativo que cuenta en su contra. Para ser honesto, simplemente no trabaje para una empresa que usa LOC / d como una métrica de productividad, porque la administración claramente no tiene ninguna pista sobre el desarrollo de software y por lo tanto siempre estará a la defensiva desde el primer día.
Es útil cuando carga su impresora de línea, para que sepa cuántas páginas consumirá la lista de códigos que está a punto de imprimir. ;)
Es útil de muchas maneras.
No recuerdo el # exacto, pero Microsoft tenía un elenco web del que hablaban por cada X líneas de código, en promedio hay un número de errores. Puede tomar esa declaración y usarla para obtener una línea de base para varias cosas.
- Qué tan bien un revisor de código está haciendo su trabajo.
- juzgar el nivel de habilidad de 2 empleados al comparar la proporción de errores en varios proyectos.
Otra cosa que miramos es, ¿por qué hay tantas líneas? A menudo, cuando un nuevo programador se pone atascado, simplemente copia y pega trozos de código en lugar de crear funciones y encapsular.
Creo que el que escribí x líneas de código en un día es una medida terrible. No tiene en cuenta la dificultad del problema, el idioma en el que escribe, etc.
Es una gran métrica para asustar / impresionar a las personas. Eso es todo, y definitivamente el contexto que estoy viendo en los tres ejemplos.
Es una métrica terrible, pero como otras personas han notado, te da una idea (muy) aproximada de la complejidad general de un sistema. Si está comparando dos proyectos, A y B, y A tiene 10,000 líneas de código, y B es 20,000, eso no le dice mucho: el proyecto B podría ser excesivamente detallado, o A podría ser supercomprimido.
Por otro lado, si un proyecto es de 10,000 líneas de código, y el otro es de 1,000,000 líneas, el segundo proyecto es significativamente más complejo, en general.
Los problemas con esta métrica aparecen cuando se usa para evaluar la productividad o el nivel de contribución a algún proyecto. Si el programador "X" escribe 2 veces el número de líneas como "Y" del programador, podría o no contribuir más, tal vez "Y" esté trabajando en un problema más difícil ...
Es una medida de productividad, así como de complejidad. Al igual que todas las métricas, debe evaluarse con cuidado. Una métrica única generalmente no es suficiente para una respuesta completa.
IE, un programa de 500 líneas no es tan complejo como una línea 5000. Ahora tiene que hacer otras preguntas para obtener una mejor visión del programa ... pero ahora tiene una métrica.
Estoy de acuerdo en que tomar la cantidad total de líneas de código en un proyecto es una forma de medir la complejidad .
Ciertamente no es la única medida de complejidad. Por ejemplo, la depuración de un script Perl ofuscado de 100 líneas es muy diferente de la depuración de un proyecto Java de 5.000 líneas con plantillas de comentarios.
Pero sin mirar la fuente, normalmente pensarías que más líneas de código son más complejas, del mismo modo que podrías pensar que un tarball de fuente de 10MB es más complejo que un tarball de fuente de 15kb.
Hay muchas Métricas de Software diferentes. Las líneas de código son las más utilizadas y las más fáciles de entender.
Me sorprende la frecuencia con la que las líneas de métrica de código se correlacionan con las otras métricas. En lugar de comprar una herramienta que pueda calcular la complejidad ciclomática para descubrir los olores del código, solo busco los métodos con muchas líneas, y también tienden a tener una alta complejidad.
Un buen ejemplo de uso de líneas de código está en la métrica: Errores por líneas de código. Puede darle una idea intuitiva de cuántos errores debe esperar encontrar en su proyecto. En mi organización, generalmente somos alrededor de 20 errores por cada 1000 líneas de código. Esto significa que si estamos listos para enviar un producto que tiene 100,000 líneas de código, y nuestra base de datos de errores muestra que hemos encontrado 50 errores, entonces probablemente deberíamos hacer más pruebas. Si tenemos 20 errores por cada 1000 líneas de código, entonces probablemente nos estamos aproximando a la calidad en la que normalmente estamos.
Un mal ejemplo de uso es medir la productividad del desarrollador. Si mide la productividad del desarrollador por líneas de código, las personas tienden a usar más líneas para entregar menos.
Las líneas de código son útiles para saber cuándo se está preguntando si un archivo de código se está volviendo demasiado grande. Hmmm ... Este archivo ahora tiene 5000 líneas de código. Tal vez debería refactorizar esto.
Me parece que hay un límite finito de la cantidad de líneas de código a las que me puedo referir en cualquier proyecto dado. El límite es probablemente muy similar para el programador promedio. Por lo tanto, si usted sabe que su proyecto tiene 2 millones de líneas de código, y se puede esperar que los programadores puedan entender si un error está relacionado con las líneas de código de 5K que conocen bien, entonces usted sabe que necesita contratar 400 programadores para que su código base esté bien cubierto de la memoria de alguien.
Esto también lo hará pensar dos veces antes de aumentar su base de códigos demasiado rápido y podría hacer que piense en refactorizarlo para que sea más comprensible.
Tenga en cuenta que inventé estos números.
Me sorprende que nadie haya mencionado la cita famosa de Dijkstra todavía, así que aquí va:
Lo que quiero decir hoy es que, si deseamos contar las líneas de código, no deberíamos considerarlas como "líneas producidas" sino como "líneas gastadas": la sabiduría convencional actual es tan tonta como para reservar que cuenta en el lado equivocado de la libro mayor.
La cita es de un artículo titulado " Sobre la crueldad de enseñar realmente informática ".
Respuesta: cuando se puede hablar de líneas negativas de código. Como en: "Eliminé 40 líneas de código extrañas hoy, y el programa sigue funcionando tan bien como antes".
como la mayoría de las métricas, significan muy poco sin contexto. Entonces la respuesta corta es: nunca (a excepción de la impresora de línea, ¡qué gracioso! ¿Quién imprime programas en estos días?)
Un ejemplo:
Imagine que está probando unidades y refaccionando el código heredado. Comienza con 50,000 líneas de código (50 KLOC) y 1,000 errores demostrables (pruebas unitarias fallidas). La proporción es 1K / 50KLOC = 1 error por 50 líneas de código. ¡Claramente este es un código terrible!
Ahora, varias iteraciones más adelante, ha reducido los errores conocidos a la mitad (y los errores desconocidos por más que eso es muy probable) y la base del código por un factor de cinco a través de la refactorización ejemplar. La proporción ahora es de 500/10000 = 1 error por cada 20 líneas de código. ¡Lo cual es aparentemente aún peor!
Dependiendo de la impresión que desee hacer, esto se puede presentar como uno o más de los siguientes:
- 50% menos errores
- cinco veces menos código
- 80% menos de código
- 60% de empeoramiento de la proporción de errores en el código
todos estos son verdaderos (asumiendo que no arruiné las matemáticas), y todos apestan al resumir la gran mejora que tal esfuerzo de refactorización debe haber logrado.
Consulte la definición de wikipedia: http://en.wikipedia.org/wiki/Source_lines_of_code
SLOC = ''líneas de código fuente''
En realidad, hay un poco de tiempo puesto en estas métricas en las que trabajo. También hay diferentes formas de contar SLOC.
Del artículo de wikipedia:
Hay dos tipos principales de medidas SLOC: SLOC físico y SLOC lógico.
Otro buen recurso: http://www.dwheeler.com/sloc/
Cuando tiene que presupuestar el número de tarjetas perforadas que necesita ordenar.
Escribí 2 entradas de blog que describen los pro y los contras de contar Líneas de código (LoC):
¿Cómo se cuenta el número de líneas de código (LOC)? : La idea es explicar que necesita contar el número lógico de líneas de código en lugar de un recuento físico. Para hacerlo, puedes usar herramientas como NDepend por ejemplo.
¿Por qué es útil contar el número de líneas de código (LOC)? : La idea es que la LoC nunca debe usarse para medir la productividad, sino más bien para hacer una estimación de la cobertura de prueba y una estimación del plazo del software.
El perfil de madurez de proceso de la comunidad de software del Instituto de Ingeniería de Software: Actualización de fin de año de 1998 (que lamentablemente no pude encontrar un enlace) analiza una encuesta de aproximadamente 800 equipos de desarrollo de software (o tal vez eran tiendas). La densidad promedio del defecto fue de 12 defectos por 1000 LOC.
Si tenía una aplicación con 0 defectos (no existe en realidad, pero supongamos) y escribió 1000 LOC, en promedio, puede suponer que acaba de introducir 12 defectos en el sistema. Si QA encuentra 1 o 2 defectos y eso es todo, entonces necesitan hacer más pruebas, ya que probablemente haya 10 o más defectos.
Como la mayoría de la gente ya ha mencionado, puede ser una métrica ambigua, especialmente si está comparando códigos de personas en diferentes idiomas.
5,000 líneas de Lisp! = 5,000 líneas de C
Al menos, no para el progreso:
"Medir el progreso de la programación por líneas de código es como medir el progreso de construcción de la aeronave en peso". - Bill Gates
Me recuerda esto:
La presente carta es muy larga, simplemente porque no tuve tiempo para acortarla.
--Blaise Pascal.
Es una idea muy útil cuando se asocia con la cantidad de defectos. "Defectos" le da una medida de la calidad del código. Los menos "defectos", mejor es el software; Es casi imposible eliminar todos los defectos. En muchas ocasiones, un solo defecto podría ser dañino y fatal.
Sin embargo, no parece que exista software no defectuoso.
Hay un caso particular cuando lo encuentro invaluable. Cuando estás en una entrevista te dicen que parte de tu trabajo será mantener un C ++ / Perl / Java / etc existente. proyecto heredado Preguntarle al entrevistador cuántos KLOC (aproximadamente) están involucrados en el proyecto legado le dará una mejor idea de si desea o no su trabajo.
Al determinar el nivel de esfuerzo (LOE). Si está preparando una propuesta y tendrá aproximadamente los MISMOS ingenieros trabajando en el nuevo proyecto, entonces podrá determinar cuántos ingenieros se necesitan por cuánto tiempo.
Parafraseando una cita que leí hace unos 25 años,
"El problema con el uso de líneas de código como métrica es que mide la complejidad de la solución , no la complejidad del problema ".
Creo que la cita es de David Parnas en un artículo en el Diario de la ACM.
Al señalar por qué el cambio tardará tanto.
"Windows tiene 7 millones de líneas de código y lleva un tiempo probar todas las dependencias ..."