Super-dee-duper D features

[Nicolai Waniek]

I waited a long time to reply to this thread and I didn't read the
latest (let's guess, 60) messages replied to this thread because lots of
them where about LISP and of about how people think (recursively or not).

So why do I reply then? Because all this discussion about mixins and all
this stuff makes me a bit sad. I don't like it as well as I don't like
the C++ macros (and everyone on the #d channel knows that I really
_hate_ them...).

The main problem I have with mixins/templates and so on is that it
enables a programmer to change the "look and feel" of the language
completely. What is bad about it? That if you're working in a team
someone has a "great idea" and invents his own MyDSL. So what? Everyone
else has to "learn" this new DSL. So they spend time on something they
would've better spent on coding something else, or fixing bugs... I
worked in a team of about 8 persons bugfixing a project with
approximately 1.000.000 LoC. The former programmers just seemed to not
know how to code (and we programmed using Delphi!!! a language most
people like to tell you: "oh, that's a language that shows you how to
work structured" - that's totally bullshit!).
So on one hand, we had to improve the software as it was used by just
too many companies to completely rewrite it - on the other hand we had
to bugfix it with a syntax that even didn't look like Pascal. Now what?
If we had someone "just for the sake of it" implementing something with
his MyDSL, i would've probably killed him!

The thing I really want to say is: Stick to a clear definition on what
the language is, and what not. As long as I can remember - for example -
working on a python project was as easy as possible, because the
language just defined what is "and what not". If you let the programmer
decide and how to extend the language (and this is definitely possible
with templates and mixins and macros and the whole bunch of shitload).

Okay, there are some examples (even provided by Walter) on how to
properly use mixins and templates (for example letting the compiler
generate the byte-array for an icon file), but there's always someone
who thinks how "smart" he is and invents something that's just time
consuming to learn...

I think, that even templates are used too much at the moment (have a
look at tango, that's full of this). Why? because it doesn't fit into
the OOP pragma - you would've used some interface declarations and then
invented some functions that work on the interfaces instead of writing a
template... But well, there are some cases where templates are just nice.

I would really like to see more of the "details" implemented (runtime
type information, for example, or something like delphi's "type TClass =
class of TObject" to make it possible to create correct Object
Factories) instead of the new language features we got with the last few
releases.

I had a look at D because it was C++ just without all this stuff I
didn't like, but with the new language features, C++'s bad stuff is
simply replaced by something else that will definitely be used in the
wrong way (have a look at the apache headers, for example.
macros&macros&macros&...)

I really hope you will guide the D language into the right direction,
because I do like the language, but unfortunately, I don't like the
newest language features.

Best regards,
Nicolai