+972 52-548-6969
The ideal IDE
time to read 5 min | 858 words
We are discussing the ideal IDE on the Alt.Net mailing list, I thought that it would be interesting to gather all the requirements in one place.
I made some minimal attempt to reduce duplication, and to put the interesting parts, but check the discussion, it is still going on. This is not a list of "what is wrong with VS", it is a list of things that we want to see in an IDE (or not see in an IDE :-) ). IDE is defined as the place where I write code / debug /test.
Good quotes:
- I want to be a train speeding full steam and have this IDE laying track just in front of me until such time as I tell it I want to go a different direction.
- I just want a lightening fast intelligent editor that will let me choose to add on the features I care about. I don't want to have to deal with lag time.
- Give me something like TextMate for .NET. Build it on managed code. Make the AST model/API sensible and self-evident. Provide a user-centricity driven plugin model - no abstracterbation for programmers with technology fetishes. Plain, simple, self-evident. Extensibility and usability for the merest of mere mortals.
- So, do you really need Snippet Compiler with ReSharper editing features and debugger?
And now to the real stuff that was mentioned:
- Coding:
- Syntax highlighting
- Intellisense (I may think I am a jedi but true zen is to talk to the machine and have it put forth the words before you)
- Code Browsing
- Refactoring
- Treat Warnings as Errors as not negotiable (always enabled).
- i want it to be geared towards the keyboard developer.
- Text manipulation:
- Regex manipulation of the text.
- Debugger, good one.
- Edit and continue
- Testing integration
- Setting up all the required stuff, what is compiled, embedded, etc.
- Preferably it should read my build script and work on top of that.
- i want the build system to be pluggable
- i want a light project structure. If anything is going to be stored in a file it needs to be in a readable form and would preferable have a lightweight API that ships with it.
- Source control integration - nice, but not really a must have, I use tortoise for that.
- Some opinions said that SCM should not be in the IDE.
- Extensible
- Should be able to add a new language easily.
- Should offer me the AST of the code when I build a plugin.
- Make it have a light version, where you can unplug stuff you find unnecessary. ??
- So as far as an IDE is concerned I want to do everything from inside it like deployments
- Smarts:
- Error highlighting (errors, warnings, test failures, bad practices, ...)
- A Code Smell detection system (users could extend it with CQL)
- i want it to give me visual cues to interesting code constructs
- All existing R# features
- IDE support for effect analysis (Chapter 11 of Working Effectively with Lagacy Code).
- automatically correct these issues: flase > false, reslut = result, retrun = return
- User interface:
- Full screen ability
- Background compilation as you type (I hate waiting for VS to compile my solutions all the time).
- Code searching:
- A very fast way to get from the current function you are in to any caller or to any function the function is calling (and class definitions, ...)
- Ability to instantly search for a specific artifact (kind of like google / windows live search). As I type it in, I see the filtered results. This is NOT the find feature.
- Misc:
- The ability to have 2 people working in separate window panes on the same file (one person typing on the local keyboard/mouse, the other in a remote desktop); both visible in the same environment.
- IDE installation < 100Mb
- Shell integration would be nice. and available from the keyboard (think launchy)
- For windows PowerShell integration would be nice too.
- How about an IDE that doesn’t lock up when the source control is unavailable ;)
- better multiple monitor support.
- Configuration screens that don’t give me a headache
- Responsive:
- I am willing to pay for a quad core computer with 16 GB RAM, and use that for only programming. But it _must_ be responsive. (I used VS.Net on such a system, it crawled!)
- FAST FAST FAST
- Designers:
- i don't want any of the overhead of a designer.
- Designers that don’t break or no designers at all
- Built in (no separate window) reflector
- I should be able to CTRL+B from the method to the code or to the disassembled code.
- Release cycle:
- I want an IDE which is released early and often. And I want an IDE built by a team which is responsive to community feedback. The rest is just details.
- Multiple Releases a year, constant improvement.
Comments
perhaps a good project to show what the "ALT.NET" is all about
How about a project based on Visual Studio 8 Shell?
/i want it to be geared towards the keyboard developer/
I use ViEmu for just that reason. Awesome editing power.
.. . and then we suddenly wake up in the middle of the night...
;-)
... and a pony! ;)
You didn't mention HTML editing. As for the treat warnings as errors being non-negotiable. What about in the case of HTML warnings or ASPX designer warnings?
Phil
Haacked, can you check out the thread in the mailing list. This is about code, not HTML.
The warnings/errors from the HTML editors are more than useless
I'd love this, VS has been killing me lately. I basically can't compile inside it any more, im doing all my builds with nant, and testing inside the old nunit gui : )
I guess we should all get of our asses and start working on SharpDevelop
Unless JetBrains is listening???
I'm not familiar with the original mailing list and, perhaps, your blog isn't the right place to whine about VS, but --
I want every feature to be switchable on and off. You said VS is slow. I can't imagine it would be compiling my code while I type.
I would love to see XML comments gathered at the bottom of the file. Again this should be switchable. I, for one, hate viewing somebody else's code with XML comments decorating every silly member of a class.
I'm in the same boat as LukeB. ViEmu has made VS something that it never really was before... a real editor for the keyboard programmer.
Built-in support for known editor confgs suchs emacs and VIM into this fantasy editor would be awesome.
"Treat Warnings as Errors as not negotiable (always enabled)."
But that excludes certain types of reflection based approaches.
An example is using objects with private fields, only getter property methods and no assignment to the fields in the constructors or any other methods.
The compiler will note that the field is never assigned to and give you a warning - but NOT an error since it correctly realizes it can't rule out that the field will be written to by reflection. I would be horribly annoyed if I had to add dummy assignements all over the read-only objects and properties in my Domain Model just to make it compile when I know it will only be filled with values via reflection by the mapper.
/Mats
"Source control integration - nice, but not really a must have, I use tortoise for that."
How are you planning to deal with renames that preserve change history then? Esp. when using R#?
"Source control integration - nice, but not really a must have, I use tortoise for that."
How are you planning to deal with renames that preserve change history then? Esp. when using R#?
"Treat Warnings as Errors as not negotiable (always enabled)"
This doesn't sound like a good idea. In addition to the Reflection problems Mats outlined, it's going to wreak havoc with code-generation, since all of the sudden an external party's code follows a looser spec than your IDE (i.e. compiler) implements. This isn't going to be fixable without nasty hacks either. Further, it means that using foreign code in general is going to be more tedious; whether it works or not - mere correctness is no longer sufficient, you need to avoid all warnings too.
Frankly, I think the "Treat warnings as Errors" option should never have even been an option. One real, negative consequence of having it as an option is that people actually turn it on, and that means that useful C# features to support maintainability of old code (the enforced usage of "override" as opposed to "new" for overridden methods) become useless overhead. If you change a base class and someone has created a new method using that name, then he'll get a warning - which is going to break his code now. If his project is large, that might be a serious amount of work you're forcing him to do before he can even make a compile.
Worse yet, as years go by, not only does old code grow stale more quickly (by exacerbating the "override" problem"), but by treating warnings as errors, suddenly adding real, useful warnings to the compiler has become a breaking change! There's a number of FxCop features which I would greatly appreciate right in the compiler, but that's never going to happen because people use "treat warnings as errors".
The IDE should (at worst) have a non-negotiable nag-screen if you actually try to run/debug/test code with warnings, but it should still compile, and eventually work without any code changes. Heck, it's even OK if the UI shows the warning as if it were an error, but behind the screens, the compile must complete.
The rest of the ideas sound pretty good though!
@Andris,
Good point, and one of the reasons that I really like VisualSVN
Eamon,
I disagree, and I run my code with both warning as errors as with output XML.
This means that I get a compiler error if I have a public/ protected type or member without documentation.
There is a lot of value in ensuring the correctness of code, and I would like the compiler to help me, and breaking the build is a good way to do this.
I took upon myself to ensure that Castle Active Record compiled without warning. It has over 400(!) warnings, but since making the change, it has not been an issue at all.
ditto to Andris.
Filenames should share their name with the class definition/implementation which they hold. When refactoring, class names may change often. Renaming files becomes a common refactoring which should be reflected by the SCM.
I like .NET more than Java, but switching from Eclipse to Visual Studio hurt so bad. Oh it hurt.
Background threads. Please. I am amazed at how much of my time VS wastes while it is locked up performing some task. Start with background compiling, and background indexing of project files for lightning fast searches and refactoring.
Quick File Open - a la "Open Resource" in Eclipse. Having to click to open my project files instead of hitting ctrl-shift-r and typing a partial name -- that was sooo painful
Better refactoring
Pluggable Scripting / Macros - including Boo, PowerShell
Perspectives
Modular, so I can disable features that I don't need.
More open plugin licensing model. Is there still no support for Boo because of the lame licensing rules?
Maybe someone has already written support for these:
NAnt integration
Built-in Reflector support. Eclipse had a sweet java decompiler plugin where I could browse into ANY class and set breakpoints on it.
Also nice:
Identifying tasks and TODOs using
On the fly conversion from one CLR language to another. If SharpDevelop can do it, so can VS.
Customizable editors, including external editors, for certain file types.
Ability to open explorer to a project folder
Quick fixes - anyone know what I'm talking about? Eclipse QuickFixes are great productivity enhancers. For example, if the compiler figures out you are missing a cast in Eclipse, you can just hit Ctrl+1 which will show a list of possible fixes, then select "Cast", and it will generate the code for what it thinks you need to cast to, highlighting it so that you can easily manually override it. Oh man, editing code in Eclipse was such bliss.
Comment preview