¿El número promedio de errores por loc es el mismo para diferentes lenguajes de programación? [cerrado]

45

Me han dicho que el número promedio de errores / defectos por línea de código es "constante" para diferentes lenguajes de programación. 10 KLOC de Ruby tendrían el mismo número de errores que 10 KLOC de c ++. El argumento se usa generalmente para promover el uso de lenguajes expresivos (piense en python / ruby ​​sobre c ++ / ensamblador) ya que el número de líneas para describir la misma funcionalidad sería menor.

¿Alguien sabe de dónde viene este reclamo? ¿Los lenguajes de nivel superior conducen a menos errores?

Kristian
fuente
11
Parece irrazonable considerando que algunos idiomas fomentan un estilo que agrupa más declaraciones en una sola línea que otros.
Caleb
10
Bugs / LOC es una métrica muy incorrecta para todo. Depende del idioma, pero depende mucho más del programador que lo escriba. Por lo tanto, tomar el promedio del idioma no tiene sentido, ya que las grandes fluctuaciones están en la otra variable. Esto es solo IMO, ofc.
K.Steff
3
Puedo decirte que el número de errores / línea que escribo en Perl será mucho mayor que el número que escribo en C. Un amigo mío es un mago de Perl, y para él los errores / línea son mucho mayores en C que en C Perl. Es difícil ver cómo esta métrica podría ser útil.
Caleb
44
¿Realmente crees que {1≥⍴⍵:⍵⋄e←⍵[?⍴⍵]⋄ (∇(⍵<e)/⍵) , ((⍵=e)/⍵) , ∇(⍵>e)/⍵}es tan probable que contenga un error como int pivot = arr.Count / 2;?
svick
2
Acabo de encontrarme con esta pregunta. No tengo la menor idea de por qué estaba cerrado; Esta es una pregunta perfecta para este sitio. Para un proyecto grande, los errores por KLOC no son una medida de lo buenos que son los programadores. Es una medida de qué tan buena es la organización y el proceso.
David Hammen

Respuestas:

43

Contrariamente a la intuición, el número de errores por cada 1000 líneas parece ser relativamente constante, independientemente del lenguaje específico involucrado. Steve McConnell , autor de Code Complete y Software Estimation: Demystifying the Black Art repasa esta área con cierto detalle.

No tengo mis copias a mano, están en mi estantería en el trabajo, pero un rápido Google encontró una cita relevante:

Promedio de la industria: "aproximadamente 15 - 50 errores por 1000 líneas de código entregado".
(Steve) dice además que esto generalmente es representativo del código que tiene algún nivel de programación estructurada, pero que probablemente incluye una combinación de técnicas de codificación.

Citado de Code Complete , que se encuentra aquí: http://mayerdan.com/ruby/2012/11/11/bugs-per-line-of-code-ratio/

Si la memoria funciona correctamente, Steve entra en una discusión exhaustiva de esto, mostrando que las cifras son constantes en todos los lenguajes (C, C ++, Java, Assembly, etc.) y a pesar de las dificultades (como definir qué significa "línea de código").

Lo más importante es que tiene muchas citas para sus fuentes: no está ofreciendo opiniones sin fundamento, pero tiene las referencias para respaldarlas.

Parece reducirse a esto: el número promedio de defectos por kloc parece ser más una propiedad del hecho de que los desarrolladores son humanos falibles que las ventajas o desventajas particulares de un lenguaje o plataforma en particular.

(Aparte: si aún no tiene Code Complete, compre una copia y léala a fondo, vale la pena la inversión).

Actualización : hay otro factor en juego con algunas de las respuestas aquí: las estadísticas a gran escala son útiles para hacer predicciones generales pero no específicas. Tenga en cuenta que las tablas de mortalidad de la población pueden predecir cuántas personas morirán en accidentes de tráfico este año, pero no pueden decirle qué personas morirán. Del mismo modo, las estadísticas de la industria que muestran un número relativamente constante de defectos por kloc no se pueden utilizar para predecir qué tan bien, o qué tan mal, se desempeñará un desarrollador en particular o qué sucederá en un proyecto determinado.

