Which D IDE do you use?(survey)

[Idan Arye via Digitalmars-d]

On Friday, 10 April 2015 at 08:02:15 UTC, Szymon Gatner wrote:
> On Tuesday, 7 April 2015 at 22:58:44 UTC, weaselcat wrote:
>> Hi, I hope nobody minds but I'm just curious as to the 
>> popularity amongst D IDEs for a blog post. Sorry if I forgot 
>> your favorite $editor.
>>
>> http://goo.gl/forms/MmsuInzDL0
>>
>> thanks : )
>
> In my time Vim and Emacs were just fancy text editors, not 
> IDEs. Are they really IDEs now? Do they manage pojects? Do they 
> autocomplete? Do they build / deploy to device with one 
> keystroke? Do they support debugging (breakpoints / variable / 
> registers inspection)? Do they support refactoring?
>
> Please don't take it as an attack or trolling but if they don't 
> (and I am pretty sure they don't (maybe I am wrong about 
> autocoplete)) they they are not Integrated Development 
> Environments.

Powerful text editors like Vim and Emacs(and the more modern 
ones, like Sublime, Atom etc.) are IDEs in the same sense that 
UNIX is an IDE. They can't really do any of that IDE stuff 
themselves, but they can delegate it to external programs, and 
they can have plugins to make that go smoother.

I personally gone to great lengths to make Vim more IDE-like and 
work with it to develop D code:

> Do they manage pojects?

With plugins like NERD 
Tree(https://github.com/scrooloose/nerdtree) and 
ctrlp(https://github.com/kien/ctrlp.vim) I can treat the current 
working directory as the project, quickly navigating it's 
directory tree like in most IDEs and jumping to files.

> Do they autocomplete?

Vim comes with many general-purpose autocompletion options - 
words in opened files, tags, filenames, whole lines, static 
dictionaries based on the filetype etc.

Vim also allows to create a Vimscript function for 
autocompletions, which means that if there is some extrnal 
utility that provides autocompletion service for your language, 
you can delegate autocompletion to it. In D's case we have 
DCD(https://github.com/Hackerpilot/DCD), and 
Dutyl(https://github.com/idanarye/vim-dutyl) can get 
autocompletions from it.

> Do they build / deploy to device with one keystroke?

If you can do it via command line, you can create a keybind for 
running that command line. Since that command can be different 
between different projects - not to mention different programming 
languages! - I've created 
Integrake(https://github.com/idanarye/vim-integrake), which 
allows me to quickly create and manage small pieces of Ruby code 
I can use to build the project, deploy it to device, run it, 
pretty much everything. Since the command to run an Integrake 
task is always the same(assuming I name the task the same), I can 
easily create global key-binds for them do them with a single 
keystroke. Sure, when creating the project I need to write that 
command once - but that's an extremely low overhead that I only 
need to do when I create the project or when I want to change the 
build flags or stuff.

Actually, in my case it's two keystrokes - but that's a matter of 
personal preferences(first key stroke is the prefix, then I have 
the full ABC * modifier keys to map to the different tasks(and 
theoretically numbers and symbols - but I haven't reached the 
point I have so many tasks to map that I need to use those, and 
it's easier to remember that "b" = "build" and "d" = "deploy" 
than to guess what "1" means...)

> Do they support debugging (breakpoints / variable / registers 
> inspection)?

Since D can be debugged with GDB, I can use 
Vebugger(https://github.com/idanarye/vim-vebugger) to set 
breakpoints, inspect variables etc. It doesn't have a full 
feature-set yet(mainly because I'm too lazy to develop them...), 
but it will. Someday. Probably...

> Do they support refactoring?

Don't even need plugins for that(though there are many plugins 
that improve this aspect) - Vim's text manipulation features are 
second to none, and once you get used to modal editing and get 
your muscles to memorize the keymaps, you you refactor far more 
flexibly than what your IDE's developers decided to implement and 
put in the Edit->Refactor menu.