People often talk what features are missing from their language of choice but what about vice versa? So here's a fun and subjective question, at the turn of the year (thought up during a hang-over, so bear with me):

  • What do you think are the most malicious programming language features ever invented?

Go ahead and be creative and controversial in your interpretation of what a malicious programming language feature is, e.g. unproductive, unsafe, insecure, incomprehensible, ambiguous, unpredictable, verbose, slow, superfluous, complex, unimplementable, etc.

Some random possible more-or-less boring candidates:

  • goto [control-flow, low-level] (suitable for low-level language, but perhaps not high-level ones - or perhaps only for a low-level named subset)
  • null [data-modeling, correctness] (imprecise types leading to undesired run-time value propagation)

and some perhaps more controversial candidates for good/bad measure:

  • checked exceptions [control-flow] (superfluous exception handling)
  • unchecked exceptions [control-flow] (missing exception handling; mitigated by good tools)
  • method overloading [ambiguity]
  • excessive implicit type coercions (and equality comparison) (e.g. javascript truth table)

This is realizing of course that a feature might be considered undesired in one language whilst not so in another, depending on what the language objectives are. There may be candidates might "interact" poorly with one group of features but not another.

In recent times the notion of language ergonomics has also been proposed to describe and justify language design.

Some inspiration.