Hi all. There are a few things which have been bothering me as of late, and
I want your opinions on them to know whether or not I'm jumping at shadows.
For starters, we all have a common goal of making D as widely used as
possible since we all love the language, otherwise we probably wouldn't be
here. At the same time, there are a few factors which as I see it make the
adoption of D much more difficult and need to be addressed if we intend to
succeed:
1. 1.0 doesn't appear to be any special sort of marker with regard to the
standard; we have not only CTFE but mixins added post-1.0, along with
numerous changes to the _standard_library. I understand the compiler can be
made to strictly conform to the 1.0 spec, but the fact still remains it
seems very ad hoc. What ought to happen IMO is that we first call a review
of the language spec where everyone sends in any complaints they have and
they must be clearly addressed to everyone's satisfaction, or at least to
the degree that's possible. Then, the spec ought to be frozen for a while,
and we work strictly on the standard library, which I'll address later.
Then, the whole D language, including standard library, ought to be frozen
for several years to let it proliferate throughout the technical community;
an experimental compiler can of course undergo development, but clearly
marked as such and _separate_ from the stable compiler.
2. We have two competing standard libraries; this is nowhere near good.
Phobos is basically built on C wherever possible and sort of thrown
together, and Tango reminds me of Java with a class for everything and then
some. For the standard's sake (and consequent adoption), D needs one
accepted standard library. The current state makes that difficult because
Walter is forced to hand-manage both the compiler and library. What ought to
happen IMO is that Walter should delegate day to day library management to a
trusted associate who will occasionally inform Walter of the latest
developments; Walter makes the final call, and life goes on.
So to conclude, these are issues that have been sort of addressed at various
times in other issues, but never to a point that accomplished the intended
goal. The D community is growing; there are going to be a lot of new people
that look at it now and say "Huh? Say again?" Maybe we ought to step back
and forget the years we've had to become comfortable with D and analyze it
from a potential user's point of view in order to make adoption easier.
Thoughts?

Ameer Armaly Wrote:

> 1. 1.0 doesn't appear to be any special sort of marker with regard to the standard; we have not only CTFE but mixins added post-1.0, along with numerous changes to the _standard_library. I understand the compiler can be made to strictly conform to the 1.0 spec,

Exactly, so you can continue to develop for the 1.0 spec, and that code will work, to my understanding, as advertised.

>but the fact still remains it
> seems very ad hoc.

> Then, the whole D language, including standard library, ought to be frozen for several years to let it proliferate throughout the technical community;

I totally disagree with this statement.  We have a frozen implementation of D 1.0, and a frozen spec for the language of D 1.0.  That can proliferate as much as people like.  I feel that as long as future 1.x compilers support 1.0 code, people can write 1.0 code and it will work universally on people's compilers.

> an experimental compiler can of course undergo development, but clearly
> marked as such and _separate_ from the stable compiler.
> 2. We have two competing standard libraries; this is nowhere near good.

I feel that this is perfectly fine.  People can develop a program using either library and I can compile it on my system.  10 libraries would be retarded, and very bad.  2 really isn't.

> Phobos is basically built on C wherever possible and sort of thrown together, and Tango reminds me of Java with a class for everything and then some. For the standard's sake (and consequent adoption), D needs one accepted standard library.

I disagree, in fact being able to plug in a library according to your programming philosophy will probably allow us to develop superior programs.

> The current state makes that difficult because Walter is forced to hand-manage both the compiler and library. What ought to happen IMO is that Walter should delegate day to day library management to a trusted associate who will occasionally inform Walter of the latest developments; Walter makes the final call, and life goes on.

My understanding is that Walter develops and maintains D and D language spec; and that he wrote the original Phobos.  I think someone else is maintaining Phobos under that system, while yet someone else is maintaining Tango and releasing without constant verification from Walter - and with Walter's occasional contributions.

> So to conclude, these are issues that have been sort of addressed at various times in other issues, but never to a point that accomplished the intended goal. The D community is growing; there are going to be a lot of new people that look at it now and say "Huh? Say again?" Maybe we ought to step back and forget the years we've had to become comfortable with D and analyze it from a potential user's point of view in order to make adoption easier.

