In article <d04p7a$550$1@digitaldaemon.com>, Walter says...
>

>
>I've found myself wondering over the last few months what "1.0" actually is.

Having formally participated in the design of Java and Flash ActionScript, I can say that the biggest non-commercial part of the definition of "what 1.0 actually is" was cutting off your ability to ever change your mind about some things. Freezing your mistakes. After 1.0, you are still able to add things, but you can't really remove anything, and the things you add have to be squeezed into the spaces not already occupied by something you can't remove. Having to squeeze new, better ideas into cracks between old, worse ideas makes a language into, well, C++ or Perl 5.

>Since D will undergo continuous improvement regardless, why don't we just drive a stake in the ground and call what we have "1.0"?

Yes, many things will still be changeable, but many will not. The "stake in the ground" is a stake thru the heart of anybody who still fervently hopes to pursuade you to change certain things before it's too late. Even though it is true that D will undergo continuous improvement, you will never again be completely free to "do things right" after 1.0 ships.

I don't think it's possible to avoid that outcome entirely (except by never shipping, which would be a tragedy), but I think there are ways to minimize it. When your first priority is to deliver revenue numbers to Wall St. this quarter, or crush Microsoft, or surprise your competitors by unveiling your stealth project, your options are limited.

But if you have the luxury of making the best possible language design your first priority, do whatever you can to get the world to help before committing to 1.0.

No matter how smart you are, the world collectively is smarter. It's also self-contradictory, overwhelming, and chaotic, so taking advantage of that extra smartness isn't trivial, but I think it's a tremendously valuable resource. You've already been engaging the world to some extent via this forum, but maybe one last push would be useful.

Before making the 1.0 committment, you might consider getting some docs together that describe the *goals* for the language (what you're trying to optimize for), and why you believe the existing design decisions to be better than their major alternatives at meeting those goals. Just the process of writing such a thing, as a pursuasive document, not as a declaration of fact, might be useful to you.

Then get the word out (Slashdot, etc.) that you'd like people to read these design arguments, think about them, try writing some code, and then respond with their highest priority requests for any changes.

Then instead of defending your previous decisions, as is a natural temptation, and doing battle with the change suggestions, try to relax and see what emerges. Try to imagine that nothing had been decided (or implemented!) yet, that there was no existing design to defend, and you were free to let a design "emerge" naturally from the data.

This emergence isn't a majority vote, just a sense of what the mass of users were thinking that you could adapt to without legacy constraints on your decision making.

I think the existing design is so close to optimal for what you are optimizing for that the fundamental design of D will be overwhelmingly endorsed. Also, since the existing design would form the basis for discussion, what I think would emerge would simply be minor modifications. People's highest priority change requests would be in the details, I believe.

I really think that if you could relax your commitment to the existing details and dispassionately observe what emerges and implement that, it would be better than what you have now, though I don't know how. (Sort of a stochastic optimization algorithm that isn't best for each individual but is best overall.) I also think it would be so close to what you have that the changes would be relatively minor, though if what emerged did imply a need for big changes, you'd want to know that before 1.0 since it would eventually become obvious later, and later might be too late.

> I think D 1.0 is the day you are ready to make D public and face scrutinization from all those c++ programmers,

I wonder how much "affection and fondness" C++ programmers have for it.

<alert comment="war stories from older newbie">

I started using C in the early 80's and thought it was pretty primitive and "dangerous". I actually kind of liked Ada for the rigor it imposed ... if you had a dedicated VAX for compiles and/or worked late at night.

I was on a project about '87 that used the AT&T C++ 1.2 CppFront and thought the concept was brilliant. Single inheritance, no templates/generics, no STL. no exceptions. When the native compilers from Borland and others came out, I was one happy techie. (I think this is about the time frame that The WB started being noticed ... could be wrong)

But I never cared for C++ 2.0. Just an ugly 'pug' of a language. Yuck.

