Hacker News Reader

Comment by mailslot | Hacker News Reader

I’m going to get heavily downvoted for this, I’m sure, but... If I find myself needing, or even using, code completion, I’ve fucked up my implementation. My interfaces are not intuitive nor consistent... or it’s just glue lacking adequate abstraction.

I strongly suggest all developers disable completion & tag jumping, not because I’m an elitist, but because it forces you to write better code. Not a troll. I’m serious.

On projects I’ve worked on that started with Intellisense, they quickly evolved into being unmaintainable without it. It’s an asset to skilled hands, but a debilitating crutch for the novice.

It’s like never operating a vehicle without a GPS. You never develop certain types of skills.

View on HN

I get what you're trying to say, but I feel like it also implies that you've written everything you're using. I'm an Android developer, and I've worked on some huge java code bases. Not only do I rely on autocomplete to discover/remember various parts of the Android SDK, but things like "go to declaration" or "find usages" are incredibly useful for navigating large code bases. Not to mention Java isn't known for being the most terse language, so saving some keystrokes helps too :)

Personally, it slows me down considerably without intellisense, even when I know the entire codebase. If you have overloaded methods, for example, just remembering the order of the parameters is impossible without intellisense.

This makes me believe that either I have a really poor memory by not being able to memorize thousands of method names, their parameters and orders or other devs have a really, really good memory.

You're not alone. I strictly use kwargs in my functions because I can't be arsed to remember the order of arguments in addition to the structure of the rest of the program. It's more work but I need any simplification or hint I can get for my feeble mind. And I don't even use Java.

It’s a fools erand to disregard automated tooling that could benefit in API discovery, type checking, linting, code analysis, spelling, navigation, auditing, etc. which are now manual remedial tasks common in day to day development you have to do yourself and the later you catch any of these issues the more time you will have wasted.

You now have to leave your context and “break the zone” you’re in to find the symbol name you want you use elsewhere, you’re at the very least less productive as a result.

I’d also expect code quality to suffer, given the number of issues I’ve found thanks to code analysis, type checking, linting and spelling that we’re able to highlight, catch and resolve human errors before shipping.

I didn't downvote you because I understand where you're coming from. The APIs you work with probably don't change and you already know most of them, disabling code completion works for you. But if someone renames things in your API, you'll be slower without completion. And if you're working with a new language/framework (or even just a large library), you'll reaaalllyyyy wish you had code completion.

A few years ago, I started working on a project where I needed to use C#. I'd never written a line of C# in my life, so I installed VS and with the aide of Intellisense, I went from having a "Hello World" snippet from Google to using several C# libraries to create a ~1000 line PoC in a day. A few days later, it was production ready. Without Intellisense, this story would be very different.

Autocomplete isn't just a form of documentation, I very rarely use it that way (that's what go to definition or GitHub are for). I know how to override ToString(), but ov[tab]tos[tab] saves me about 40 keystrokes. Stubbing out an interface can save me hundreds.

Scott Hanselman has a great tweet chain (or blog article, can't remember) on the fact that you have a limited amount of keystrokes in your life. I'd rather not waste them on something a machine could do.

some languages are more verbose than others. if you're dealing with `ProblemProblemFactory` type of abstraction madness and subscribe to the idea of spelling out every variable (MessageCounter instead of "cnt" etc) then this would seem handy.

Maybe it's a question of mindset & philosophy. I personally prefer a minimalist but powerful editor without plugins and just rely on their internal capabilities (which granted are a learning curve). It avoids getting stuck when doing $EDITOR foo on a system you don't own and still feel at home and as fast as on your primary workspace.

"How to Do 90% of What Plugins Do (With Just Vim)": https://www.youtube.com/watch?v=XA2WjJbmmoM

I’ve worked in multi-million line codebases with several generations of naming “conventions.” Auto-complete is a lifesaver there. I’ve also worked in small micro services with a well defined API and a SLOC that could be measured in the tens of thousands. In that case, sure autocomplete could be seen as unneeded.

Edit: replaces ableist phrasing with more precise term.

I don't agree. If you are developing with Rust, completion can be useful. It can show you the signatures of the function/struct and types. It'd be hassle to go look them up on a browser.

Fair

Good completion can help when working with a new library you are not familiar with yet. Specifically in strongly typed languages like Java or Kotlin.

Usually I kind of know what I want to do with an object so I start typing ‘myObject.’ and the editor shows me all possible methods with their argument types. It’s way faster than looking up the docs. And in the case of Java/Kotlin in intellij you get the documentation right along the method names and types.

Apparently you've never worked with a very large codebase.

... but with completion disabled I'm pretty sure I'll stop naming my interfaces properly because it's too hard to type, and I won't try to came up with "clever" ways of naming things like "creat" and "mv". I'll just use cr, sav, o, upd, a, b, c, d, ..., zz instead, good luck maintaining that.

TBH I just love auto completion to reduce the amount of typing I need to do.

Yeah, a couple decades ago I used to think Intellisense was no big deal. I loved Emacs and was happy with Hippie completion:

https://www.emacswiki.org/emacs/HippieExpand

I’ve long since changed my mind and really hate not having great auto-completion.

I find that grabbing pen and paper and looking at the problem from a high-level avoids the problem where you code-monkey the program by just quickly banging away at the keyboard.

I partly agree with you. Tag jumping is actually necessary though. Jumping through the linux kernel code base without tags would be a nightmare. I do agree that the pop up as you type autocomplete is actually producing worse developers. Sometimes using the standard vim completions via C-x are actually worth it, but a lot of the time it just encourages writing more code than less code.

I use autocompletion because it helps me get things done faster, not because it helps me get things done that I couldn't do without it.

What about when you are having to navigate and work with someone else's crappy code which is 90% of a job anyone works with. Sure if it was up to your own discipline I would agree with you, but we have to deal with other people's code constantly and I'm not rewriting it just to understand it. I need code navigation and completion.

Your words, my words. I highly recommend people read [1] where Linus explains why he thinks kernel debuggers are basically unnecessary. I think many of his arguments apply here as well.

[1] http://lwn.net/2000/0914/a/lt-debugger.php3

Lack of discoverability makes for worse code, if anything. Constantly switching back and forth between documentation and the editor is a big hindrance to getting things done.

I don't agree. I don't think there's a correlation between intellisense and bad coding standards.

You obviously did not worked with huge (100,000+ lines) codebase which you did not write yourself.

I'm not relying the autocomplete functionality per se, but they make discovering these kind of code easier.

I have, and my teams write abstraction layers around both internal & external systems for testing, integration, and sanity.

It limits the scope & necessity of domain knowledge to be scattered about everywhere. The core logic is easy to reason about and there’s no tight coupling.

For example, if I’m calling libcurl directly in C++, I’ll create a generic adapter. Auto completion isn’t adequate for that library anyway, unless you can remember the docs.

If it’s some unwieldy “does everything” internally developed monolith by a team from hell, the same applies. Encapsulated composition.

The problem most people have to code with other libraries, and the intellisense can help to make the work easier.

It also helps you to make better code by showing diagnostics.

Well, I think it depends on how you use it. If you use it to 'discover' huge code bases (instead of reading documentation), I am not so sure that is a good idea. But if you use it to reduce the keys you have to press, there is nothing wrong with that.

It is a powerful tool and you should be aware of that power and act accordingly (meaning: know exactly what you are typing and don't fall for bad suggestions).

Reply on news.ycombinator.com