D is constantly being nitpicked on this forum - and the fact that it hasn't been feature frozen has allowed it to continue to be nitpicked and evolve into a better language.  I feel that the current process Walter is employing is almost even more important than the language itself; as clearly C++ and C stagnated leading for a need to replace those languages.

Sincerely,
Dan

Ameer Armaly wrote:
> Hi all. There are a few things which have been bothering me as of late, and I want your opinions on them to know whether or not I'm jumping at shadows. For starters, we all have a common goal of making D as widely used as possible since we all love the language, otherwise we probably wouldn't be here. At the same time, there are a few factors which as I see it make the adoption of D much more difficult and need to be addressed if we intend to succeed:
> 1. 1.0 doesn't appear to be any special sort of marker with regard to the standard; we have not only CTFE but mixins added post-1.0, along with numerous changes to the _standard_library. I understand the compiler can be made to strictly conform to the 1.0 spec, but the fact still remains it seems very ad hoc. What ought to happen IMO is that we first call a review of the language spec where everyone sends in any complaints they have and they must be clearly addressed to everyone's satisfaction, or at least to the degree that's possible. Then, the spec ought to be frozen for a while, and we work strictly on the standard library, which I'll address later. Then, the whole D language, including standard library, ought to be frozen for several years to let it proliferate throughout the technical community; an experimental compiler can of course undergo development, but clearly marked as such and _separate_ from the stable compiler.

The idea of a separate compiler for experimental features has come up in the past and I think it's a good one.  But if it's easier for Walter to maintain a single compiler and provide a feature switch then that seems fine as well.  Also, other review models have been suggested, with the Python approach suggested as one alternative IIRC.  This is ultimately up to Walter however, and the method he feels would be most productive or beneficial to language development.  I can't claim to have any strong feelings here one way or the other.

> 2. We have two competing standard libraries; this is nowhere near good. Phobos is basically built on C wherever possible and sort of thrown together, and Tango reminds me of Java with a class for everything and then some. For the standard's sake (and consequent adoption), D needs one accepted standard library.

For what it's worth, Tango is only positioned as a "standard library" because it includes compiler runtime features (out of necessity), and because of its scope.  It was never intended to compete directly with Phobos.  To some, this distinction may be simply a matter of semantics, but I do feel it's important to point this out since it was never our intention to confuse things.  That said, if a choice truly had to be made between Phobos, Tango, etc, for a "D standard library" then that choice will be made by the community simply by virtue of whatever library each individual decides to use.  I don't know that an arbitrary decision would carry much weight here.

> The current state makes that difficult because
> Walter is forced to hand-manage both the compiler and library.

I think there is some benefit to Walter maintaining Phobos, as it allows new compiler releases to include library code demonstrating or supporting the use of new language features.  This is something that would be more difficult to achieve if the library work were handled by someone else.  That isn't to say that there are no alternatives to this, but it bears mentioning.

> What ought to
> happen IMO is that Walter should delegate day to day library management to a trusted associate who will occasionally inform Walter of the latest developments; Walter makes the final call, and life goes on.

There is also the issue of maintaining the compiler runtime code vs. the remainder of the library code.  Whatever happens at the user level, the compiler writer will want to maintain any runtime code that compiler requires.

> So to conclude, these are issues that have been sort of addressed at various times in other issues, but never to a point that accomplished the intended goal. The D community is growing; there are going to be a lot of new people that look at it now and say "Huh? Say again?" Maybe we ought to step back and forget the years we've had to become comfortable with D and analyze it from a potential user's point of view in order to make adoption easier.
> Thoughts? 

Only that D is still a young language and that I feel things will sort themselves out in time.  Until then, we can simply do our best to clearly answer any questions posed by new users and to avoid overt conflict in public discussions.  After all, the way we interact with one another reflects upon D as a whole, and if we can't make sense of what's going on then how is a new user supposed to? :-)


Sean

