null references redux + Looney Tunes

[Nick Sabalausky]

"language_fan" <somewhere at internet.com.invalid> wrote in message 
news:ha87kd$2j3d$1 at digitalmars.com...
> On Sat, 03 Oct 2009 14:35:22 -0400, Jeremie Pelletier wrote:
>>
>> Think of the english languages, how many words does it have? I would
>> hate to try and express my ideas if I had only 100 words to choose from.
>> Some people do but we call them simple minded or uneducated :)
>
> Comparing spoken languages and formal languages used to program computers
> is rather far fetched. Even a small child recognizes more words than a
> complex programming language has keywords. There are programming
> languages with rather minimal set of core keywords and constructs. This
> makes them in no way more suitable for less intelligent people.

I think his point was that number of keywords isn't a particularly good 
measure of language complexity. To bring it back to programming languages, 
VB has keywords coming out the wazoo, but the only thing complex about VB is 
the complexity involved in trying to express high-level (or low-level) 
concepts that VB is just too *simple* to handle.

> And your
> stance of disagreeing with everyone here does not make you better than
> the rest of us, it is just irritating.
>

I think I missed the memo indicating that disagreeing with others had 
suddenly become a bad thing. ;)

> D is pretty verbose in many respects. There are some totally unnecessary
> words like 'body' in the grammar. Also things like foreach_reverse should
> just die. Even a novice programmer can write a meta-program to replace
> foreach_reverse without any runtime performance hit. Designing a crappy
> programming language is not hard. Usually the elegance arises from clever
> use of powerful, generic core structures.

Fair enough. *But*, I really think "elegantly simple" language design is 
double-edged sword. In my experience, and I think this is what Jeremie was 
alluding to, I've found that an "elegantly simple" language, no matter how 
well-chosen the primitives are, generally results in a problematic lack of 
expressiveness and a frequent sense of fighting against the language instead 
of merely using it.

For example, the most elegantly simple languages I've seen are Java (at 
least earlier versions, anyway), JavaScript, Smalltalk, Haskell, and maybe 
Forth. And I really do admire those languages from a theoretical 
perspective...but only in the same sense that I admire Brainfuck. I'd never 
want to actually use any of those languages for any real work simply because 
their "elegantly simple" designs lead to many cases where I'd have to (or 
have had to) fight against them to accomplish what I need. I guess it just 
comes down to "as simple as possible, *but no more*."

In a more complex language like D, I never feel like I need to try to keep 
the whole langauge in my head. I just need some subset at any particular 
time, and then when (and I do mean "when", not "if"), when I need something 
else, it's nice to know that it's there to use and that I won't have to try 
to cram it into the wrong tool for the job or constantly switch between an 
array of languages while trying to keep them all playing nice with each 
other.

It's like a professional handyman having the smallest possible possible 
toolbox with only the barest essentialls, versus a big super-toolbox that 
has all the *right* tools he might need. Just because it's there doesn't 
mean it has to be used, but if I were a handyman and had to remove a 
phillips-head screw, I'd want to be able to reach for a forward/reverse 
drill and an appropriately-sized phillips-head bit, and not have to pry it 
out with the bare minimum (the back of a hammer, or a 
sort-of-sized-similarly manual flathead screwdriver), and also not have to 
put one specialized mini-toolbax back and switch to a 
differently-specialized mini-toolbox for every different task.