Programming language criterion for coding mistakes [closed] - language-agnostic

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 years ago.
Improve this question
When comparing programming languages and IDEs, I think there is one criterion that is never mentioned and I think is very important.
Question :
Do you know if there exist a definition of this criterion (which I'm going to define)? Please provide references.
The criterion, which I'll call "coding mistakes index", represents the number of coding mistakes that will be caught by the programming environment before runtime.
It’s a percentage, as related to the IDE+language.
For example, a hello world in Eclipse+java: if I delete one of the bold letters, an error message is presented.
package main;
public class Main{
public static void main(String[] args ){
System.out.println(" Hello Horld ");
}
}
In this example: there are 91 bold letters out of 106 letters which make 86%.

Answer 1

From my personal experience, I'd have to say that's a very useless metric. The number of syntax errors caught by the compiler or interpreter before runtime is 100% for all languages. What you've demonstrated is a syntax error.
Syntax errors usually happen when you're learning a language. Or when you're programming in a language that you haven't touched in a while. Generally, a proficient programmer will internalize the language's syntax and avoid them while typing. For example, C programmers quickly learn to end statements with ; and Lisp programmers quickly learn to keep track of braces (usually by learning to neatly indent code).
In industry, such trivial language detail as syntax or types are very, very rarely the cause of bugs even in languages with minimal syntax or have no type systems. Most bugs you'll encounter are in the form of:
package main;
public class Main{
public static void main(String[] args ){
System.out.println(" Goodbye World ");
}
}
See what I did there? The bug is the use of the word "Goodbye" instead of "Hello". Bugs are rarely accidental - buggy code almost always look correct and intentional and almost always compile without errors (otherwise they'll be called compile errors not bugs). Bugs are usually caused by a misunderstanding of what the code should do.
Another reason it's a useless metric is different languages have different levels of verbosity. Of the following two examples:
Example 1:
package main;
public class Main{
public static void main(String[] args ){
System.out.prntln(" Hello World ");
}
}
Example 2:
prnt " Hello World \n";
Both examples are exactly the same program in different languages with exactly the same bug. But example 1 would have a higher "coding mistakes index" while example 2 would have a lower index. This is simply because there's less code in example 2 to begin with therefore syntax errors account for a lower percentage of the typed characters.
But from a readability standpoint a human can easily spot the mistake in example 2 without even running the compiler or using an IDE while the mistake in example 1 is easily overlooked.
This means that the coding mistakes index is not only not useful but can even be misleading by giving a potentially better language a lower score.
How useful is a benchmark/metric is directly related to how likely it is to exist. A useless metric is unlikely to be used and therefore is unlikely to be invented/exist. A metric that's completely wrong is very likely to be ignored by everyone even if someone invents it.