"Dan" <murpsoft@hotmail.com> wrote in message news:ev1ch5$t6u$1@digitalmars.com...
> Ameer Armaly Wrote:
>
>> 1. 1.0 doesn't appear to be any special sort of marker with regard to the
>> standard; we have not only CTFE but mixins added post-1.0, along with
>> numerous changes to the _standard_library. I understand the compiler can
>> be
>> made to strictly conform to the 1.0 spec,
>
> Exactly, so you can continue to develop for the 1.0 spec, and that code will work, to my understanding, as advertised.
>
>>but the fact still remains it
>> seems very ad hoc.
>
>> Then, the whole D language, including standard library, ought to be
>> frozen
>> for several years to let it proliferate throughout the technical
>> community;
>
> I totally disagree with this statement.  We have a frozen implementation of D 1.0, and a frozen spec for the language of D 1.0.  That can proliferate as much as people like.  I feel that as long as future 1.x compilers support 1.0 code, people can write 1.0 code and it will work universally on people's compilers.
>
Perhaps, but (1) the standard libraries aren't standard, and (2) it looks less intuitive to someone who takes a glance at the language for the first time.
>> an experimental compiler can of course undergo development, but clearly
>> marked as such and _separate_ from the stable compiler.
>> 2. We have two competing standard libraries; this is nowhere near good.
>
> I feel that this is perfectly fine.  People can develop a program using either library and I can compile it on my system.  10 libraries would be retarded, and very bad.  2 really isn't.
>
>> Phobos is basically built on C wherever possible and sort of thrown
>> together, and Tango reminds me of Java with a class for everything and
>> then
>> some. For the standard's sake (and consequent adoption), D needs one
>> accepted standard library.
>
> I disagree, in fact being able to plug in a library according to your programming philosophy will probably allow us to develop superior programs.
>
Maybe, but everyone here can testify to the cumbersome nature of plugging in any one library; it's not quite as easy as all that. Besides, look at C; it has one standard library but you could build anything you want on top of it. The idea is not so much that one implimentation be better, but that one be constant; many programs have to write standard C or posix functions because they aren't present on certain operating systems. Besides, if one program had to be compiled with one lib but everything else with another, you have to go through that whole process unnecessarily.
>> The current state makes that difficult because
>> Walter is forced to hand-manage both the compiler and library. What ought
>> to
>> happen IMO is that Walter should delegate day to day library management
>> to a
>> trusted associate who will occasionally inform Walter of the latest
>> developments; Walter makes the final call, and life goes on.
>
> My understanding is that Walter develops and maintains D and D language spec; and that he wrote the original Phobos.  I think someone else is maintaining Phobos under that system, while yet someone else is maintaining Tango and releasing without constant verification from Walter - and with Walter's occasional contributions.
>
>> So to conclude, these are issues that have been sort of addressed at
>> various
>> times in other issues, but never to a point that accomplished the
>> intended
>> goal. The D community is growing; there are going to be a lot of new
>> people
>> that look at it now and say "Huh? Say again?" Maybe we ought to step back
>> and forget the years we've had to become comfortable with D and analyze
>> it
>> from a potential user's point of view in order to make adoption easier.
>
> D is constantly being nitpicked on this forum - and the fact that it hasn't been feature frozen has allowed it to continue to be nitpicked and evolve into a better language.  I feel that the current process Walter is employing is almost even more important than the language itself; as clearly C++ and C stagnated leading for a need to replace those languages.
>
> Sincerely,
> Dan
> 

Although you raise some good points I can't agree here.  I think D still has a few more years development until we get to that stage.  People are only just starting to use it for real.  We should have the flexibility to fix their issues as they arise rather then setting it in stone at the moment.  I see 1.0 as kinda like a speedbump to stability.  The more we go over the more set in stone it'll get.  I think this will be a much more valid argument at 2.0 and even more so at 3.0.

-Joel

