It's just me sharing a positive experience.

TL;DR I have a strong (anecdotal) evidence that D is rapidly gaining popularity :)

I was well aware of D certain number of D enthusiasts from Russia,
but seeing one casually going by in the wild is another thing.

In brief I was half-sleeping in a train when a young guy
takes a seat next to me. He pulls out a laptop and powers it up.

Idly wondering what I'll see this time around (HTML/JS? Python/Ruby? MS Word, PowerPoint?) to my surprise I notice it boots Arch linux.

Cute... and then the guy starts X11 from the console... (dubious) with Xfce (+1 from me, though I'm with Cinnamon now).

The next thing he does: fire up a terminal and Geany.

Command line goes like:

cd Code/D

cd <some-project>

git pull

And then he's off furiously hacking on some GTK-based project written in D.
(I omit the details, though the repo is public)
Actually it's some kind of client-server file transfer utility, alpha quality it seems. I even checked the repo, seems like he's involved in some tiny software startup.

Bottom line for me this kind of thing beats TIOBE index any day of the week :)

-- 
Dmitry Olshansky

On Wednesday, 20 February 2013 at 17:48:29 UTC, Dmitry Olshansky wrote:
> It's just me sharing a positive experience.
>
> TL;DR I have a strong (anecdotal) evidence that D is rapidly gaining popularity :)
>
[..]

I've noticed what looks like a large increase in the postings in D learn, which to me indicates a sudden increase in the people who are checking D out.

--rt

Cool I will try not to sleep when I catch a train next time. :-)

On Wednesday, 20 February 2013 at 17:52:46 UTC, Rob T wrote:
> On Wednesday, 20 February 2013 at 17:48:29 UTC, Dmitry Olshansky wrote:
>> It's just me sharing a positive experience.
>>
>> TL;DR I have a strong (anecdotal) evidence that D is rapidly gaining popularity :)
>>
> [..]
>
> I've noticed what looks like a large increase in the postings in D learn, which to me indicates a sudden increase in the people who are checking D out.
>
> --rt

I would say in late 2011 - early 2012 I hit more than usual talks about D in russian segment of the web, maybe it was growing that time.

But D has been loosing position in Tiobe index for a year. And two other measures which I know: http://langpop.com/ and http://lang-index.sourceforge.net/ also do not give much preference to it.

On Wednesday, 20 February 2013 at 18:03:50 UTC, Maxim Fomin wrote:
> I would say in late 2011 - early 2012 I hit more than usual talks about D in russian segment of the web, maybe it was growing that time.
>
> But D has been loosing position in Tiobe index for a year. And two other measures which I know: http://langpop.com/ and http://lang-index.sourceforge.net/ also do not give much preference to it.

When I fist investigated D about a year ago, I noticed that Google searches brought up more D1/Tango stuff than D2 stuff, and there seemed to be a ton of former D1/Tango activity that suddenly stopped when D2/Phobos came out. I also noted the same indexes that showed D was relatively noticeable on the charts, but then dropped almost out of sight.

It was clear to me that a fight had happened and there was a split and many people had suddenly abandoned D causing the rapid drop off the charts.

What may be underway is a resurgence around D2, so what we need to do is not repeat past mistakes, and do a ton of boring stuff like stabilize D2/Phobos before moving on to D3, install better processes for documentation and developing the language specifications, and of course continue to improve the release process (it still needs a real beta and stable release), etc.

--rt

Rob T:

> and do a ton of boring stuff like stabilize D2/Phobos before moving on to D3, install better processes for documentation and developing the language specifications, and of course continue to improve the release process (it still needs a real beta and stable release), etc.

"Stabilize" is the wrong word to use. Implementing the 64 compiler is good, implementing shared libraries is good, porting D runtime/Phobos to RISC CPUs is good, replacing the GC is good, improving the floating point management by DMD is good, and so on and on.

But in my opinion what's more needed now is instead to try to complete as much as possible the design and implementation of the missing/broken/incomplete parts of the core language (like finishing const/immutable design, finishing the implementation of pure, redesigning properties, fixing @trusted, doing what's possible with shared, doing what's possible to finish the inference of tags like pure in templated functions, finishing the design of packages, finishing the implementation of the module system, finishing the design of operator overloading, and so on. The complete list of broken/unfinished parts scares me).

Bye,
bearophile

On Wed, Feb 20, 2013 at 07:42:41PM +0100, bearophile wrote: [...]
> But in my opinion what's more needed now is instead to try to complete as much as possible the design and implementation of the missing/broken/incomplete parts of the core language (like finishing const/immutable design, finishing the implementation of pure, redesigning properties, fixing @trusted, doing what's possible with shared, doing what's possible to finish the inference of tags like pure in templated functions, finishing the design of packages, finishing the implementation of the module system, finishing the design of operator overloading, and so on. The complete list of broken/unfinished parts scares me).
[...]

