Since I am allways looking for new friends <g> ,and because my opinion does not fit into the "D - more or less power than C++" discussion, another opinion: D - more power than (really) needed !

Preface :
I guess most people here coming from C++/Java .. my background (Modula/Oberon/4GL) is different.
Ergo : I have an other view regarding D.
So why D has enough power ?

Templates nice to have, but nessesary ? No. Let me quote Betrand Meyer.
~~~ "Inheritance is more powerfull than  using templates"
Yes, I know Eiffel supports templates but the point is that everything can also be done using inheritance. And heh, we have GC.
Also, i feel using templates is like learing an dialect. (well D's implementation is at least readable)

The Oberon Language spec. has 18 pages is extremly simple and
enables you to create an combined code/text/graphic editor, using inheritance and a good choice of patterns,  which has much more power than let's say Scintilla.
So I wonder how can this be done with such a simple language, and
what does it mean for D? D more power than REALLY needed!

One of the things that I found really impressive (and unexpected) is that D code is readable. Good Design!

Just my opinion.
Björn Lietz-Spendig
SIMPLE IS BEAUTIFULL

bls wrote:
> Since I am allways looking for new friends <g> ,and because my opinion does not fit into the "D - more or less power than C++" discussion, another opinion: D - more power than (really) needed !
> 
> Preface :
> I guess most people here coming from C++/Java .. my background (Modula/Oberon/4GL) is different.
> Ergo : I have an other view regarding D.
> So why D has enough power ?
> 
> Templates nice to have, but nessesary ? No. Let me quote Betrand Meyer.
> ~~~ "Inheritance is more powerfull than  using templates"
> Yes, I know Eiffel supports templates but the point is that everything can also be done using inheritance. And heh, we have GC.
> Also, i feel using templates is like learing an dialect. (well D's implementation is at least readable)
> 
> The Oberon Language spec. has 18 pages is extremly simple and
> enables you to create an combined code/text/graphic editor, using inheritance and a good choice of patterns,  which has much more power than let's say Scintilla.
> So I wonder how can this be done with such a simple language, and
> what does it mean for D? D more power than REALLY needed!
> 
> One of the things that I found really impressive (and unexpected) is that D code is readable. Good Design!
> 
> Just my opinion.
> Björn Lietz-Spendig
> SIMPLE IS BEAUTIFULL
> 
> 
> 


It's ironic that the overview page on the digital mars website makes comments about C++ having many "islands" ..
I think back then D didn't have templates. Well, now it does, and those comments are applicable to D as much as they are to C++

<quote src=http://www.digitalmars.com/d/overview.html>
C++ programmers tend to program in particular islands of the language, i.e. getting very proficient using certain features while avoiding other feature sets. While the code is usually portable from compiler to compiler, it can be hard to port it from programmer to programmer. A great strength of C++ is that it can support many radically different styles of programming - but in long term use, the overlapping and contradictory styles are a hindrance.
</quote>

Hasan Aljudy wrote:

> bls wrote:
>> Since I am allways looking for new friends <g> ,and because my opinion does not fit into the "D - more or less power than C++" discussion, another opinion: D - more power than (really) needed !
>> 
>> Preface :
>> I guess most people here coming from C++/Java .. my background
>> (Modula/Oberon/4GL) is different.
>> Ergo : I have an other view regarding D.
>> So why D has enough power ?
>> 
>> Templates nice to have, but nessesary ? No. Let me quote Betrand Meyer.
>> ~~~ "Inheritance is more powerfull than  using templates"
>> Yes, I know Eiffel supports templates but the point is that everything
>> can also be done using inheritance. And heh, we have GC.
>> Also, i feel using templates is like learing an dialect. (well D's
>> implementation is at least readable)
>> 
>> The Oberon Language spec. has 18 pages is extremly simple and
>> enables you to create an combined code/text/graphic editor, using
>> inheritance and a good choice of patterns,  which has much more power
>> than let's say Scintilla.
>> So I wonder how can this be done with such a simple language, and
>> what does it mean for D? D more power than REALLY needed!
>> 
>> One of the things that I found really impressive (and unexpected) is that D code is readable. Good Design!
>> 
>> Just my opinion.
>> Björn Lietz-Spendig
>> SIMPLE IS BEAUTIFULL
>> 
>> 
>> 
> 
> 
> It's ironic that the overview page on the digital mars website makes
> comments about C++ having many "islands" ..
> I think back then D didn't have templates. Well, now it does, and those
> comments are applicable to D as much as they are to C++
> 
> <quote src=http://www.digitalmars.com/d/overview.html>
> C++ programmers tend to program in particular islands of the language,
> i.e. getting very proficient using certain features while avoiding other
> feature sets. While the code is usually portable from compiler to
> compiler, it can be hard to port it from programmer to programmer. A
> great strength of C++ is that it can support many radically different
> styles of programming - but in long term use, the overlapping and
> contradictory styles are a hindrance.
> </quote>

I have to disagree that this is yet a problem. In C++, the templates look radically different from the rest of the language. Templates in D actually look like the rest of the language, only that you have to use recursion to get the advanced stuff working. (I know that I made a similar advocacy against templates three years ago, but I've changed my mind...).

I think that walter has been good at adding features that are easy to grok even for those new to the language, they don't really syntactically crash.

bls wrote:
<snip>
> Templates nice to have, but nessesary ? No. Let me quote Betrand Meyer.
> ~~~ "Inheritance is more powerfull than  using templates"

Having both must be even more powerful then.

> Yes, I know Eiffel supports templates but the point is that everything can also be done using inheritance. And heh, we have GC.

Would you care to supply an example?

<snip>
> The Oberon Language spec. has 18 pages is extremly simple and
> enables you to create an combined code/text/graphic editor, using inheritance and a good choice of patterns,  which has much more power than let's say Scintilla.
> So I wonder how can this be done with such a simple language, and
> what does it mean for D? D more power than REALLY needed!
<snip>

There are Turing-complete languages that are even simpler than this.

Stewart.

-- 
-----BEGIN GEEK CODE BLOCK-----
Version: 3.1
GCS/M d- s:- C++@ a->--- UB@ P+ L E@ W++@ N+++ o K-@ w++@ O? M V? PS- PE- Y? PGP- t- 5? X? R b DI? D G e++>++++ h-- r-- !y
------END GEEK CODE BLOCK------

My e-mail is valid but not my primary mailbox.  Please keep replies on the 'group where everyone may benefit.

"bls" <lietz@wanadoo.fr> wrote in message news:dubqrg$10ad$1@digitaldaemon.com...
> Since I am allways looking for new friends <g> ,and because my opinion does not fit into the "D - more or less power than C++" discussion, another opinion: D - more power than (really) needed !
>
> Preface :
> I guess most people here coming from C++/Java .. my background
> (Modula/Oberon/4GL) is different.
> Ergo : I have an other view regarding D.
> So why D has enough power ?
>
> Templates nice to have, but nessesary ? No. Let me quote Betrand Meyer.
> ~~~ "Inheritance is more powerfull than  using templates"
> Yes, I know Eiffel supports templates but the point is that everything can
> also be done using inheritance. And heh, we have GC.
> Also, i feel using templates is like learing an dialect. (well D's
> implementation is at least readable)
>
> The Oberon Language spec. has 18 pages is extremly simple and
> enables you to create an combined code/text/graphic editor, using
> inheritance and a good choice of patterns,  which has much more power than
> let's say Scintilla.
> So I wonder how can this be done with such a simple language, and
> what does it mean for D? D more power than REALLY needed!
>
> One of the things that I found really impressive (and unexpected) is that D code is readable. Good Design!
>
> Just my opinion.
> Björn Lietz-Spendig
> SIMPLE IS BEAUTIFULL

If inheritance is so powerful, then why did Java adopt generics?  If Oberon is so great, why doesn't everyone use it?  The purist OOP ideology is a narrow-minded perspective of programming.  Just because you don't use or understand generic programming does not mean that it is not incredibly useful and/or necessary.

A lot of the bias towards OOP purism comes from Java vs. C++ comparisons, much more convincing than Anything vs. D.  Hopefully the simplicity and power of D can help to eliminate OOP purism.

-Craig

"Craig Black" <cblack@ara.com> wrote in message news:dun68p$30kv$1@digitaldaemon.com...
> A lot of the bias towards OOP purism comes from Java vs. C++ comparisons, much more convincing than Anything vs. D.  Hopefully the simplicity and power of D can help to eliminate OOP purism.

The trouble with OOP is, well, not everything is an object. For example, take the trig function sin(x). It's not an object. Of course, we could bash it into being an object, but that doesn't accomplish anything but obfuscation.

Sometimes, I think C++ went hard over in the opposite direction - nothing is an object. OOP programming seems to be regarded as "oh, so 90's" by the modern C++ crowd.

Every decade seems to have its programming buzzword:

60's: artificial intelligence
70's: structured programming
80's: user-friendly
90's: object oriented programming
00's: metaprogramming

In article <duogj1$22ij$1@digitaldaemon.com>, Walter Bright says...
>
>
>"Craig Black" <cblack@ara.com> wrote in message news:dun68p$30kv$1@digitaldaemon.com...
>> A lot of the bias towards OOP purism comes from Java vs. C++ comparisons, much more convincing than Anything vs. D.  Hopefully the simplicity and power of D can help to eliminate OOP purism.
>
>The trouble with OOP is, well, not everything is an object. For example, take the trig function sin(x). It's not an object. Of course, we could bash it into being an object, but that doesn't accomplish anything but obfuscation.
>
>Sometimes, I think C++ went hard over in the opposite direction - nothing is an object. OOP programming seems to be regarded as "oh, so 90's" by the modern C++ crowd.
>
>Every decade seems to have its programming buzzword:
>
>60's: artificial intelligence
>70's: structured programming
>80's: user-friendly
>90's: object oriented programming
>00's: metaprogramming
>
>

Then, it may be in D's best interest to start thinking which will be the 10's buzzword ;)

--
Sebastián.

Sebastián E. Peyrott wrote:
> In article <duogj1$22ij$1@digitaldaemon.com>, Walter Bright says...
> 
> Then, it may be in D's best interest to start thinking which will be the 10's
> buzzword ;)

"Concurrent." ;-)


