-nogc

[Joel C. Salomon]

bearophile wrote:
> Making things more orthogonal can be quite useful and it allows more flexibility, but having common things implemented as magic is sometimes good because you need less knowledge to use the language, you need less time to understand code written by other people (because there are less general ways to do something), and this allows for more sharing of code, and you may cover most of the common usages anyway. So the risk of making things more orthogonal is to over-generalize. Scheme language (that is very orthogonal) shows this failure very well, this is a related quotation:
> 
>> In practice Scheme follows exactly the opposite route: there are dozens of different and redundant object systems, module systems, even record systems, built just by piling up feature over feature. So the minimalism of the core language is just a lie or at best a red herring (the core language can be minimalistic, but the core language is basically useless for any real life job).<

The difference here is that a core of these semi-magic features is
standard.  You’ll never write “std.Array!(T)” in real code; you’d use
“T[]”.  You might still replace the core library with custom versions of
Object &c., but you ought not to be tempted to do so.

—Joel Salomon