Slashdot had an interesting ask slashdot article yesterday about when is it the right time to go whole-hog into interpreted/VM style language development.

http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml

As its an issue that we're all familar with, I figured I'd read and see why this article had 1000+ comments.  I was actually quite suprised to find a number of people, mostly C++ guys, clamoring for "native compilation plus garbage collection" or some variant thereof.  What was also suprising was the number of "have you not seen D yet?" replies to these posts, and how well they were modded *up*.  As slashdot is peer-moderated, this means that registered users of the site had to take the time to hand out positive reviews on those particular posts.

So I have to say: you guys rock.  Remember, slashdot users pretty much hung D from the yard-arm on not one but two articles about D.  What I saw today was a subtle, but noticable shift in this attitude.  The word finally seems to be getting out.

- EricAnderton at yahoo

pragma wrote:
> Slashdot had an interesting ask slashdot article yesterday about when is it the
> right time to go whole-hog into interpreted/VM style language development.
> 
> http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml
> 
> As its an issue that we're all familar with, I figured I'd read and see why this
> article had 1000+ comments.  I was actually quite suprised to find a number of
> people, mostly C++ guys, clamoring for "native compilation plus garbage
> collection" or some variant thereof.  What was also suprising was the number of
> "have you not seen D yet?" replies to these posts, and how well they were modded
> *up*.  As slashdot is peer-moderated, this means that registered users of the
> site had to take the time to hand out positive reviews on those particular
> posts.
> 
> So I have to say: you guys rock.  Remember, slashdot users pretty much hung D
> from the yard-arm on not one but two articles about D.  What I saw today was a

It's funny - in this high-tech business of constant change - how often I run into people who are extremely passionate about resisting change (myself included). It seems to be something in the makeup of 'techies', be it related to computers or not. I think it probably stems mostly from two things: 1) people invest a lot of time and effort into their skill sets and 2) many technical / engineering types have a "prove-it" attitude towards new stuff, especially stuff that may somewhat deprecate what has worked well for them in the past.

> subtle, but noticable shift in this attitude.  The word finally seems to be
> getting out.

In this particular case, I think some (many?) C++ coders are kind-of spotting the writing on the wall (they and/or C++ needs to change) but rightly see that "going whole hog" into things like Perl, Python and/or Java for every type of application is not the way to go either.

> 
> - EricAnderton at yahoo

pragma wrote:
> Slashdot had an interesting ask slashdot article yesterday about when is it the
> right time to go whole-hog into interpreted/VM style language development.

A while back, Ars Technica had an article on hardware level interpolation of binaries, but I haven't heard much about the idea since.  Still, it seems to make more sense than software emulation of a generic machine model.


Sean

pragma wrote:
> Slashdot had an interesting ask slashdot article yesterday about when is it the
> right time to go whole-hog into interpreted/VM style language development.
> 
> http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml
> 
> As its an issue that we're all familar with, I figured I'd read and see why this
> article had 1000+ comments.  I was actually quite suprised to find a number of
> people, mostly C++ guys, clamoring for "native compilation plus garbage
> collection" or some variant thereof.  What was also suprising was the number of
> "have you not seen D yet?" replies to these posts, and how well they were modded
> *up*.  As slashdot is peer-moderated, this means that registered users of the
> site had to take the time to hand out positive reviews on those particular
> posts.
> 
> So I have to say: you guys rock.  Remember, slashdot users pretty much hung D
> from the yard-arm on not one but two articles about D.  What I saw today was a
> subtle, but noticable shift in this attitude.  The word finally seems to be
> getting out.

I saw the article when it first came out, but I obviously need to go read the followups.

The gist of the article as I interpreted it is that people go to script languages because they are more productive. Why are they more productive?

1) garbage collection

2) dynamic typing

3) lots of libraries

D's got garbage collection.

