I just love D and use nothing else anymore - if i can help it. The gripe i have is:

http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D.learn&article_id=11858 (Need to fill and find about 5000 tags and it is a real problem for now.)

Other than that it is great. I am developing a dicom reader/displayer and the code is smaller and easier than anything i have seen and used before in c++ - and i hope to be able to share it soon.
Soon after i hope i will be able to share a dicom server.

What to do i dislike?

1.) i hoped for an easer egg - bug fixes for 2.xx (see http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D.learn&article_id=11858)  - macros and more
2.) i hope people will communicate more politely
3.) i wished somebody would port parts of tango to phobos - and phobos be the standard and only library, since i think it hurts D more (tango) than most people think

I am a beginner and  i enjoy D. I hope  - "The Safe Subset of D" will be done in a way, that no delays will occure in D 2.XXXX


lurker

sorry for my english

lurker wrote:
> I just love D and use nothing else anymore - if i can help it. 

I like this thread...griping is an easy trap to fall into.  Why do I use D?

* dynamic arrays
* delegates, particularly now that closures work (very cool!)

What do i like ?

* dynamic arrays, slicing
* cleaner OOP (no multiple class inheritance)
* syntax goodies : foreach,foreach-range,the array/struct-literals,auto,loop-labels,nested comments
* and i like the transitive const (D2.0) !!!
* delegates
* powerful and yet much more transparent template programming (meta porgramming in D in general)

What i dislike ?

* two standard libraries, i think this is a real problem (keeps new users away, people i talk about D with consider it too unmature if there is such a gap between the stdlib of the reference compiler and the community-generated lib, and they simply wont give it a try cause of much stuff missing in phobos)
* IDE - We really need full code-completion/suggestion/outlining/goto support and all these goodies to convince larger scale teams to switch to D (i know Descent is on a good way...)
* some already "ancient" compiler Bugs

Thank you Walter for the great effort and the wonderful language that you are dedicating to this thankful but always critical community!


~Stephan

Sometimes it's good to give Walter something to read that isn't complaints.  Could not be a bad thing if we all listed our reasons...

Reasons D is used by me:

1. String processing is easy, clean, and straight-forward (even with i18n, etc.) in similar ways to other languages I use.

2. When there are bugs in the compiler, I can find out why in many cases.  This just makes me happy, and allows me to submit a patch so I can hope it will be fixed.

3. The spec is quite clear (although not bug-free), which along with #2 has allowed me to work on tools for D (namely Visual Studio integration.)

4. With closures, associative arrays, "auto", and similar features I am able to (in cases) write code similar to how I would write JavaScript, PHP, and other languages I use which are not native.

5. I feel like I have (fairly limited but existing) some way to give feedback on the design of the language.

6. Emphasis on slicing and other features that are clearly better for performance, and just make sense anyway.


Reasons for which I might not use D:

1. Phobos has bugs/traps, Tango I haven't used as much but the style just isn't for me... tend to have to roll much of my own code (HTTP/XML processing, basic string handling, service/daemon hookup code, etc.)

2. It's fairly easy to link to other languages, but there are walls for sure... this can be a concern, since it's unreasonable for me to push D on developers who don't know the language (due to project/budget constraints.)

3. Haven't dealt with it too much yet, but I'm concerned const will be over-much red tape for some usage...

-[Unknown]


lurker wrote:
> I just love D and use nothing else anymore - if i can help it. The gripe i have is:
> 
> http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D.learn&article_id=11858
> (Need to fill and find about 5000 tags and it is a real problem for now.)
> 
> Other than that it is great. I am developing a dicom reader/displayer and the code is smaller and easier than anything i have seen and used before in c++ - and i hope to be able to share it soon.
> Soon after i hope i will be able to share a dicom server.
> 
> What to do i dislike?
> 
> 1.) i hoped for an easer egg - bug fixes for 2.xx (see http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D.learn&article_id=11858)  - macros and more
> 2.) i hope people will communicate more politely
> 3.) i wished somebody would port parts of tango to phobos - and phobos be the standard and only library, since i think it hurts D more (tango) than most people think
> 
> I am a beginner and  i enjoy D. I hope  - "The Safe Subset of D" will be done in a way, that no delays will occure in D 2.XXXX
> 
> 
> lurker
> 
> sorry for my english

Unknown W. Brackets wrote:
> Sometimes it's good to give Walter something to read that isn't complaints.  Could not be a bad thing if we all listed our reasons...
> 
> Reasons D is used by me:

Because I can safely troll at #D, unlike ##C++.
// Seriously, speed/control of C(++) with the ease of Python.


-- 
Tomasz Stachowiak
http://h3.team0xf.com/
h3/h3r3tic on #D freenode

I'll tell you what brings me to D.

I'm interested in business programming around event models in large throughput applications.  What better environment than one which has method references which retain their object scope, closures which retain their references (although that only works in DMD currently and I mostly use GDC, but I'm not missing it much just looking forward to it working), what seems to be solid garbage collection and nice, expressive programming at the system level...

The other interest I have, as it is the unfortunate reality of business applications that many vendor libraries which are required for integration just aren't meant for asynchronous applications (and for the sake of scaling across multiple processing channels), is multithreadded programming.  And when I first heard about const, I was excited.  When I then looked into just how complex this topic has become, I got weary.

Some phase of D is just what I want in a programming language.  That phase is somewhere in the middle of D 1.0 and D 2.0, where closures are added and there weren't so many types of const/invariant behaviors and syntaxes to figure out.  I like the idea of const, but I don't like the idea of the language becoming inanely complex for the sake of trying to solve a problem no other language is able to solve.