Yeah, D already has enough features, but their interactions with each other still haven't been ironed out completely. The C/C++ inherited part of the language seems stable enough, barring a bug or two here and there. I've been writing small programs in D that I used to write in C/C++, and it's quite a pleasant experience.

But once I get into the realm of new features introduced in D, like generic metaprogramming, functional-style code, non-trivial range APIs, const-correctness, purity, etc., I just keep running into bugs, unexpected interactions, conflicting designs, etc.. It can be quite frustrating at times. No doubt, a lot of stuff *does* work, but bugs / design issues are also quite frequent, which detracts a lot from one's experience of D.

Sometimes I wonder if we're over-stretching ourselves with the amount of clever features in D, as Kernighan once said:

	Debugging is twice as hard as writing the code in the first
	place. Therefore, if you write the code as cleverly as possible,
	you are, by definition, not smart enough to debug it. -- Brian
	W. Kernighan

Maybe D already has enough innovations, and now is the time to revisit what is already there and polish it up into the refined product that it should be.


T

-- 
Valentine's Day: an occasion for florists to reach into the wallets of nominal lovers in dire need of being reminded to profess their hypothetical love for their long-forgotten.

On Wed, Feb 20, 2013 at 09:48:25PM +0400, Dmitry Olshansky wrote: [...]
> In brief I was half-sleeping in a train when a young guy
> takes a seat next to me. He pulls out a laptop and powers it up.
> 
> Idly wondering what I'll see this time around (HTML/JS? Python/Ruby? MS Word, PowerPoint?) to my surprise I notice it boots Arch linux.
> 
> Cute... and then the guy starts X11 from the console... (dubious)
> with Xfce (+1 from me, though I'm with Cinnamon now).
> 
> The next thing he does: fire up a terminal and Geany.
> 
> Command line goes like:
> 
> cd Code/D
> 
> cd <some-project>
> 
> git pull
> 
> And then he's off furiously hacking on some GTK-based project written in D.  (I omit the details, though the repo is public) Actually it's some kind of client-server file transfer utility, alpha quality it seems. I even checked the repo, seems like he's involved in some tiny software startup.
> 
> Bottom line for me this kind of thing beats TIOBE index any day of the week :)
[...]

Wait, wait, so you're saying, this random guy sitting next to you is, of all things, coding in D, and you didn't even have a conversation with him?!


T

-- 
Без труда не выловишь и рыбку из пруда.

On Thu, Feb 21, 2013 at 12:27 AM, H. S. Teoh <hsteoh@quickfur.ath.cx> wrote:
> But once I get into the realm of new features introduced in D, like generic metaprogramming, functional-style code, non-trivial range APIs, const-correctness, purity, etc., I just keep running into bugs, unexpected interactions, conflicting designs, etc.. It can be quite frustrating at times. No doubt, a lot of stuff *does* work, but bugs / design issues are also quite frequent, which detracts a lot from one's experience of D.
>
> Sometimes I wonder if we're over-stretching ourselves with the amount of clever features in D, as Kernighan once said:
>
>         Debugging is twice as hard as writing the code in the first
>         place. Therefore, if you write the code as cleverly as possible,
>         you are, by definition, not smart enough to debug it. -- Brian
>         W. Kernighan
>
> Maybe D already has enough innovations, and now is the time to revisit what is already there and polish it up into the refined product that it should be.

On that measure, the present state of D is goof. When I try something clever in metaprogramming for example, I generally hit a wall. Then I think again and usually I get a much simpler way and the D compiler too is happy with that.

In a way the buggy facet of D compiler is helping me :-)

On Wednesday, 20 February 2013 at 18:42:42 UTC, bearophile wrote:
> Rob T:
>
>> and do a ton of boring stuff like stabilize D2/Phobos before moving on to D3, install better processes for documentation and developing the language specifications, and of course continue to improve the release process (it still needs a real beta and stable release), etc.
>
> "Stabilize" is the wrong word to use. Implementing the 64 compiler is good, implementing shared libraries is good, porting D runtime/Phobos to RISC CPUs is good, replacing the GC is good, improving the floating point management by DMD is good, and so on and on.
>
> But in my opinion what's more needed now is instead to try to complete as much as possible the design and implementation of the missing/broken/incomplete parts of the core language (like finishing const/immutable design, finishing the implementation of pure, redesigning properties, fixing @trusted, doing what's possible with shared, doing what's possible to finish the inference of tags like pure in templated functions, finishing the design of packages, finishing the implementation of the module system, finishing the design of operator overloading, and so on. The complete list of broken/unfinished parts scares me).
>
> Bye,
> bearophile

Yes your additions is included in what I meant by "stabilize". We need to freeze the addition of new features for the "stable release of the language" (we currently do not have a stable release that is documented) and put it through the acid test of real world use so it can be polished up based on the feedback.

It may be a good idea to create a team that concentrates only on releasing a stable version of the language and polishing it up, otherwise it will never get done. We cannot polish up an undefined moving target, it's as simple as that.

--rt