Mindset of the D team vs the Rust team

[Bruno Medeiros via Digitalmars-d]

On 24/03/2016 17:50, Andrei Alexandrescu wrote:
> On 03/24/2016 12:50 PM, Bruno Medeiros wrote:
>> And this is one of the reasons why I've essentially moved from D to
>> Rust.
>
> It would be interesting to share a few thoughts about your experience
> with Rust if you have the time. Thanks! -- Andrei
>
>

If you're looking for an experience of someone who moved to writing a 
significant code base in Rust, that's not me. The most Rust code I've 
written so far is just this https://github.com/RustDT/Rainicorn - about 
1-2 man-weeks of effort. and I don't even consider myself proficient in 
Rust yet. (it's damn complicated to master!)

What I meant with my comment above is that I've moved my *time and 
effort investment* from D to Rust, but that doesn't mean the investment 
was writing D or Rust code directly. Rather it has more to do with 
projects like DDT (https://github.com/DDT-IDE/DDT), a project I've 
worked on and off since 2008, but fairly intensively in the last 4-5 few 
years. The DDT IDE has its own D parser and semantic engine (for code 
completion, find definition, etc.), that I built from scratch, and have 
been improving throughout these years. About a year ago or so, I was on 
the verge of massive improvements in this engine.

On one hand it would begin to support template instantiation (not 
perfectly, but enough to support code completion well enough in the 
majority of cases). Most of the groundwork necessary to have this 
analysis work in a lazy and incremental way - such that it would perform 
well under the interactive nature of an editor - was done already.

Another thing nearly completed was refactoring the engine out of Eclipse 
itself, so that it could be run externally, as a daemon process. In a 
way quite similar to DCD, Go oracle, RLS, etc. The groundwork for all 
this was done (also implementing caching, etc.). I think this would have 
been quite interesting because with the template improvements above, the 
DDT engine would have been fairly more advanced than DCD currently, and 
be available to other D IDEs/editors (especially since Eclipse is not 
that popular nowadays, and I'm the first admit, fairly so - Eclipse 
sucks in certain regards)

I was already a bit worried 2-3 years ago when Go came into the scene. 
It would definitely take a bit of mind-share out of D, but like you 
said, Go is not really a competitor to D, so it wasn't that significant...

But then queue Rust coming in to the scene, and essentially I rapidly 
lost my motivation to work in D-specific tools once I looked more into 
Rust.

DDT will still be maintained, but only because I've refactored the 
IDE-generic code into a language-agnostic framework, and built 
https://github.com/RustDT/RustDT and 
https://github.com/GoClipse/goclipse with it. But I won't be working on 
the DDT semantic engine anymore, as far as things stand.

-- 
Bruno Medeiros
https://twitter.com/brunodomedeiros