[jules]

It's not so much about typing less as it is about interactively learning to use an API or codebase. Suppose you have a comment object and you want to get the body text of that comment. With autocompletion you can just type `comment.` and you'll immediately see whether it's called "body" or "text" or something else, instead of having to browse around the codebase (which incidentally is also easier in an IDE that understands your code, because you can put your cursor on the class name and press a "go to definition" key instead of having to find it manually).

Another invaluable feature related to this is documentation as you type. I can never remember the order of the arguments to the fold function. Fortunately Visual Studio helps out: https://dl.dropbox.com/u/388822/intellisense.gif (somehow my mouse pointer shows up in white, which makes it hard to see, but if you hover over the variables you get type information & documentation).

[rapind]

To me what you're describing are imagined problems. They aren't real problems for someone who eschews autocompletion tools. No offence intended.

I would argue that the autocompletion training wheels for learning a new API are really only useful if you're rarely going to use that API again. If you're going to be using it a lot, there's actual value in spending the extra effort to learn it's functions. It'll stick more. Unless you have a photographic memory your brain will tend to discard information it had to expend no effort on, and autocompletion basically becomes background noise. I theorize that a fast typist will gain the edge after using the API 10+ times, even if they have to look it up the first couple of times, because the additional effort and focus they had to give to the task will commit it to memory (and they will potentially learn more about what the API is doing).

The focus is often on typing the fewest characters, but I think that's the wrong thing to focus on most of the time when choosing an editor.

[jules]

> I would argue that the autocompletion training wheels for learning a new API are really only useful if you're rarely going to use that API again. If you're going to be using it a lot, there's actual value in spending the extra effort to learn it's functions.

Couldn't agree more with the second sentence: I actually print out a listing of common APIs and take the time to memorize them. But you just described 90% of the APIs in your first sentence. For those APIs having quick access to autocompletion lists (to see which methods an object supports) and quick access to documentation is tremendously useful. As for your theory, common sense would say that how much you learn is proportional to the time spend on it. So if you use the API 10 times by looking it up manually, and you use the API 10 times by looking it up in contextual autocomplete, then yes you're going to learn more with the manual lookup. But this is an unfair comparison: you'd spend much more time on the latter than on the former. In the same time to look up the API 10 times manually, you could have looked it up in contextual autocomplete 30 times and then you'd have memorized it just as well.

I sense a lot of irrational aversion to autocomplete, that it's for slow typists, it's training wheels, and Real Men don't use it. Look at it as an incredibly quick way to look up documentation. In fact unless the method name is really long I do not use autocomplete as autocomplete at all: I fully type the method name instead of hitting a key to accept the completion. It's just a way to short circuit the process of switching to a web browser, searching for and reading the documentation of the relevant class/module, and switching back to the editor.

[rapind]

I wasn't using the term "training wheels" in any sort of derogatory way. You described autocomplete as a learning tool to get you up and running fast with a new API. Training wheels seemed like a good analogy. Nothing macho about it.

I don't think autocompleting a call 30 times is nearly as valuable as looking it up for me at least, because since I'm already invested I'll take the time to learn about it. If all I did was tab complete something and it seemed to work I'd be far too lazy to dig any deeper. I don't see why I'd spend any more time on it during consecutive autocompletes either.

Also, when I use a new library chances are very high that I'll be using it over and over and over again. It's more like 10% of APIs that I'll never use again (but still may learn something). I'm speaking purely from experience, and it baffles me that others stated finding so little library re-use. That sounds incredibly frustrating.

It's been my experience having used autocomplete tools in the past (4-5 years ago would be the last time) I don't miss them at all. I don't think they provide me with any real benefits. This is completely thought through and rational IMO. However I will grant you that it's potentially subjective and not everyone would see the same benefits.

[kamaal]

You are arguing against a lost cause. Using a text editor to work with languages like Java/C# was the trend of the 90's.

These days 99% of all Java/C# coding is in IDE's. And rightly so, because there is no reason to subject yourself to the torture of programming using an text editor. That sort of verbosity and boiler plate should be handled by tools, not humans.

People who code using simple text editors, in highly verbose and boiler plate demanding languages like Java are exceptional few and going by the trend will never be the norm.

[rapind]

You're probably right. The last time I touched Java was about 4 years ago. Even then I was using a basic text editor (Eclipse was a monster at the time that took forever to launch and hemorrhaged memory), but it wasn't so bad in the Spring (and Guice) world because you were mostly working with POJOs and didn't need any of the Eclipse autocomplete and refactoring tools.

I think the trend will actually go the other way though and there'll be less gigantic IDE usage in the future, but I'm not going to put money on it.

[samspot]

I tried to use Sublime for Java (w/ Spring/Hibernate) for a day and found several things I can't live without:

1. Ctrl-1: Automatically tries to fix a compile error. I use this a lot to get my imports automatically, and for other random things.

2. Open Declaration: This was touched on by others and is incredibly useful. The IDE can find the right Class even if two have the same name, while search can make this difficult in some cases.

3. Show References: Similar to above, this is just incredibly useful when you are refactoring or need to see how something is used.

4. Generate getters and setters: I know this one is dumb, but it's so convenient. I just hover over the unused warning then click, and i've got the code.

This editor is snazzy and fast but I don't think I can make the switch.

[samspot]

Why waste the mental space, especially with something you don't know you'll be using again? Not to mention the fact that api documentation can be difficult to find or may not exist at all. The Autocomplete knows exactly what methods are available.

I wouldn't disagree about learning the libraries you use frequently, but I personally work on a huge stack with more than 80 dependencies and memorizing their api's just isn't time well spent.

[skrebbel]

Most APIs I use I don't intend to use many times again. If I'd be coding against the same 5 libs over and over again, chances are big I'm coding roughly the same thing over and over again. That sounds very boring. (that, or i'm coding something low-level like a db or a protocol - but are you?)

[rapind]

Most APIs I use, I end up using over and over and over again in different projects / applications.

Only ever using 5 libs does sound incredibly boring. However the toolbox of libraries I've accumulated repeated experience with over the years is in the hundreds, and learning more about them has proven worthwhile. I assume most developers would say the same.