Ameer Armaly wrote:
> Hi all. There are a few things which have been bothering me as of late, and I want your opinions on them to know whether or not I'm jumping at shadows. For starters, we all have a common goal of making D as widely used as possible since we all love the language, otherwise we probably wouldn't be here. At the same time, there are a few factors which as I see it make the adoption of D much more difficult and need to be addressed if we intend to succeed:
> 1. 1.0 doesn't appear to be any special sort of marker with regard to the standard; we have not only CTFE but mixins added post-1.0, along with numerous changes to the _standard_library. I understand the compiler can be made to strictly conform to the 1.0 spec, but the fact still remains it seems very ad hoc. What ought to happen IMO is that we first call a review of the language spec where everyone sends in any complaints they have and they must be clearly addressed to everyone's satisfaction, or at least to the degree that's possible. Then, the spec ought to be frozen for a while, and we work strictly on the standard library, which I'll address later. Then, the whole D language, including standard library, ought to be frozen for several years to let it proliferate throughout the technical community; an experimental compiler can of course undergo development, but clearly marked as such and _separate_ from the stable compiler.
> 2. We have two competing standard libraries; this is nowhere near good. Phobos is basically built on C wherever possible and sort of thrown together, and Tango reminds me of Java with a class for everything and then some. For the standard's sake (and consequent adoption), D needs one accepted standard library. The current state makes that difficult because Walter is forced to hand-manage both the compiler and library. What ought to happen IMO is that Walter should delegate day to day library management to a trusted associate who will occasionally inform Walter of the latest developments; Walter makes the final call, and life goes on.
> So to conclude, these are issues that have been sort of addressed at various times in other issues, but never to a point that accomplished the intended goal. The D community is growing; there are going to be a lot of new people that look at it now and say "Huh? Say again?" Maybe we ought to step back and forget the years we've had to become comfortable with D and analyze it from a potential user's point of view in order to make adoption easier.
> Thoughts? 
> 
> 

Ameer Armaly wrote:

> 2. We have two competing standard libraries; this is nowhere near good. 

Yeah, I find that it's kinda funny that we have gone from:

int main(char[][] args)
{
    printf("hello world\n");
    return 0;
}

in the original D introduction and samples to the current:

version (Tango)
import tango.io.Console;
else // Phobos
import std.stdio;

void main()
{
    version (Tango)
    Cout ("Hello, World!").newline;
    else // Phobos
    writefln("Hello, World!");
}

And then there are all these new "D++" additions in progress
that I haven't quite understood yet. Like 4 languages in one :-)

--anders

Ameer Armaly wrote:
> Hi all. There are a few things which have been bothering me as of late, and I want your opinions on them to know whether or not I'm jumping at shadows. For starters, we all have a common goal of making D as widely used as possible since we all love the language, otherwise we probably wouldn't be here. At the same time, there are a few factors which as I see it make the adoption of D much more difficult and need to be addressed if we intend to succeed:
> [...]

I think one thing to keep in mind is that the 1.0 release was basically a gift to the user community to lend D that air of authenticity that business folks need to let their people use a new toy.  In reality, there are so many radical features being considered for D that it's really comparable to C++ in its CFront stage rather than the ARM, let alone, ANSI stage.  On the one hand, D needs users to push the language to expose its weaknesses.  On the other hand, D needs the flexibility to break some stuff to add compelling new features.  It's a tricky business bootstrapping a new language, and only people who can tolerate life on the bleeding edge survive in this kind of space.

D does indeed need a fair bit of time before it becomes sufficiently stable to consider something like standardization.  Even choosing a standard library would be premature, given that D has nothing like the STL yet, though something is planned.  And having a wealth of choices isn't a bad thing.  If functionality grossly overlapped, that would be one thing.  But by providing libraries with different design philosophies to appeal to different user segments, D can ease the transition for more programmers.  If anything, now is the time to think hard about what you think a language should have, and make a strong case for your favorite features.  There's no guarantee your feature will get implemented, but look how hard it is to get something added to a language as big and mature as C++...

Dave

