I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".

I'll give as an example the features I found most useful in Eclipse for Java:
 - Refactoring.
 - Import rewriting: adding necessary imports and removing unnecessary automatically.
 - Semantic errors as you type.
 - Autocompletion.
 - Implement methods of interface/abstract class.
 - Type hierarchy.
 - Finding all the locations where a symbol is used.
 - Extract variable: selecting an expression and replacing it with a variable, and also adding a declaration for it.
 - Cast expression/argument to X.

But possibles answers for D could also be "Template instantiation debugging", "Mixin expansion", etc.

On Fri, 08 Feb 2008 04:02:11 +0300, Ary Borenszweig <ary@esperanto.org.ar> wrote:

> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".
>
> I'll give as an example the features I found most useful in Eclipse for Java:
>   - Refactoring.
>   - Import rewriting: adding necessary imports and removing unnecessary automatically.
>   - Semantic errors as you type.
>   - Autocompletion.
>   - Implement methods of interface/abstract class.
>   - Type hierarchy.
>   - Finding all the locations where a symbol is used.
>   - Extract variable: selecting an expression and replacing it with a variable, and also adding a declaration for it.
>   - Cast expression/argument to X.
>
> But possibles answers for D could also be "Template instantiation debugging", "Mixin expansion", etc.

I would like to add:
- Intention Actions ( http://www.jetbrains.com/idea/docs/help/editing/intentionactions.html )
- External build tool integration, like Ant for Java. (As you may guess, I'd vote for DSSS :) )

naryl wrote:
> I would like to add:
> - Intention Actions ( http://www.jetbrains.com/idea/docs/help/editing/intentionactions.html )

JDT has that, and it's a sort-of-planned feature for Descent. I don't usually use that feature for correcting mistakes, I actually use it to write a lot of my code. For example, if I need a new class I'll often just write the new declaration, toss a couple method calls there, and go back and use the quick-fix processor (as JDT calls it) to generate the class with the correct constructor & functions right there. If I'm assigning it to an interface, it'll even put the unimplemented methods there. Very handy!

Reply to Ary,

> I'm talking about features that already exist in IDEs for other
> languages, or features that don't exist at all. Suppose you are typing
> some D source file and stop thinking "Man, I would really like to
> do/know X".
> 
> I'll give as an example the features I found most useful in Eclipse
> for
> Java:
> - Refactoring.
> - Import rewriting: adding necessary imports and removing
> unnecessary
> automatically.
> - Semantic errors as you type.
> - Autocompletion.
> - Implement methods of interface/abstract class.
> - Type hierarchy.
> - Finding all the locations where a symbol is used.
> - Extract variable: selecting an expression and replacing it with a
> variable, and also adding a declaration for it.
> - Cast expression/argument to X.
> But possibles answers for D could also be "Template instantiation
> debugging", "Mixin expansion", etc.
> 
in the order I though of them:

Live "unittest": this would look like a table of values to call a function with and any time the function will compile (try every key stroke) the function is run and each output is reported. (the level of integration with the compiler this would demand would be intense) This would make one of the best things about using spreadsheets available in a real programming language.

selective import maintenance: if you try to use a new function it adds it to the import list (maybe after asking) or maybe even adding new imports.

Ary Borenszweig schrieb:
> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".
> 
> I'll give as an example the features I found most useful in Eclipse for Java:
>  - Refactoring.
>  - Import rewriting: adding necessary imports and removing unnecessary automatically.
>  - Semantic errors as you type.
>  - Autocompletion.
>  - Implement methods of interface/abstract class.
>  - Type hierarchy.
>  - Finding all the locations where a symbol is used.
>  - Extract variable: selecting an expression and replacing it with a variable, and also adding a declaration for it.
>  - Cast expression/argument to X.
> 
> But possibles answers for D could also be "Template instantiation debugging", "Mixin expansion", etc.

1-
Realtime Developer Collaboration without the need of CVS, SVN and the like. (requires RDBMS and async. communication support)
2-
The I in IDE ;)
Bjoern

Ary Borenszweig wrote:
> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".

- proper Vim integration
- Help in applying conventions, or even being able to define conventions on a per project base (module/package naming, type naming, general code style, etc.)
- Additional to the above point, possibility to define project templates and rules/conventions
- integration of one or more build tools (namely rebuild, dsss, make) and abstraction of config files of each (automatic generation for a project, too, of course but with the possibility to alter variables & co with the IDE itself, without having to edit the file(s))

What I'd like to see most in an IDE is userfriendliness. Especially the installation of the IDE. I just want to download the IDE, and install it with a few button clicks or a single console command. It should be able to do most of its features without the need to configure compiler paths, or what not. That's what I think is missing in the current IDE's for D.

----
On Fri, 08 Feb 2008 02:02:11 +0100, Ary Borenszweig <ary@esperanto.org.ar> wrote:

> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".
>
> I'll give as an example the features I found most useful in Eclipse for Java:
>   - Refactoring.
>   - Import rewriting: adding necessary imports and removing unnecessary automatically.
>   - Semantic errors as you type.
>   - Autocompletion.
>   - Implement methods of interface/abstract class.
>   - Type hierarchy.
>   - Finding all the locations where a symbol is used.
>   - Extract variable: selecting an expression and replacing it with a variable, and also adding a declaration for it.
>   - Cast expression/argument to X.
>
> But possibles answers for D could also be "Template instantiation debugging", "Mixin expansion", etc.

Ary Borenszweig wrote:

> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".
> 
> I'll give as an example the features I found most useful in Eclipse for
> Java:
>   - Refactoring.
>   - Import rewriting: adding necessary imports and removing unnecessary
> automatically.
>   - Semantic errors as you type.
>   - Autocompletion.
>   - Implement methods of interface/abstract class.
>   - Type hierarchy.
>   - Finding all the locations where a symbol is used.
>   - Extract variable: selecting an expression and replacing it with a
> variable, and also adding a declaration for it.
>   - Cast expression/argument to X.
> 
> But possibles answers for D could also be "Template instantiation debugging", "Mixin expansion", etc.

In addition to that list in no particular order:
° Code navigation similar to webbrowser where you follow code definitions
and uses go to definition etc). Most IDEs have that, but very few implement
a proper back button/shortcut, so that I can quickly look up a function
implementation and return to where I was before.
° Find all references: Given a symbol, it shows me all places where this
symbol is used.
° Method outline: A combobox that, when clicked, lists all method declared
in the current file and brings me there on selection.
° Symbol search: A dialog where I can search for symbols project wide.
° Automatic code formatting as I type, with the settings stored per project,
and not per user.

Speed. The IDE shall not slow down if the project has hundreds of source files or uses big libs/files. Editing shall always be smooth.

Frank Benoit pisze:
> Speed. The IDE shall not slow down if the project has hundreds of source files or uses big libs/files. Editing shall always be smooth.

You will have to translate Eclipse to D ;-)

BR
Marcin Kuszczak
(aarti_pl)