The "gotchas" of C were traded for the obscurity and "what in the world is going on" of C++ 2.0. I try not to use the capabilities of C++ that go much beyond 1.2. I recall admiring how Ada did exceptions and templates, but the C++ approach seemed deeply flawed and just unreadibly ugly.

The C++ world seems tremendously interested in using the template/generic capability to write "Game Of Life" code. That's bizarre.

</alert>

I know when I first started out D, I was wondering why all my classes would seg fault :-/ (it was because i never 'newed' it).

Is there a way for the compiler to give a better error (run time error message) instead of 'segmentation fault'. Maybe something like, 'filename-line# cannot access null class'

sai wrote:
> I am a graduate student of Mechanical engineering, I wanted to use D in doing
> high performance dynamic optimization and for implementing real time simulators
> for feedback controllers (Matlab is > 1000 times slower than real time!).
> 
> After learning Java and C# (and Matlab of course) I hate touching C or C++
> But D came to me as a very pleasant surprise; it was love at first sight.
> 
> Anyway, I am not very good at using debuggers or even understand the source
> of D front end etc. My programs in D crashed too often due to bugs in my code.
> I wish, I could get a 'D' IDE with built in debugger, that works on windows.
> I wish, phobos be as extensive as java api, with at least one standard GUI api.
> 
> I know, I may sound funny or silly for other expert programmers, but atleast for
> me, the current state of D is not readily usable. 
> 
> Anyway, I am not blaming anyone, its just, you know .... a little disappointment
> that the language you love does not have all the things you wanted. 
> 
> I know, it will take time, and for now, I have to be content with some other
> language. 
> 
> Anyway, I really enjoyed whatever coding I did in D. 
> 
> 
>>>The questin is, what are you guys waiting for?
>>
> 
> Well, I am waiting for a complete language, like array literal expressions,
> mixins, etc etc. extensive API with at least one GUI, with DTL distributed along
> with D compiler. Well again, I know, it will take time ..... D 1.0 .... D 2.0
> ...
> 
> I understand, Digitalmars is no Microsoft or no Sun. I guess I have to check
> back after a long vacation from this ng.
> 
> Best Wishes and Mighty kudos for Walter and all others involved
> sai
> 
> 

> Is D useable for serious development now? Yes.
>
It really depends on what serious development means, if you are referring to commercial development I will surely say not yet. Once we see tools that can help in development e.g. IDE's with integrated debuggers it will be getting somewhere.

I use D for pet projects and even for prototyping sometimes, but some people I work with will not even look at it until some tools are available for it.

Zz

Ben Hinkle wrote:
> "Jason Mills" <jmills@cs.mun.ca> wrote in message news:d04ccv$2nh7$1@digitaldaemon.com...
> 
>>I have been reading this newsgroup for several years. Although I post rarely I do read it every day. Early on I was so enthusiastic about D I could barely contain myself. I could not wait to use D at work, replacing C++ and Java. I'm still patiently waiting for that day. With C++/CLI soon a reality, improvements to C++ coming, together with existing versions of C# and Java, all with huge libraries ready to use out of the box, will D every be able to compete?
>>
>>Jason
> 
> 
> Not to single you out, but the best way to help D compete is to get invovled. I'm talkin' to all of you out there sittin' on the fence - yeah you know who you are! :-) If everyone waits for D to arrive it will never arrive (deep, eh?).

I would love too to get involved. But I'm afraid I have no free time. Working full time, working on my masters, and family life take all my time. That said, I will soon be finished my masters. Then I should be able to contribute something beyond d.vim.

> The day dmd-1.0.zip comes out it will be a nice time to reflect a little and start planning for what to do next, but practically speaking it will a lot like dmd-0.nnn.zip. I don't think there was a day that C++ suddenly arrived. It just grew and grew. Java and C# have huge marketing machines behind them so they try to trumpet milestones as changing the world - but mostly the world changes very slowly. Hence the importance of all the libraries/tools/community surrounding what Walter does.