"janderson" <askme@me.com> wrote in message news:ev1u1d$1q81$1@digitalmars.com...
> Although you raise some good points I can't agree here.  I think D still has a few more years development until we get to that stage.  People are only just starting to use it for real.  We should have the flexibility to fix their issues as they arise rather then setting it in stone at the moment.  I see 1.0 as kinda like a speedbump to stability.  The more we go over the more set in stone it'll get.  I think this will be a much more valid argument at 2.0 and even more so at 3.0.
>
It seems then that we interpret 1.0 in different ways; my first thought was that it was going to be a setup (language, compiler, libs) that people could just pick up and run with. But apparently not...
> -Joel
>
> Ameer Armaly wrote:
>> Hi all. There are a few things which have been bothering me as of late,
>> and I want your opinions on them to know whether or not I'm jumping at
>> shadows. For starters, we all have a common goal of making D as widely
>> used as possible since we all love the language, otherwise we probably
>> wouldn't be here. At the same time, there are a few factors which as I
>> see it make the adoption of D much more difficult and need to be
>> addressed if we intend to succeed:
>> 1. 1.0 doesn't appear to be any special sort of marker with regard to the
>> standard; we have not only CTFE but mixins added post-1.0, along with
>> numerous changes to the _standard_library. I understand the compiler can
>> be made to strictly conform to the 1.0 spec, but the fact still remains
>> it seems very ad hoc. What ought to happen IMO is that we first call a
>> review of the language spec where everyone sends in any complaints they
>> have and they must be clearly addressed to everyone's satisfaction, or at
>> least to the degree that's possible. Then, the spec ought to be frozen
>> for a while, and we work strictly on the standard library, which I'll
>> address later. Then, the whole D language, including standard library,
>> ought to be frozen for several years to let it proliferate throughout the
>> technical community; an experimental compiler can of course undergo
>> development, but clearly marked as such and _separate_ from the stable
>> compiler.
>> 2. We have two competing standard libraries; this is nowhere near good.
>> Phobos is basically built on C wherever possible and sort of thrown
>> together, and Tango reminds me of Java with a class for everything and
>> then some. For the standard's sake (and consequent adoption), D needs one
>> accepted standard library. The current state makes that difficult because
>> Walter is forced to hand-manage both the compiler and library. What ought
>> to happen IMO is that Walter should delegate day to day library
>> management to a trusted associate who will occasionally inform Walter of
>> the latest developments; Walter makes the final call, and life goes on.
>> So to conclude, these are issues that have been sort of addressed at
>> various times in other issues, but never to a point that accomplished the
>> intended goal. The D community is growing; there are going to be a lot of
>> new people that look at it now and say "Huh? Say again?" Maybe we ought
>> to step back and forget the years we've had to become comfortable with D
>> and analyze it from a potential user's point of view in order to make
>> adoption easier.
>> Thoughts?

"Anders F Björklund" <afb@algonet.se> wrote in message news:ev2ang$2i85$1@digitalmars.com...
> Ameer Armaly wrote:
>
>> 2. We have two competing standard libraries; this is nowhere near good.
>
> Yeah, I find that it's kinda funny that we have gone from:
>
> int main(char[][] args)
> {
>     printf("hello world\n");
>     return 0;
> }
>
> in the original D introduction and samples to the current:
>
> version (Tango)
> import tango.io.Console;
> else // Phobos
> import std.stdio;
>
> void main()
> {
>     version (Tango)
>     Cout ("Hello, World!").newline;
>     else // Phobos
>     writefln("Hello, World!");
> }
>
> And then there are all these new "D++" additions in progress that I haven't quite understood yet. Like 4 languages in one :-)
>
It's just not healthy for adoption's sake; if some big company comes along, falls in love with the language itself, then takes a look at the library situation I doubt they would be impressed.
> --anders

Ameer Armaly wrote:

> 
> "janderson" <askme@me.com> wrote in message news:ev1u1d$1q81$1@digitalmars.com...
>> Although you raise some good points I can't agree here.  I think D still
>> has a few more years development until we get to that stage.  People are
>> only just starting to use it for real.  We should have the flexibility to
>> fix their issues as they arise rather then setting it in stone at the
>> moment.  I see 1.0 as kinda like a speedbump to stability.  The more we
>> go
>> over the more set in stone it'll get.  I think this will be a much more
>> valid argument at 2.0 and even more so at 3.0.
>>
> It seems then that we interpret 1.0 in different ways; my first thought was that it was going to be a setup (language, compiler, libs) that people could just pick up and run with. But apparently not...

That would have been ideal, but if that really was the case, 1.0 was rushed out way too early :)

-- 
Lars Ivar Igesund
blog at http://larsivi.net
DSource, #d.tango & #D: larsivi
Dancing the Tango