Dynamic typing is interesting in that while it is more productive, it's a big reason why scripting languages will always be slooow. It's also interesting in that if you look real hard at C++ templates, a lot of what they are used for is to fake dynamic typing.

D is moving towards what I call implicit typing - I've been taking a hard look at where one is required to specify a type, and instead trying to figure out a way the type can be inferred instead (foreach is a good example). Implicit typing gets D a number of the benefits of dynamic typing with less complexity than the C++ template approach.

D doesn't have lots of libraries. But, in reality, C++ doesn't either, because it's too **** hard to write general purpose libraries in the absence of garbage collection. I believe that it's so much easier to write libraries in D that D will quickly surpass C++ in depth and breadth of libraries. Of course, that isn't good enough, we need to get to the Python or Ruby level of library support.

Walter Bright wrote:
> pragma wrote:
> 
>> Slashdot had an interesting ask slashdot article yesterday about when is it the
>> right time to go whole-hog into interpreted/VM style language development.
>>
>> http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml
>>
>> As its an issue that we're all familar with, I figured I'd read and see why this
>> article had 1000+ comments.  I was actually quite suprised to find a number of
>> people, mostly C++ guys, clamoring for "native compilation plus garbage
>> collection" or some variant thereof.  What was also suprising was the number of
>> "have you not seen D yet?" replies to these posts, and how well they were modded
>> *up*.  As slashdot is peer-moderated, this means that registered users of the
>> site had to take the time to hand out positive reviews on those particular
>> posts.
>>
>> So I have to say: you guys rock.  Remember, slashdot users pretty much hung D
>> from the yard-arm on not one but two articles about D.  What I saw today was a
>> subtle, but noticable shift in this attitude.  The word finally seems to be
>> getting out.
> 
> 
> I saw the article when it first came out, but I obviously need to go read the followups.
> 
> The gist of the article as I interpreted it is that people go to script languages because they are more productive. Why are they more productive?
> 
> 1) garbage collection
> 
> 2) dynamic typing
> 
> 3) lots of libraries
> 
> D's got garbage collection.
> 
> Dynamic typing is interesting in that while it is more productive, it's a big reason why scripting languages will always be slooow. It's also interesting in that if you look real hard at C++ templates, a lot of what they are used for is to fake dynamic typing.
> 
> D is moving towards what I call implicit typing - I've been taking a hard look at where one is required to specify a type, and instead trying to figure out a way the type can be inferred instead (foreach is a good example). Implicit typing gets D a number of the benefits of dynamic typing with less complexity than the C++ template approach.
 <snip>

Are you saying you will move towards SML like typing (Hindley-Milner type) ?

Please elaborate if you can.

-DavidM

David Medlock wrote:
> Are you saying you will move towards SML like typing (Hindley-Milner type) ?
> 
> Please elaborate if you can.

Nothing formal, just looking to extend type inference where it can be, such as:

	auto x = foo();

instead of:

	int x = foo();

David Medlock wrote:

> Walter Bright wrote:
> > pragma wrote:
> > 
> > > Slashdot had an interesting ask slashdot article yesterday about when  is it the right time to go whole-hog into interpreted/VM style language development.
> > > 
> > > http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml
> > > 
> > > As its an issue that we're all familar with, I figured I'd read and  see why this article had 1000+ comments.  I was actually quite suprised to find a  number of people, mostly C++ guys, clamoring for "native compilation plus garbage collection" or some variant thereof.  What was also suprising was the  number of "have you not seen D yet?" replies to these posts, and how well they  were modded *up*.  As slashdot is peer-moderated, this means that registered users  of the site had to take the time to hand out positive reviews on those  particular posts.
> > > 
> > > So I have to say: you guys rock.  Remember, slashdot users pretty much hung D from the yard-arm on not one but two articles about D.  What I saw today was a subtle, but noticable shift in this attitude.  The word finally seems  to be getting out.
> > 
> > 
> > I saw the article when it first came out, but I obviously need to go  read the followups.
> > 
> > The gist of the article as I interpreted it is that people go to script languages because they are more productive. Why are they more productive?
> > 
> > 1) garbage collection
> > 
> > 2) dynamic typing
> > 
> > 3) lots of libraries
> > 
> > D's got garbage collection.
> > 
> > Dynamic typing is interesting in that while it is more productive, it's  a big reason why scripting languages will always be slooow. It's also interesting in that if you look real hard at C++ templates, a lot of  what they are used for is to fake dynamic typing.
> > 
> > D is moving towards what I call implicit typing - I've been taking a  hard look at where one is required to specify a type, and instead trying  to figure out a way the type can be inferred instead (foreach is a good example). Implicit typing gets D a number of the benefits of dynamic typing with less complexity than the C++ template approach.
>  <snip>
> 
> Are you saying you will move towards SML like typing (Hindley-Milner type) ?

