Earlier quoted context omitted.
These "king gets wisdom from dressing as regular person" stories are great, and it's definitely a great idea for higher level folks to sample the ground truth themselves on a regular basis. CEOs are at a real danger of being surrounded by yes-men, and it's very possible that through conditioning and repetition they might actually start believing insane corporate positions. However, there's a real smell of something g…
The CEO can easily see problems that the line workers don't see as problems. For example, I happily programmed in C for many years while not even noticing severe problems with the language. Later broader experience with other languages led me to wonder why I didn't see the problems with C before, even though they were negatively affecting my work.
S s;
S *p;
To read a field: s.field
p->field
It turns out that there's no ambiguity in using `.` for both `.` and `->`. Both can be: s.field
p.field
But what's the problem with `->`? It's when you want to refactor the code to switch between a value to a reference. If `.` is used for both, just change the typedef and maybe a couple places. With `.` and `->`, there are maybe thousands of tedious changes to make in the code base. The inevitable result of this is you're not going to attempt such a refactor, as it's too much work. The code stays in the way it was originally designed.I was able to see this only via broader experience with other languages. I never even noticed the issue before.
C++ addressed this not by fixing it, but by introducing the reference type. But the C++ ref type brings along with it all kinds of new problems, which I won't get into here.