Falling into the pit of success is a often toted phrase in programming, and amongst people in programming languages. The idea behind the phrase is that in a well designed language, it is easier to write a correct program than an incorrect program. Because it’s easier to write a correct program, the programmer will nearly accidentally write the correct program, falling into it seemingly accidentally. This is done usually through strong typing, where incorrect programs aren’t considered programs, and through languages where the meaning of the program is easy to tell from looking at the program. This is also done through some software engineering libraries, where the code in it reads like a sentence in English.
x.OnRequest(GET) .Call(handler) //TODO: better example
When another user reads this code, they can understand it as well as they can understand normal english sentences. Similarly, writing in that code is as easy as writing in normal english sentences.
Conventions are certain restrictions imposed on developers. These conventions can be used to remove bad and dangerous patterns. One such type of convention is not allowing for global variables. Another type of convention is to make the program easier to understand for readers. For example, prepending m_ before private variables in C#. Many of the reasons for conventions are those same reasons to get developers to fall into the pit of success. Unfortunately, unlike a well designed programming language, or api, which will disallow through the type system and syntax things that go against conventions, conventions can be broken. During high pressure situations, like a looming deadline, justifications can be made to break those conventions, and discipline must be exercised to keep those conventions from being broken. However, in my experience, these justifications never are truly worth it, and don’t seem to pay off, but us humans are weak and will take that path of least resistance. Perhaps languages should make themselves easily modifiable, allowing companies to put in their own conventions into the system. Or perhaps in large releases of the language, existing and widely accepted conventions should be incorporated into the language.