I disagree with a lot of VS UI ideas (all caps menus?) but VS still remains the gold standard for IDEs. C++ IntelliSense makes me immensely more productive in a very tough language to parse. And UI designers like WinForms are 100% more pleasant than laying things out in code.
OK, I'm a long time emacs guy and not the target market, but I'm genuinely curious about the IntelliSense claim. Really? Are there any screencasts or whatnot I can look at to see an expert developer demonstrating that they're "immensely more productive" than just typing the symbol names?
Honestly my experience is exactly the opposite: I watch windows people try to edit code and wince. Their hands are bouncing to the mouse and arrow keys constantly. They mash keys and wait for key repeat instead of deleting marked regions. They pop dialog boxes up to search for things and have to move them around the screen to see.
And yeah: sometimes they press some kind of button and get a big list of symbol names that they end up staring at for a while before picking one.
It all just seems like a mess to me, but I'm willing to be educated.
I find it to be useful as a discovery tool. I can type
String.
and then it'll present me with a list of methods and properties on String. And then, when I've typed String.Substring it'll tell me what the arguments are.
For stuff I use all the time it isn't so useful, but when I'm unsure it's a lot quicker than running off to read an extensive reference guide. (and type completion is a time-saver too - no need to type out full variable names)
This sums it well. Intellisense is a discovery tool, not a productivity tool once you have discovered. Intellisense helps you write code without having to StackOverflow all the time.
Your criticisms are correct, but when people say "Intellisense" they refer to more than just command completion. When you hit that "." or "->" or "<ctrl>+<space>" or whatever, you can see (and navigate with the keyboard):
- The full type signature of the function and its arguments (including generic/template parameters and constraints)
- Whether any of the arguments have default values and, if so, what they are
- Whether the last argument is a "params" or "..."
- The XMLDoc describing the function and every argument
- A scrollable list of every overload for that function name
Invoking Intellisense when not completing a function tells you:
- What code objects are available in your current scope
- What type of things those objects are (property, field, method, overloadable method in a subclass, ...)
- A list of snippets you could invoke from that point
All of this can be configured to show up automatically or only when invoked with specific key combinations. Also, the Visual Studio team has somehow made it so that all this stuff stays out of your way even when it comes up automagically. I've never seen any other IDE come close to being "always there yet unobtrusive". This includes Eclipse and they do it pretty well.
The biggest issue I have with your argument is that, while it's true that watching someone fumble around with their mouse while coding IS pretty painful, Intellisense is NOT the cause.
You didn't make this argument but I want to address it: I watch people who use vanilla Vim when they code (I can knock them because I tend to be one of them). What do they have on their other screen? A browser with some combination of google search tabs and Stackoverflow.com. What's on their terminal? One tab usually has a man (3) page up for shmemget() or something. A lot of what we're doing is looking up documentation for an API. I don't understand how this is somehow more "pure" than having that same documentation browsable in your editor and at your fingertips!
You're right; IDEs encourage lazy programming habits. But look again at that guy fumbling around with his mouse. Is he REALLY going to turn into a ninja command line wizard because you took his IDE away? Nope. He's going to continue to be mediocre no matter what tools you give him, because the underlying reason is deeper than the tools.
Nonsense. You know what's lazy? Working on a project with millions of lines of code and deciding that digging through it to find the routine you need is more work than just coding it again.
My conspiracy theory is that editors that allow you to enter code real fast encourage a personal not-invented-here syndrome. Coding it yourself is faster than looking up how to use someone else's code (be it code by a team member or an open-source library). If the only way to use a lib is to read bad reference docs on the internet, or, god forbid, the source, and you're on vim/emacs/sublime, then sure, hack it together yourself. It's faster, more fun, and all the trouble caused by code duplication and added complexity is for your successors anyway. Not your problem! This why all PHP, Ruby and Python programmers build their own HTTP request router at some point in their career (I sure did).
On the other side, editors that make it very easy for you to discover and navigate code will encourage you to use existing code. Typing `someObject.` and getting a precise, documented and navigable list of exactly what you can do with that object. That causes you to use that object the way it was intended. Maybe refactor one of its methods so that it's more flexible or general. You wouldn't refactor a method that you don't know existed, right? Direct, at-your-fingertips insight in the code you use, and the code you wrote last month, encourages appropriate use of said code.
(Sidenote: of course there's absolutely no reason why an IDE can't have great text-editing keybindings. I suspect that the only reason most fakevim plugins for IDEs are mediocre is because the user group is so small. After all, the average vim/emacs user looks down on IDEs)
> My conspiracy theory is that editors that allow you to enter code real fast encourage a personal not-invented-here syndrome.
If your "million lines of code" project isn't well documented or designed, then relying on an IDE to find pieces of code doesn't really help.
It is also my "conspiracy theory" that because IDEs are so good at hiding the junk under the carpet, developers become sloppy and stop carrying about things like modularization and API design, immersing themselves into sloppy code and factories of factories. E.g. no project should ever get to millions of lines of code, because no developer is able to keep it in one's head, which is why monolithic code bases are a mess. If you're not splitting your project in multiple modules/libraries, you're doing it wrong.
And such users can't see it, because they are developing in languages in which IDE usage was encouraged from the start (e.g. C#, Java), so libraries are naturally developed with IDEs in mind, being really hard and frustrating to use them without an IDE, creating a vicious circle. It is also my opinion that IDE "users" (because seriously folks, many of you are not the kind of people that can adapt their environment to their needs, therefore you are just users) have never tried to develop in Vim or Emacs in combination with a potent REPL, plus the Unix toolchain. Unfortunately for you particularly, you'd also have to change languages and immerse yourself in the Unix culture for that to be a pleasant experience. But seriously, try it sometimes, you might just like it.
Note that I'm currently using IntelliJ IDEA, from the same guys that are delivering ReSharper, the plugin that makes Visual Studio usable. IntelliJ IDEA is a really potent IDE. But many times I hate it and I can't wait to get back full-time on Emacs, unfortunately I have to use IntelliJ because I'm dealing with Java's ecosystem right now. Well, at least Java has Maven and SBT.
But seriously, this is almost entirely bullshit. I've used IDEs for a long time, and they just don't encourage the problems you're describing here. Bad developers do, and that's totally independent of your language or your editor. Maybe you don't have to work on million line projects but lots of people do, and maybe, just maybe, it's not their fault and maybe, just maybe, there are totally valid reasons that their projects are like that. It is my opinion that mere editor "users" (because seriously folks, many of you are the kind of people who can't get off your high horse) never understand that, and refuse to accept that perhaps other people might like different tools or work in different scenarios than they do.
And yes, I used Emacs for 8 years. You couldn't pay me enough to go back.
Good points. How about "IDEs can encourage lazy programming habits, but that's more an indictment of the programmer rather than his or her toolset."
I've personally moved to Vim because I found that I like it, but I still have all the plugins that turn it right back into an IDE of sorts. I try to resist looking down on IDE users... I used IDEs for a long time and suffered no ill effects (that I know of).
The fundamental concept of "browsing" (a.k.a. discovering something new, rather than navigating to something whose existence you know of a priori) seems to be completely lost on the 'nix folks.
IDEs like Visual Studio with Intellisense tell you your options when writing code. Text editors fundamentally do not have that capability. The end result is that you spend a lot of time looking through code manually ("the code is the documentation", etc.) figuring out the right arguments to call a function with and such, when in fact the editor could have just told you what you needed to know right in front of your face with zero effort on your part. That's lost productivity.
I use clojure inside emacs fulltime now, but in a former life I worked with and liked Visual Studio, and I even owned Visual C++ 1.0 back in the day.
Visual Studio keybindings (even its emacs keybindings, whether or not they existing in 2013) are indeed pretty bad in places - as you note, it sometimes makes a distinction between the text editor and the UI widgets, so you do find yourself leaving home position regularly to move up and down a list, instead of C-n/C-p. But a lot of the problem is just people not bothering to learn what's available.
The IntelliSense has better defaults than you get with most emacs modes, which is possibly why people notice a difference (i.e. in VS you don't have to _do_ anything, it auto suggests, and completes on punctuation, and always pops up a lot of nice info, all out of the box). But I'm not sure there's anything there you can't achieve in emacs, depending on your language - certainly in Java with flymake and the eclipse compiler you can do some good stuff.
The huge gulf, for me, is with refactoring. Visual Studio with Resharper is vastly, vastly more intelligent, powerful and reliable than anything you've likely cooked up in emacs, even with semantic mode etc. And I think this unlocks a lot of productivity - sometimes a problem isn't just text, it's deeply tied to the semantics of your code, and in VS (again, I'm assuming nobody uses it without Resharper) you can be performing refactorings at a pretty high level without skipping a beat. In emacs, not so much. The degree to which that happens in your code is the degree to which you'll notice and become bothered by it.
Again, this is for OO languages. I would certainly like more refactoring power than I have with clojure today, but nothing that's so far above and beyond just day-to-day paredit that I've bothered.
It depends on what language you program in. For C++ dev, I find both vi and emacs to be of no benefit. The Editor + Debugger + Source Navigation + Refactoring features provided by Visual Studio + Visual Assist plugin are unbeatable IMO.
vi/Emacs' strength is text manipulation. But in IRL most C++ developers (on any platform) are NOT typing in reams of C++ code non-stop. I will often pause to think, look up documentation/reference books, maybe take down some notes or work out a problem on a whiteboard, or debug/step through code, etc. In short the vast vast majority of my time is spent away from the editor. Honestly I don't see how a C++ developer can objectively claim any time-savings with emacs vs a full fledged IDE like VS. YMMV with other languages.
Apart from VS I have recently heard some very nice things about Qt-Creator, but I haven't used it personally.
It sounds like your experiences are seeing people who don't really know the tool and / or the framework. To someone who knows both, intellisense (especially adding in resharper) can be a huge productivity increase.
Snippets are pretty much available in every language, and they are a good start. The key thing about the tools VS (and resharper) add is that they understand the code, to a certain extent. So you're not merely doing text based processing of the code, but semantic processing at some level. Every year it gets better and better. As you come to understand what it is doing within that context, you can really use it to fly while coding, especially while doing things like refactoring.
I pondered this a few years ago with some colleagues but it never seemed possible to get off the ground: real programmers, who consider themselves fairly good, using best practices, working on real, meaty projects, videoing _everything_ and making it public. Actually being able to see in detail how this stuff unfolds would be great for me.
You can sometimes follow along with ludum dare etc but that's mostly stuff hacked together quickly. I'd absolutely love it if top open source coders showed up live streaming their work.
That sounds like more of a problem with the average VS/Windows dev than of intellisense.
Surely you use autocomplete or typeahead in emacs, right? It's just about saving time.
Intellisense isn't "I dunno what I want so I'll wander around." It's "I know exactly what I want and want to type as little as possible." VS also supports Emmet/ZenCoding, which is an extreme example.
I'm a vim guy, but it's wrong to look down on IDEs as pure crutches. They're just tools. In the end, expressive power is conferred more by paradigm and language than editor.
In this case, IntelliSense gives you visibility into available methods and their signatures right in the environment. When working in a larger codebase (LLVM in my case), it's very helpful to not have to look up documentation. Then there are tools like ReSharper which you can think of as "higher-order editing" tools that understand the semantics of the code and use it as a basis for manipulation, rather than simply modifying the textual representation of the code.
Vim is great at manipulating text, but not as good at understanding the code. IDEs are worse at manipulating, but a bit better at the latter. For most things, I reach for Vim. For bigger code bases, I'm pretty happy in an IDE, as long as it stays out of my way.
It's worth noting it's pretty easy to setup good IntelliSense-style behavior for emacs, too. I often try to press people who are fans of VS on why they think it's the best and I have yet to see anything that improves on a well-configured emacs with CEDET, magit, etc.
I think it's the "well-configured" part. While I love using vim, my .vimrc file and .vim folder have been crafted and maintained over years. I can't give those to beginners without explanation. VS needs no setup. Intellisense is free.
I'm not familiar with Emacs+CEDET+magit, but if it has these features, then basically yes - its Intellisense is as good as Visual Studio's:
-Method and property completion on framework and own methods
-Parameter hints on all methods
-Enum completion
In addition, VS has a solution-understanding which goes way beyond intellisense. For instance I cannot fathom how people are able to work without "Navigate to definition", "Find usages" or "Refactor > Rename" in any development environment.
I use at least the first two on the list regularly in emacs; I don't have enum completion setup in C++ code, but it may be available or easily addable with some CEDET hacking. The big caveat that configuration is onerous, depending on the target language. I doubt that emacs's IntelliSense-like packages are as good as VS's, certainly in terms of polish and packaging, but what it has is good enough.
Also nice is being able to immediately pop up the man page for the symbol under the cursor, as well as language-specific documentation (like the Hyperspec in CL), and the ease of extending it to do exactly what you want, and supporting new languages, can't be beaten.
I refuse to work in an environment without jump to definition/references. These things should be considered a bare minimum requirement for a programmer's editor.
I've found that you can make Emacs and Vim be just as fancy as Visual Studio when it comes to all this stuff (and when you combine semantic intellisense with plain-ol' fuzzy search, you arguably get even MORE value, because you can do things like "build up an intellisense" by repeatedly calling methods on a dynamic object).
BUT, it doesn't work out of the box. You have to set up the plugins right, you have to make sure all the tools respect your compiler and library paths, in some of these environments you have to manually rerun your "tags" program for the editor to pick up the updates.
My point is that, even though all this stuff is getting better, it's still pretty far away from "just load stuff into Visual Studio and chances are you'll get a bunch of fancy stuff".
As someone who uses both VS and IntelliJ IDEA regularly, the latter is superior. VS with ReSharper comes close, but raw VS has comedic support for refactoring when compared with IDEA.
In my experience, if you haven't tried IDEA, it's best not to claim VS's superiority. I mean, just look at the ReSharper page. All of those things are missing from VS for C# but not IntelliJ for Java.
Frankly, the two are simply not comparable.
Edit: Rereading, this seems combative. It isn't meant to be. Just try IntelliJ if you're working with Java. It's really good. I hope its features come to other IDEs as well.