Personally, I think the immutability of a real const, read-only view, is ideal.  The ability to return read-only references to a data structure that isn't read only sounds like the compiler solving the never-ending problem I've faced in java of programmers being too sloppy to properly build immutable objects.

const fixes everything.  But what does invariant give me?  The way I see it, it's just a way to qualify literal values for most purposes!  And that I find unnecessary, because they may as well just implicitly be const.  And theoretically, if const is really a read only view, once you promote to const, you shouldn't be able to come back out of it. Honestly, I don't see the reason for everything else...it makes sense to qualify a method as "doesn't modify the object" so it can be accessible from a const reference to that object, but

I love the expressiveness that D has...and while I'm writing this, I'll take a second to plug my thoughts on array slicing.

array[..] should be synonymous with array[0..$]
array[5..] should be synonymous with array[5..$]/array[5..length]
array[..5] should be synonymous with array[0..5].

This makes the language a little more expressive, makes sense, and doesn't require $.

Cheers,
    Scott S. McCoy

On Fri, 2008-03-28 at 12:04 -0700, Russell Lewis wrote:

> lurker wrote:
> > I just love D and use nothing else anymore - if i can help it.
> 
> I like this thread...griping is an easy trap to fall into.  Why do I use D?
> 
> * dynamic arrays
> * delegates, particularly now that closures work (very cool!)

Extrawurst wrote:
> Thank you Walter for the great effort and the wonderful language that you are dedicating to this thankful but always critical community!

You're welcome!

(And I'm aware that if nobody's grumbling about X, then nobody's using X!)

Me too:

Top features of D:
- arrays, including associative arrays and all their goodies (slicing etc.)
- strings, unicode ftw
- GC AND pointers && friends PLUS C interop
- module system and object orientation
- delegates, including nested functions
- generic programming

D is such a rich language, supporting many styles of programming. Like in C++ the programmer has a lot of freedom and can make her own tradeoffs, like in python the language is really productive and enjoyable.

I'm also very fond of the care that has been given to practical needs: ddoc, function hijacking, even such simple things as disallowing 'for(int i = 0; i < 10; i++);', etc. etc.

And last but not least, although some harsh words have been said (this always happens though) I think D does have a mature and helpful community as well as design team, which inspires trust.

Ok, thanks everybody. </fanboy>

On Fri, 28 Mar 2008 22:02:42 +0100, Extrawurst wrote:

> What do i like ?
> 
> * dynamic arrays, slicing
> * cleaner OOP (no multiple class inheritance) * syntax goodies :
> foreach,foreach-range,the array/struct-literals,auto,loop-labels,nested
> comments * and i like the transitive const (D2.0) !!! * delegates
> * powerful and yet much more transparent template programming (meta
> porgramming in D in general)
> 
> What i dislike ?
> 
> * two standard libraries, i think this is a real problem (keeps new
> users away, people i talk about D with consider it too unmature if there
> is such a gap between the stdlib of the reference compiler and the
> community-generated lib, and they simply wont give it a try cause of
> much stuff missing in phobos)
> * IDE - We really need full code-completion/suggestion/outlining/goto
> support and all these goodies to convince larger scale teams to switch
> to D (i know Descent is on a good way...) * some already "ancient"
> compiler Bugs
> 
> Thank you Walter for the great effort and the wonderful language that you are dedicating to this thankful but always critical community!
> 
> 
> ~Stephan

This pretty much sums it up for me too.

I think D is fantastic, and I am close to being able to use it for project work in my day job. The team I work in is also keen - we are sick and tired of C++'s stupidities and ugliness. All that is holding us back is the standard litany of GUI, 64-bit, waiting just a bit longer for 2.x to mature and the Tango/Phobos split - and they won't hold us back much longer.

In preparation I have ported quite a bit of our library code and have had wonderful experience, ending up with about 1/3 as much code, and what is left is far easier to understand and easier on the eye.

Good to see a thread like this on the NG. Too much of the negative stuff - but
it's needed.

What do I like about D?

* Transitive const. I actually thought that const in other languages was
  transitive before Walter told us all it's not. (I never tested it, it just
  never occured to me that anyone would do something as illogical as
  non-transitive const :P)
* Array operations, slices, strings, as well as all the other stuff that has to
  do with this.
* Garbage collecting. Ok, so there are certain strings attached to using it,
  but you can turn it off.
* Code generation. Mixins, CTFE, templates - and so simple and logical.
* Easy linking to C. It's a must, and we know it.
* Compiles to native code.
* Multi-level language. It's assembler, C, Java and more.
* Inline assembler. Makes it easier for me to learn assembler, and having just
  one way to do it ensures that the next compiler I bump into will also compile
  my code. (at least such is the theory...)
* C++ without all the mucus, shamanic rituals, and eldritch incantations.


What do I not like about D?

* Enum. While I understand some people use keyword count as an indication of
  language worth, I heartily disagree. And enum is to me a list of elements
  related to each other, with no defined value except the name (unless you
  choose to assign them values, of course).
* Template/CTFE/Mixin error messages. Well, they're ok on their own, but I'd
  like to be able to tell the user 'this and that is wrong with your template
  instantion/CTFE function in file foo at line bar'.
* Old bugs. When something doesn't work, and the answer you get when you ask is
  "It's in bugzilla, been there since Adam and Eve walked the earth", it doesn't
  quite make me smile and dance and sing.


All in all, D is the language I want. It's not perfect (yet :P), but it's close
to what I want for most things.

Now, I think the only thing that remains is to say thank you. To Walter,
especially. But also to Andrei and the others who help, to the Tango team and
others who create important libraries for D, and to everyone on the newsgroup.
D wouldn't be what it is without you.

-- Simen