clayasaurus wrote:
> I know when I first started out D, I was wondering why all my classes would seg fault :-/ (it was because i never 'newed' it).

I totally agree.  I still get bitten by segfaults.  I start taking the C  approach to finding them, by rolling up my sleaves and looking for possible null pointer references, etc.  I never find the obvious null pointer - because it isn't there :)  And I'm so used to C/C++ that when I see object.foo() (instead of object->foo()) I think "that can't be the problem, it's not a pointer"
So, please please can we have a message other than segfault for objects that haven't been instantiated?

Brad

Derek Parnell wrote:
> On Wed, 02 Mar 2005 09:11:11 -0330, Jason Mills wrote:
> 
> 
>>I have been reading this newsgroup for several years. Although I post rarely I do read it every day. Early on I was so enthusiastic about D I could barely contain myself. I could not wait to use D at work, replacing C++ and Java. I'm still patiently waiting for that day. With C++/CLI soon a reality, improvements to C++ coming, together with existing versions of C# and Java, all with huge libraries ready to use out of the box, will D every be able to compete?
>>
>>Jason
> 
> By the phrase "be ready", do you mean "be finished"? If so, then I doubt
> whether it will ever be really finished. But if you are asking will it ever
> be in a state in which we can use it, then I guess it is vert nearly there
> now. And over then next year or two, it will only get better (most cost
> effective) to use. Currently, it will take a bit of work on your part to
> make things happen, but better libraries and better code generation, and
> hopefully better syntax, are still to come.

I guess what I mean by "ready" is "when can I ditch Java and C++ and use D at work?". See my other post.

> Even though there are some bugs still in the current DMD implementation, I
> haven't seen too many in which incorrect object code is being created.
> 
> So I suggest you start using D with a purpose, if only to get some practice
> in how to think in D. Also, try to find a library project, or some other
> way in which you can personally contribute to the future of D.
> 

"Lynn Allan" <l_d_allan@adelphia.net> wrote in message news:d05fb0$109c$1@digitaldaemon.com...
> The "gotchas" of C were traded for the obscurity and "what in the world is going on" of C++ 2.0. I try not to use the capabilities of C++ that go much beyond 1.2. I recall admiring how Ada did exceptions and templates, but the C++ approach seemed deeply flawed and just unreadibly ugly.

C++'s groundbreaking ideas w.r.t. generic programming are, in a word, brilliant. But I, too, find the expression of those ideas in the C++ syntax to be so flawed as to be well nigh unusable. The use of < > in particular. My brain simply refuses to parse them as if they were brackets. But that by itself might be passable, but the nail in the coffin was then overloading << and >>, and then making the classes that overloaded them templates themselves using < and > !! It has all the visual appeal of gibberish.

I aimed to fix that in D. I love templates and generic programming, but it's got to look right.

> The C++ world seems tremendously interested in using the template/generic capability to write "Game Of Life" code. That's bizarre.

It's good that there are people who push the limits like that, it's the way progress is made. Some of that stuff is so 'out there' is it really even C++ anymore? Is C++ just the 'machine code' of a new language layered on top of it?

> I've found myself wondering over the
> last few months what "1.0" actually is.

Simple, and I'll be glad to help <g>

1. Examine my pet project
2. Identify what would be most useful to support it
3. "Make it so"
4. Call it version = 1.0

Take a couple of days off.

1'. Anticipate what would be most useful for my pet project in the
future
2'. Call that ++version
3'. "Make it so."
4'. GoTo step 1'

If you hold up your end of the above, I will commit to telling everyone I know about how wonderful 'D' is. Fair?

Zz wrote:
>>Is D useable for serious development now? Yes.
>>
> 
> It really depends on what serious development means, if you are referring to
> commercial development I will surely say not yet. Once we see tools that can
> help in development e.g. IDE's with integrated debuggers it will be getting
> somewhere.
> 
> I use D for pet projects and even for prototyping sometimes, but some people
> I work with will not even look at it until some tools are available for it.
> 
> Zz

Exactly!