Sean

Walter Bright wrote:
> "Craig Black" <cblack@ara.com> wrote
> 
>> A lot of the bias towards OOP purism comes from Java vs. C++ comparisons, much more convincing than Anything vs. D. Hopefully the simplicity and power of D can help to eliminate OOP purism.
> 
> The trouble with OOP is, well, not everything is an object. For example, take the trig function sin(x). It's not an object. Of course, we could bash it into being an object, but that doesn't
> accomplish anything but obfuscation.
> 
> Sometimes, I think C++ went hard over in the opposite direction -
> nothing is an object. OOP programming seems to be regarded as
> "oh, so 90's" by the modern C++ crowd.
> 
> Every decade seems to have its programming buzzword:
> 
> 60's: artificial intelligence
> 70's: structured programming
> 80's: user-friendly
> 90's: object oriented programming
> 00's: metaprogramming 

I sometimes view the programming language scene as a small forest. We have massive cross-pollination between species there, new "pure" species come up every now and then, and once they grow, other new species start getting dna from them too. In time most of the good ideas get spread around. And those who can receive new dna in adulthood, stay fit and prosper.

 Conversely, what one does see is old, big trees that are dry and hollow, just rutting or drying as they stand. One can even see trees die suddenly, felled by the wind.

But like in the real world, one never sees the moment a language is born. Only when it's grown enough to get one's attention do we see it.