Bevan
fuente
44
No tengo una copia de la Estimación de software, pero en Code Complete McConnel cita el informe de 1977 "Calidad del programa y productividad del programador" de Capers Jones como la fuente de una tabla de errores por LOC por tamaño de proyecto. El punto que McConnel intenta hacer es que los errores aumentan dramáticamente a medida que aumenta el tamaño del proyecto, y señala que los datos son solo una "instantánea de la industria" y que "los números pueden tener poca semejanza con los de los proyectos en los que ha trabajado ". Realmente no veo nada allí que tenga algo que ver con esta pregunta.
Roc Martí
¿Qué edición de Code Complete tienes @ RocMartí? Sé que la segunda edición fue una gran actualización. Tendré que desenterrarlo y ver qué dice cuando llegue al trabajo el lunes.
Bevan
Creo que su edición ( Actualización:) es el núcleo del problema. O, como dijo Mark Twain, hay tres tipos de mentiras: mentiras, malditas mentiras y estadísticas.
GalacticCowboy
1
@ RocMartí "los errores aumentan dramáticamente a medida que aumenta el tamaño del proyecto" ¿También señaló que el agua está húmeda? Por supuesto, hay errores cuando las cosas se ponen más complicadas. Porque cada nuevo cambio tiene que tener en cuenta cada pieza posible que pueda verse afectada. Que crece a medida que crece el proyecto.
Parthian Shot
3
La cita es incorrecta u obsoleta. En la segunda edición, está en la página 521: "La experiencia promedio de la industria es de aproximadamente 1 a 25 errores por 1000 líneas de código para el software entregado. El software generalmente se ha desarrollado utilizando una mezcla de técnicas".
Aryeh Leib Taurog
18

La afirmación es, en el mejor de los casos, ingenua.

SLOC no es exactamente una métrica confiable para nada útil, excepto quizás comparar el tamaño de dos o más proyectos. Además, hay dos tipos distintos de SLOC, LOC físico y LOC lógico, y estos pueden diferir significativamente. Considere este ejemplo, de Wikipedia :

for (i = 0; i < 100; i += 1) printf("hello"); 

Aquí tenemos un LOC físico, pero dos lógicos ( fory printfdeclaraciones). Pero, por supuesto, podríamos escribir el ejemplo como:

for (i = 0; i < 100; i += 1) 
  printf("hello"); 

Lo que nos daría dos LOC físicos y dos lógicos. Creo que está claro que cualquier medición de "error por loc" que dependería de los LOC físicos estaría contaminada por el estilo de programación, por lo que nuestra medición sería en gran medida inútil.

Si, por otro lado, utilizamos LOC lógicos, nuestra medición dependería en gran medida de las idiosincrasias sintácticas del lenguaje. Aunque la métrica resultante podría ser un poco útil al comparar proyectos escritos en el mismo idioma, sería bastante inútil para proyectos escritos en diferentes idiomas.

Una posible fuente para el reclamo son las fallas de software de Les Hatton, locuras y falacias :

Podemos concluir que la elección del lenguaje de programación está, en el mejor de los casos, débilmente relacionada con la confiabilidad.

Más adelante, el artículo menciona densidades de defectos similares para C y C ++:

En un estudio reciente que comparó dos sistemas similares de tamaño similar (alrededor de 50,000 líneas cada uno), uno en C y otro en C ++ diseñado por objetos, se demostró que las densidades de defectos resultantes eran aproximadamente iguales en 2.4 y 2.9 por 1000 líneas respectivamente.

Sin embargo, esto no significa que el "error por LOC" sea constante en todos los lenguajes de programación, o que sería significativo si lo fuera.

Yannis
fuente
Si supone que los errores / la declaración son constantes, entonces hay una diferencia para los idiomas. El ejemplo de C comúnmente tiene errores en los argumentos for () y printf (). Si tuviera que codificar la funcionalidad de printf en su totalidad, tendría proporcionalmente más errores y si tuviera un lenguaje de nivel superior con una sola llamada printRepeat () habría menos oportunidades de equivocarse.
Martin Beckett
2
Resumen: los errores por punto de declaración / función son constantes, los lenguajes de bajo nivel tienen más código escrito por el programador falible, los lenguajes de alto nivel escribes menos, por lo tanto, menos errores. ¡Aunque los errores de diseño totalmente incorrectos son probablemente los mismos!
Martin Beckett
2
Sin mencionar que lo que constituye "un error" es altamente subjetivo, y que los errores difieren enormemente en severidad, impacto e importancia.
tdammers
@tdammers Y esa importancia puede ser negativa. Tenemos un puñado de errores a los que el cliente está acostumbrado / espera / quiere, por lo que no podemos solucionarlos ...
Izkata
@Izkata: depende de tu definición de error ...
tdammers
12

