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
