The Great IDE vs Text Editor Debate
blog.bittersweetryan.com
blog.bittersweetryan.com
IDE's (as a notion) are better than editors, and everyone would agree to that if IDE's (as an implementation) weren't worse than editors.
I mean, if we could have an IDE with:
1) Fast, and I mean FAST, startup times and response.
2) No much visual clutter when you don't want it (unlike Eclipse/XCode/Idea/VS etc tons of toolbars and such)
3) A great editor pane, on the level of Vim/Emacs for editing code.
While retaining all other IDE features (debugging integrated, refactoring, intelligent auto completion, building system, REPL, etc)
then everybody would like it.
Except for the total barebones kind of guys, people don't have IDEs in that they hate an IDEs feature set. They hate IDE in that they hate current IDE implementation.
As proof, consider that people using Emacs/Vim/ST/TE also adds tons of plugins and settings and stuff to them to add them IDE like capabilities (project handling, tree views, debugging, AST-auto-completion, etc).
Text editors win over IDEs because outside of theory you never get an IDE like that, they are always slower, always full of clutter.
I've seen some people promote certain lightweight IDEs as being just as handy as text editors, but it's simply not true. Their startup time is simply measured in several seconds seconds rather than several minutes, but it's never instant like my text editor. They have a minimalistic interface, but it's usually a lot of stuff crammed into very small menus, nothing like the text editors where I can intuitively find everything (because the text editor doesn't overreach in functionality, it's just a text editor).
Nothing at all technically or theoretically prevents it.
>t's like saying that trucks are always better than cars, provided that the truck uses less gas, fits better into small spaces, and is easier to control.
Except those contrains only apply to physical objects such as cars.
With code, you can achieve all of the requirements I described. Not because there are no compromises to be made when programming -- but because none of those compromises comes into play in this situation.
You CAN have an IDE that opens fast.
You CAN have an IDE with a great editor pane (embedded Vim for example).
None of those are infeasible or necessary tradeoffs.
>I've seen some people promote certain lightweight IDEs as being just as handy as text editors, but it's simply not true. Their startup time is simply measured in several seconds seconds rather than several minutes, but it's never instant like my text editor. They have a minimalistic interface, but it's usually a lot of stuff crammed into very small menus, nothing like the text editors where I can intuitively find everything (because the text editor doesn't overreach in functionality, it's just a text editor).
None of those are necessary characteristics of an IDE. The fact that you say "usually" admits to that.
As an example: something like Sublime Text 3 can load in split seconds.
The basic things it lacks to be a full IDE (refactoring support, embedded debugger, etc) are things that can be loaded on demand, so if they were added to it, startup time wouldn't be affected at all.
And it could still have a minimalistic interface even with those. Why?
Because, for one, nothing necessitates all panes being open at all times. E.g When you run the debugger you can see the debugger toolbar -- when editing, you don't. Etc.
As for your "Their startup time is simply measured in several seconds seconds rather than several minutes, but it's never instant like my text editor".
1) As I said, something like ST3 opens instantly.
2) Even if it takes seconds, who cares? You open your editor once and you work.
It's not like you reopen it all the time. If you do open it, e.g because you want an editor for sysadmin, terminal work, sure, use something else.
To help implement these types of features the IDE embeds a version of the language inside of itself.
The problem with this is you then need a new IDE for each new language.
Because a good programmer's editor will try to be language neutral it does not have that luxury.
But as a bonus, because the editor is not carrying around all that extra language baggage the editor will always be faster than the IDE.
Well, it would be nice if we had some "IDE framework" to take care of all the barebones stuff (editor pane, basic UI, loading files, encoding, high level abstract support for highlighting, refactoring, embedding a terminal, etc) and people could hook it into their language to make an IDE for it.
And it would have to be written in C, to not usable from all languages with a C ABI/FFI, and not be dog slow like Eclipse.
I was describing a "toolkit" like approach, not an extensible base. Think of it as a "set of libraries" vs a "framework".
Emacs makes what I describe difficult. You cannot change the editor. You cannot add a different GUI on top. You have to do most of the extension work in elisp, etc.
I would prefer a set of libs a Ruby guy can hook up with Ruby and extend, a Python guy with Python, etc. Not a one-size-plus-extensions-fits-all.