Esta observación es muy antigua y proviene de una fuente muy venerable, a saber, Fred Brooks en su libro "The Mythical Man Month". Fue gerente superior en IBM y administró muchos proyectos de programación, incluido el sistema operativo de millones de líneas OS / 360. De hecho, informó que la cantidad de errores en un programa no es proporcional a la longitud del código, ¡sino cuadrática ! Según su investigación, el número de errores fue proporcional a la duración del programa a la potencia 1.5. En otras palabras, un programa que es diez veces más largo tiene 30 veces más errores. E informó que esto se aplicaba a todos los lenguajes de programación y niveles de lenguajes de programación.

Steven Pemberton
fuente
6

No creo que los errores por LOC sean constantes para un idioma determinado. Los errores por LOC parecen una métrica que algunos gerentes usan para determinar la calidad de los desarrolladores cuando se trata del tiempo de revisión.

Ahora, aparte de eso, algunos idiomas son más propensos a errores o defectos que otros. Por lo general, pero no siempre, este es un lenguaje de nivel inferior que uno más alto. Por ejemplo, la codificación en C versus C # (o Java). Digo generalmente porque la realidad y el quid de la respuesta que busca se reduce a la calidad del desarrollador y las prácticas de codificación vigentes. He visto muy buenos desarrolladores de C con una calidad de código mucho más alta y recuentos de defectos más bajos que los desarrolladores promedio de Java / C #. Este es un elemento que separa a un desarrollador senior de uno junior. No cuántos LOC escriben en un período de tiempo determinado, sino la calidad del código que escriben independientemente del idioma, LOC o período de tiempo.

La única respuesta que puedo dar que podría relacionarse es que cuanto más LOC hay, más probable es que haya un defecto y más defectos existen.

Akira71
fuente
Mi pregunta es sobre el número promedio de defectos por línea de código independientemente del idioma.
Kristian
44
@ Kristian no hay tal número. Cambia por persona en relación con el trabajo y la experiencia del desarrollador y el idioma en el que están codificando. No creo que haya un promedio universal.
Akira71
1
@ Akira71 "no existe ese número" Bueno, claro. Pero hay distribuciones de probabilidad, de las cuales puede extraer números. Tampoco hay un número de cuántas pulgadas de lluvia caen anualmente en la selva amazónica, pero puede tomar un promedio.
Parthian Shot
3

Errores por línea de código

Bugs / LOC solo es relativo a un individuo. Para las empresas que implementan herramientas de seguimiento de errores que se vinculan con su repositorio de código fuente. Es posible que un gerente organice los problemas por desarrollador, ordenados por problemas pasados ​​y cambios de código.

Los errores son relativos a su trabajo

Un desarrollador de software senior, que tiene mucha experiencia, mucha habilidad, es muy inteligente y puede realizar trabajos independientes, es mucho más probable que tenga muchos más errores registrados en un sistema de seguimiento, que un desarrollador junior con poca experiencia.

¿Cómo es eso posible?

Los desarrolladores senior a menudo se dedican a tareas de desarrollo de mayor riesgo. Refactorización de código y construcción de nuevos sistemas como ejemplo. Los desarrolladores junior a menudo se asignan para solucionar problemas conocidos que no valen la pena el tiempo de un desarrollador senior.

Por lo tanto, mediante la asignación de tareas, un junior no está introduciendo errores, sino reparándolos, y un desarrollador senior tiene el riesgo de presentarlos, porque el beneficio de lo que están tratando de archivar es más importante que los problemas menores que se plantean al completarlos Tareas.

La sintaxis del idioma es importante

El argumento de que un lenguaje introduce menos errores, porque puede lograr más en menos líneas de código es un mito completo. Lenguajes altamente estructurados como C ++ / C # / Java obligan al desarrollador a expresar claramente por escrito cuál debería ser la instrucción deseada, ya que los lenguajes como Python / PHP son muy desestructurados. Esos lenguajes permiten expresiones escritas que no solo confundirán a un desarrollador, sino también al analizador de lenguaje.

El compilador reduce errores

¿Cuántos errores en Python / PHP han llegado a los servidores de producción, porque no había compilador para advertir al desarrollador que algo era incorrecto? Cuando mide errores por LOC, ¿es eso antes o después de que un compilador haya procesado el código fuente?

