You are a stupid programmer, you can't have that

[Brian Tiffin]

On Saturday, 7 August 2021 at 12:15:15 UTC, IGotD- wrote:
> ...
> Language designers seem to have a big brother attitude towards 
> programmers and think they will save the world by introducing 
> limitations.
>
> Examples.
> ...
> 2.
> Somewhat related. when Java was designed, the designer (James 
> Gosling I believe) claimed that programmers were too stupid to 
> understand the difference between signed and unsigned math 
> (despite often several years of university education) and 
> removed signed math entirely from the language. The impact is 
> that when unsigned math is required, you are forced to 
> conversions and library solutions. Not ideal when an HW APIs 
> deals with unsigned numbers for example.
>
> You are welcome to add any other examples that you find 
> significant for the discussion.
>
>
> This partially applies to D in some extent but can often be 
> found in other languages and mentality of several language 
> designers.
>
> The question is, do you think language designers go to far when 
> trying to "save" programmers from misuse or not?
> Do you think there can be approaches that both prevent bugs at 
> the same time do not limit the language?

Just to point out that using Java as a sample seems a bit off.  
Java (well, the JVM) is the ultimate in restrictive.  It's a 
compiler that doesn't emit CPU code, but safe(r) emulation in a 
sandbox.  Java stormed the Enterprise world because Business 
managers wanted safer code, and are willing to slow everything 
down for an extra margin of safety.  The JVM was not accepted en 
masse because bosses didn't trust users, but because they didn't 
trust the programmers.  It kept those pesky cubicle workers one 
level away from **their** hardware. They were promised less 
show-stopping mistakes while still allowing the hiring of all the 
coders they need to help automate everyone else out of work.  
That James and the other Java designers decided to lessen 
signed/unsigned transition errors by simply removing unsigned, is 
just par for the JVM course.

Walter seems to be trying to lead D development down paths he 
sees as smarter, and wiser in the large.  I don't get the sense 
that D is being designed for stupid programmers, or limited 
because of stupid. At least nowhere near the same league as with 
the JVM decisions *which was purposely built because 
non-technical people don't trust programmers (lacking the skills 
to quickly determine if one is foolish or wise, but still want to 
hire them all while pursuing business goals)*.

Just about everyone thinks they are a good driver, or they 
wouldn't drive.  But seat belts still save a lot of lives.  
*Would probably save even more, if we didn't all drive that 
little bit faster feeling safer behind a seat belt, in cars now 
designed to crumple more for less crumpling of passengers*.  They 
don't install guard rails on highways because *everyone* misses 
the turn, but some few might on a bad day, so there is a guard 
rail to limit the damage.

I've always viewed the JVM as programming in bumper cars.  There 
is a lot of fun to be had in bumper cars.  You can learn a lot 
about yourself and others.  Business leaders, particularly the 
non-technical, seem to agree.

I'm still new to D, but see it's present and future as an easy to 
read and write *feels safer, is safer* programming environment, 
at speed, en masse.

Have good, make well.