April 2018
As with most other kinds of tools, programming languages can be designed and evolved in two fundamentally different ways.
For one there is the possibility for design to be born out of practical needs. The first adequate version of the tool is the first solving a real-world problem. Its feature set hence represents the minimum framework required to actually do the stuff the tool is intended for. Further growth comes out of the desire to be applicable to a broader range of use-cases. As this Organic Approach of Design continues to shape the product, the tool inevitably grows more and more complex with no defined core principles foreclosing this undisciplined morphogenesis.
A successful example of this design approach is Perl 5, a powerful and pragmatic programming language originally intended as a tool for report processing, later also CGI scripting, later also bioinformatics, later also developing MVC web-services, later also data analysis, later also GUI programming, nowadays also practically everything else. The design principles underpinning the development of Perl are very vague and allow for continuous unrestricted growth.
Opposing that method is the idea of Principled Design, which treats abstraction and generalization as a blessing, exceptional behavior and special cases — either unintentional or justified by pragmatism — as a curse. The theoretical optimum to strive for here is the most minimal tool regarding the amount of core principles. The first adequate version of the tool is the first satisfying the designer's desire for minimalism. Avoiding further unnecessary growth is one of the main means to achieve the absolute main objective: keeping things simple.
The ideal physics engine — neglecting impure concerns like performance or compliance with arbitrary standards — thus would be aware of nothing more than F=ma and Newton's law of universal gravitation.
A utilization of this school of design is present in Scheme, an elegant programming language based on a functional core (lambda, if, define, and quote) only extended by the minimum required feature set to support imperative programming (set!, begin, and call/cc) and means of defining user-provided forms to supplement the shortage of in-built control structures.
A very noticeable psychological phenomenon is that simple, i.e. principled, tools appeal to a tremendously large group of hackers. This especially shows when weighting the market share of languages like Scheme, Smalltalk, or Forth amongst hackers compared to their general position in the whole software engineering community. As these tools are not all that mainstream, this incident might be partly due to hackers' general intellectual curiosity leading them to even find out about these projects in the first place, although that would still leave the spotters with the freedom to despise those as absurdities as they commonly do with needlessly complex tools like COBOL. This means there must be something about simplicity, that makes it so attractive to hackers. What is it?
Maybe simplicity is worthy for its own sake and the ease it brings to the state of mind. However I would argue that said ease is appreciated by every individual and not just hackers, thus there has to be a deeper more fundamental reason more closely tied to a hacker's world view. In order to disclose this truth, we have to ask ourselves what hackers really want. A surprisingly accurate exaggeration is that all that hackers want is power, which straightforwardly comes out of flexibility and moldability of tools and interestingly enough principled design is probably the most direct path to flexibility.
In order for an absurdly small set of core features to be as applicable as a tremendously large set of highly-concrete ones, the small core has to be so flexible that the second set can be constructed out of it. And since the core was explicitly designed to not rely on all-too-concrete forms, you can be almost sure that it can be used to construct an even bigger and even more specialized pool of features. This property of simplistic systems also allows for discoverability, which makes them excellent tools for exploring newly found abstractions and paradigms, which definitely adds to their appeal.
Simplicity and principled design aren't the only ways to achieve flexibility though. As of its fifth incarnation, Perl not only tries to give you all the tools to build everything, but also all the tools to build all the tools to build everything. Simplicity is however for sure the safest indicator of malleability, as a tool can not be minimalist and practical as well as inflexible at the same time.
This in turn means that designers aware of the difficulties associated with complex systems should focus on simplicity besides functionality too as it usually introduces flexibility all by itself. Hackers — being creators themselves — realize this and also appreciate it.