Actualización 2019:

Los compiladores no hacen ninguna diferencia en la naturaleza o el número de errores. Los errores son puramente relativos a la persona que escribió el código fuente, y los errores en sí mismos pueden ser de naturaleza muy subjetiva.

Reactgular
fuente
3
Recompilador para reducir errores: tanto Python como PHP técnicamente tienen compiladores, simplemente no hacen lo mismo comprobando que los lenguajes tipados estáticamente. Tampoco estoy de acuerdo en que dicha comprobación tenga un efecto significativo en el recuento final de errores porque prácticamente todos los errores que un compilador puede detectar se detectan con pruebas mínimas.
Winston Ewert
3
Se acordó que los errores que el compilador podría detectar, generalmente se detectarán con pruebas automáticas o manuales razonables. La diferencia es que los lenguajes tipados estáticamente le dan el primer paso de prueba (a) de forma gratuita y (b) muy, muy rápido. Un buen conjunto de pruebas unitarias de Ruby es mejor que un compilador, pero generalmente no puede ejecutarlas tan rápido, no las obtiene de forma gratuita, y normalmente no apuntan tan cerca de la línea de código que es el problema.
Ken Smith
Los tipos estáticos de @KenSmith no son gratuitos. course.cs.washington.edu/courses/cse590n/10au/…
Hugo Wood
1

FWIW, en mi experiencia

  1. Hay dos tipos de errores: a) donde el programa no cumple con las expectativas, yb) donde el programa no puede cumplir con ninguna expectativa razonable, porque se bloquea / se bloquea / no se compila.

  2. Independientemente del idioma, los errores de tipo (b) son causados ​​por la redundancia en la estructura de datos / clases, donde cambiar algo en una parte de la estructura de datos coloca la estructura en un estado inconsistente / roto hasta que se realicen uno o más cambios correspondientes en otras partes . Contribuir a esto es la redundancia del código fuente, donde una edición en una línea de código hace que el código sea incorrecto hasta que se realicen uno o más cambios en otras partes. Estos dos tipos de redundancia están estrechamente relacionados, por supuesto, y dado que los programadores no son superpersonas, se distraen, olvidan cosas y cometen errores, lo que provoca errores.

Estas cosas (de nuevo, en mi experiencia) no son realmente una función del lenguaje, sino de la habilidad / madurez del programador. Los programas que son mucho menos propensos a errores también tienden a ser mucho más pequeños, en términos de LOC, para un conjunto dado de funcionalidades.

He visto sistemas en los que algunas personas escriben programas, mientras que otras escriben directorios, y los primeros tienden a "simplemente funcionar" en comparación con los segundos.

Mike Dunlavey
fuente
1

Esperaría que un factor clave en los errores de codificación se relacione con lo que yo llamo la "brecha semántica" entre un tipo particular de definición de solución y el código para resolverlo; donde estos son errores de reformulación cercanos, sería más evidente, donde el código es muy diferente, se pueden esperar muchos errores. El paradigma de ciertos idiomas coincide estrechamente con ciertos dominios problemáticos: las hojas de cálculo son muy apropiadas para los cálculos comerciales cotidianos, lo que resulta en que muy poco "código" y el "código" estén muy cerca del dominio del problema. El código esperado es muy conciso (poco KLOC) y pocos errores. Por el contrario, usar ensamblador requeriría muchos KLOC y es probable que produzca una inmensa cantidad de errores.

Andreas Dinkelacker
fuente
¿Cómo fue esto rechazado? SO se está
llenando
0

En lugar de hablar sobre líneas de código, que de hecho son una métrica inútil, me gustaría abordar esta parte de su pregunta:

¿Los lenguajes de nivel superior conducen a menos errores?

Esto es diferente a los errores / LOC, porque los lenguajes de nivel superior hacen más con menos código. La implementación de algunos requisitos de características puede requerir 500 líneas de LISP frente a 15000 líneas de ensamblaje x86.

Por lo tanto, incluso si los errores / LOC son constantes entre todos los idiomas, el lenguaje de nivel superior seguirá produciendo menos errores.

Misko
fuente
2
¿Líneas de código una "métrica inútil"? No, es una aproximación aproximada de la complejidad del programa. Puede ser útil porque es fácil de medir y también está estrechamente relacionado con el tiempo de desarrollo.