See Nemerle (http://nemerle.org/) - Hidney-Milner in C-family syntax. Looks
very promising.


-- 
AKhropov

Hi Andrej,
off topic, but thanks for the link. never heard about Nemerle before.
Phantastic, clean, modern language.!!
Bjoern
> See Nemerle (http://nemerle.org/) - Hidney-Milner in C-family syntax.
Looks
> very promising.
>
>
> -- 
> AKhropov

Andrei Khropov wrote:
> David Medlock wrote:
> 
> 
>>Walter Bright wrote:
>>
>>>pragma wrote:
>>>
>>>
>>>>Slashdot had an interesting ask slashdot article yesterday about when  is
>>>>it the right time to go whole-hog into interpreted/VM style language
>>>>development.
>>>>
>>>>http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml
>>>>
>>>>As its an issue that we're all familar with, I figured I'd read and  see
>>>>why this article had 1000+ comments.  I was actually quite suprised to
>>>>find a  number of people, mostly C++ guys, clamoring for "native
>>>>compilation plus garbage collection" or some variant thereof.  What was
>>>>also suprising was the  number of "have you not seen D yet?" replies to
>>>>these posts, and how well they  were modded *up*.  As slashdot is
>>>>peer-moderated, this means that registered users  of the site had to take
>>>>the time to hand out positive reviews on those  particular posts.
>>>>
>>>>So I have to say: you guys rock.  Remember, slashdot users pretty much
>>>>hung D from the yard-arm on not one but two articles about D.  What I saw
>>>>today was a subtle, but noticable shift in this attitude.  The word
>>>>finally seems  to be getting out.
>>>
>>>
>>>I saw the article when it first came out, but I obviously need to go  read
>>>the followups.
>>>
>>>The gist of the article as I interpreted it is that people go to script
>>>languages because they are more productive. Why are they more productive?
>>>
>>>1) garbage collection
>>>
>>>2) dynamic typing
>>>
>>>3) lots of libraries
>>>
>>>D's got garbage collection.
>>>
>>>Dynamic typing is interesting in that while it is more productive, it's  a
>>>big reason why scripting languages will always be slooow. It's also
>>>interesting in that if you look real hard at C++ templates, a lot of  what
>>>they are used for is to fake dynamic typing.
>>>
>>>D is moving towards what I call implicit typing - I've been taking a  hard
>>>look at where one is required to specify a type, and instead trying  to
>>>figure out a way the type can be inferred instead (foreach is a good
>>>example). Implicit typing gets D a number of the benefits of dynamic
>>>typing with less complexity than the C++ template approach.
>>
>> <snip>
>>
>>Are you saying you will move towards SML like typing (Hindley-Milner type) ?
> 
> 
> See Nemerle (http://nemerle.org/) - Hidney-Milner in C-family syntax. Looks
> very promising.
> 
> 

Thanks for the heads up.
It does look good!  Looks like dot Net only though.. :(

I hope they get either native or even translation to C.

-DavidM

David Medlock wrote:
> Andrei Khropov wrote:
>> David Medlock wrote:
>>
>>
>>> Walter Bright wrote:
>>>
>>>> pragma wrote:
>>>>
>>>>
>>>>> Slashdot had an interesting ask slashdot article yesterday about
>>>>> when  is
>>>>> it the right time to go whole-hog into interpreted/VM style language
>>>>> development.
>>>>>
>>>>> http://ask.slashdot.org/askslashdot/06/06/12/2044245.shtml
>>>>>
>>>>> As its an issue that we're all familar with, I figured I'd read
>>>>> and  see
>>>>> why this article had 1000+ comments.  I was actually quite suprised to
>>>>> find a  number of people, mostly C++ guys, clamoring for "native
>>>>> compilation plus garbage collection" or some variant thereof.  What
>>>>> was
>>>>> also suprising was the  number of "have you not seen D yet?"
>>>>> replies to
>>>>> these posts, and how well they  were modded *up*.  As slashdot is
>>>>> peer-moderated, this means that registered users  of the site had
>>>>> to take
>>>>> the time to hand out positive reviews on those  particular posts.
>>>>>
>>>>> So I have to say: you guys rock.  Remember, slashdot users pretty much
>>>>> hung D from the yard-arm on not one but two articles about D.  What
>>>>> I saw
>>>>> today was a subtle, but noticable shift in this attitude.  The word
>>>>> finally seems  to be getting out.
>>>>
>>>>
>>>> I saw the article when it first came out, but I obviously need to
>>>> go  read
>>>> the followups.
>>>>
>>>> The gist of the article as I interpreted it is that people go to script languages because they are more productive. Why are they more productive?
>>>>
>>>> 1) garbage collection
>>>>
>>>> 2) dynamic typing
>>>>
>>>> 3) lots of libraries
>>>>
>>>> D's got garbage collection.
>>>>
>>>> Dynamic typing is interesting in that while it is more productive,
>>>> it's  a
>>>> big reason why scripting languages will always be slooow. It's also
>>>> interesting in that if you look real hard at C++ templates, a lot
>>>> of  what
>>>> they are used for is to fake dynamic typing.
>>>>
>>>> D is moving towards what I call implicit typing - I've been taking
>>>> a  hard
>>>> look at where one is required to specify a type, and instead trying  to
>>>> figure out a way the type can be inferred instead (foreach is a good
>>>> example). Implicit typing gets D a number of the benefits of dynamic
>>>> typing with less complexity than the C++ template approach.
>>>
>>> <snip>
>>>
>>> Are you saying you will move towards SML like typing (Hindley-Milner
>>> type) ?
>>
>>
>> See Nemerle (http://nemerle.org/) - Hidney-Milner in C-family syntax.
>> Looks
>> very promising.
>>
>>
> 
> Thanks for the heads up.
> It does look good!  Looks like dot Net only though.. :(
> 
> I hope they get either native or even translation to C.
> 
> -DavidM

I've never understood this aversion to non-native languages.  Let's be
frank: native machine code is good, but it isn't the be-all and end-all.
 Nemerle was developed using .NET because that way they didn't have to
write a compiler; they could just use Reflection.Emit to generate their
assemblies.

Plus, it frees them from having to support every platform and processor separately.

As for .NET itself, I think it's excellent.  For most purposes, it's got plenty of performance (people are writing video decoders in C#), lots of different languages to use, and a fairly complete set of libraries.

I agree in that it would be fantastic to have something like Nemerle for native code, but I certainly won't discriminate against it just because it's managed.

	-- Daniel

P.S.  Just in case you get the wrong idea, I'm far from a .NET fanb0i. C# is only just "Ok" as a language, and the class library is painful in many places.  Still, it's better than Java *shudders*.

-- 
Unlike Knuth, I have neither proven or tried the above; it may not even make sense.

v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP  http://hackerkey.com/