With D we're pretty close. With Perl, I happened to stumble on a copy of Perl when it was like D was some 4 years ago. I thought "gee, nice idea", but never did it cross my mind that Perl "would take the world".

Heh, Practical Extraction and Reporting was all over the pages, the word Perl was sort-of incidental looking in comparison. In spite of being big (as in huge) today, Perl is also a thriving language. One thing that [come to think of it] advertises this is the version numbering. On my 0.8GHz laptop, Perl is 5.8.6. Being the pathological anarchist that Larry Wall is, he couldn't care less about striving to nice round version numbers. Which I think is actually an excellent principle. As a matter of fact, such would only become a dragstone if one hopes for unhindered renewal and improvement.

---

Today, advertising major version numbers (and shoving the minors under the rug) is corporate. As in Oracle, Windows, Solaris. Nobody seems to mind if this or that script contains a line requiring at least version x.x.374 of Perl. Folks just shrug and download it. Look at Apple.

If we, with D, can maintain backwards compatibility (no more than what Walter -- and we all, currently aim to), then such would not be a problem here either. We could skip the "Major version every 2 years, bug fixes in between" mantra, and make D more into a pipeline -- like a continuous process. (We're on the Net: no need to plan the manual books and boxes, and the ad campaign 18 months in advance.)

This sounds daring, I admit, but we've seen it done. And if we do it on purpose (vs. ending up there), then we can do it in style and elegance. It is for this thing we have the /deprecated/ keyword. If we only made major steps, who'd care about that -- there'd be so much else to plan ahead when switching to the new version at the sweat shop. (And most of the existing software would stay updated with the old version anyway.)

A three-level numbering is handy. Last position changing each time folks would want to read the Fixed list, middle version changing whenever they might want to review the readme. And of course, the first position changing whenever major things are implemented. Odd middles for developers, even for everyone.

---

But anyhow, the fact remains, we don't need to do D in discrete steps. We can do a slope.

Any grad school math teacher can write a *proof* (using differential calculus) that steps lose compared to the continuous. So it's not just good practice (especially in the modern, exponentially accelerating world), but also theoretically provable.

Georg Wrede wrote:

> Heh, Practical Extraction and Reporting was all over the pages, the word Perl was sort-of incidental looking in comparison. In spite of being big (as in huge) today, Perl is also a thriving language. One thing that [come to think of it] advertises this is the version numbering. On my 0.8GHz laptop, Perl is 5.8.6. Being the pathological anarchist that Larry Wall is, he couldn't care less about striving to nice round version numbers. Which I think is actually an excellent principle. As a matter of fact, such would only become a dragstone if one hopes for unhindered renewal and improvement.

Larry Wall is actually quite careful about numbers and language...

As in http://www.perl.com/pub/a/2000/10/23/soto2000.html ("TPC4")


But unfortunately, Perl has been losing some ground to Python lately.

At least as a system adminstration language, which is where I use it.


Hopefully, Parrot will change all of that nonsense :-)

http://dev.perl.org/perl6/

--anders