I made a decision 20 years ago to avoid auto complete and other "in programming flow breakers". Instead, I have multiple phases, writing, linting and such.

I am sure that it made me a better programmer as I know a lot of stuff by heart, where a lot of "auto" programmers are merely constantly picking of a list, which I think breaks their thinking flow...

Which is basically the same as not using the vim muscle memory for me..

Consider a piano player that needs to look up the right keys before every stoke.. The never get a feel for the music..

It's a fair point, certainly interesting, however most or all of it is an assumption (you didn't try the other thing in an elaborate way, let alone double-blind-tested it), plus it might not work like that for everyone.

In the past decades I have written (and still do) like 50/50 in IDEs and plain to somewhat less plain text editors, and if there's something which is a flow breaker for me, then it's coming up with the exact name and method in such plain editor when I just know there's one which does what I need but cannot remember the exact name. Fuzzy matching it against a list doesn't break any flow for me on the other hand.

Which matches how my memory works: I cannot remember hard facts and data well (function DoSomethingVeryHardCore). However I'm good at remembering abstract things (function which does something hardcore). I am pretty sure learning many things by heart from the many very different codebases I work on would be a complete waste of time. Instead learning some abstract mental model of the codebases architecture, and how to navigate through it in text, is what makes me fast and efficient.

I coded in IDEs for almost a decade up to that decision.

I could feel my "clarity" fall year for year.. I have never looked back.

I stand by my original statement, that for me, IDEs hinder my thought.

Also, I have seen other coders I really consider high-end having the same considerations (it might just be a bias, where I just notice those, who agree with me)..

Have you ever seen the "competitions" where they give a really really good photographer (or videographer) a 50$ toy and lets them compete against an amateur with a really high end setup..

Only amateurs blame their tools (above a certain minimum threshold)..

I'm gonna go out on a limb here and say that the amateur does worse than the pro is because said amateur doesn't know how to use the (often very complex) tool that they've been given, whereas the pro knows all of the theory and at least mostly how to use this toy.

I use autocomplete heavily and I can assure you that it breaks up flow much much less than having to go to the documentation all the time to look up minor naming variations (is it "start" or "begin"?).

Programming is not remotely the same as playing the piano. This and the sibling "I don't make mistakes" comment just seem like excuses to me.

> it breaks up flow much much less than having to go to the documentation all the time to look up minor naming variations (is it "start" or "begin"?).

I read OP's position as: If you don't use aurocomplete you'll remember the naming variations better, and won't have to look them up all the time.

I still think aurocomplete might be faster for libraries you haven't used much before, but it doesn't sound at all unbelievable to me that the brain works as stated.

I never used autocomplete until my fourth programming language. By that point, trying to write anything was an exercise in frustration as I constantly mixed keywords, namespaces and functions from the other languages.

Nowadays, I just leave autocomplete on for minimal flow break no matter what language I'm using at the moment. I don't want language-specific names and structures interrupting the flow of models and ideas from my head.

OP's position doesn't work very well the more you generalize. I had OP's philosophy when all I was doing was low level C code. It doesn't work very well when you are switching between yaml, python, c++, c#, typescript all with different libraries, coding standards, and naming conventions. By the time you no longer need the reference to remember, the reference changes.

For me, it works with 5+ languages I write (production) code in at least every month...

I don't know how it is for others.

Also, I really try to minimize complexity and not ending up in the javascript npm dependency spaghetti..

Good code is simple and obvious....

> I still think aurocomplete might be faster for libraries you haven't used much before, but it doesn't sound at all unbelievable to me that the brain works as stated.

Possibly, but I still need to read the librarys documentation carefully, where I plan my code anyways...

I have seen so many "auto coders" write 100+ lines of extra code because they missed reading the manual carefully and doing it correctly/efficiently...

If lines of code is your metric, that is great, if not, not...

FWIW, I didn’t say that I don’t make mistakes. Perhaps you misread my comment.

And why would one need an excuse for setting their development environment up the way that works best for them?

> Perhaps you misread my comment.

Which comment are you referring to you? IshKebab (the user you are replying to) was replying to svennek (not you).

IshKebab said:

> This and the sibling "I don't make mistakes" comment just seem like excuses to me.

At the time of IshKebab’s comment I was the only sibling comment.

You literally said

> I’ve learned not to make the mistakes

Yes. Perhaps you're just skipping over the word "the" when reading that sentence? In the context it has a pretty important meaning, so it pays to read all the words, not just the ones that support your preconception.

I have learned not to make the specific mistakes that the linter used to tell me off for making, so it doesn't tell me off any more. That's a very different thing from "I don't make mistakes", which is what you incorrectly claimed that I said (even with quote marks around it, implying a direct quote!)

I think it depends on whether you type, or your fingers type (without brain involvement).

I didn't say, that I don't make mistakes. It is rare that I make it a quarter of an hour before fucking up... luckily I am good at fixing it :)

But again, if you like your IDE, use it.

I have (almost) one decade of using IDE vs. two of not using an IDE and I strongly prefer the freethinking of the latter...

My use of vi-like editors is sufficiently minimalist that I use a locally built http://ex-vi.sf.net/ and still don't really need more than about half the features of that.

I -personally- find it way more comfortable than even a minimal vim install because when I typo a command it beeps at me, whereas in vim I generally accidentally activate a command I don't understand and get broken out of flow while I figure out wtf just happened.

I don't at all judge people who're IDE wizards, I've not seen any correspondence between maximalist versus minimalist taste in tooling and competence, but this approach works way better for me.

> in vim I generally accidentally activate a command I don't understand and get broken out of flow while I figure out wtf just happened

This doesn't happen to me very often anymore but when it does I’m grateful for multiple undo, I’d be scared to use an editor without it.

So interesting.

> where a lot of "auto" programmers are merely constantly picking of a list, which I think breaks their thinking flow...

For me, typing when the computer can type faster than me breaks the flow. Though your auto complete is very bad if it needs you to pick things from a list - 99% of the time it's just "type a couple of first letters, <ctrl-space>, repeat for the next token."

> Consider a piano player that needs to look up the right keys before every stoke..

Most professional classical musicians play with sheet music, no ?

> Most professional classical musicians play with sheet music, no ?

That is WHAT to play, not how to play... also I actually thought more of improv players, but that wasn't stated :)

I don't consciously type...

I think, my fingers type...

I spend 0% brain cycles on typing (it is pure muscle memory), which why picking from a list (or checking that autocomplete choose the correct) is more brain work...

> I spend 0% brain cycles on typing (it is pure muscle memory), which why picking from a list (or checking that autocomplete choose the correct) is more brain work...

but, it's definitely not "more brain work", just like stenography does not take "more brain work" to write - when you're used to it you don't need to look at the autocomplete output either, it's just a very shorthand way to get things from your brain to your computer.

I just need to trust my fingers, you need to trust an algorithm choosing something for you.

For me, checking whether auto-complete choose the correct is more work that typing the correct thing, as my fingers type on their own - almost without supervision...

I have written code for 30ish years (professionally for 25 years) and I have honed (and still hone) my environment for maximally "transparency" so that my though is not hampered by tools..

If that is not true for you, then use your IDE and be happy about it... Nothing wrong with that, at all...

EDIT: also fun, that you highligt stenography that is the definition of learning-curve/musclememory ... :)

> I just need to trust my fingers, you need to trust an algorithm choosing something for you.

but, that's the thing, I don't even remember the last time my autocomplete didn't complete the right thing. So yes, I entirely trust the algorithm, it has already saved me so muchtime.

In my experience simple tools leads to simple designs. With the aid of an IDE the architecture/design of an app can become insanely complicated.

You've really never used CTRL+X F to look up a file name in vim?

Can you elaborate how 'Ctrl-x f' looks up a file name?

I tried 'Ctrl-x' but it decrements the integer under the cursor by 1. I tried 'f' but it starts a new motion command to search the next occurrence of the character following it to the right. Example: 'fx' will place the cursor on the next occurrence of 'x' to the right.

How can I use 'Ctrl-x f' to look up a file name?

In addition to being an insert mode command as jshholland already noted, it is Ctrl-x Ctrl-f, not Ctrl-x f.

Here is a description of it and a few other insert mode commands: https://georgebrock.github.io/talks/vim-completion/

Fascinating. These ctrl-anything is like a dangerous, crippled emacs lurking in a dark corner of my beautiful vim, ready to terrorize with keyboard coords over modes and commands ;)

I've bound some complete-plug-in to tab, but that's pretty much all I do in insert-mode command-wise.

It's an insert-mode binding, built in by default.

As the boss of a company: micro managing your employees to the point where you dictate exactly how they work including their preferences for editing text is an excellent way to lose your best talents, who will likely be quirky and in some cases - possibly this case - know more about this than you do. And no, it is not 'like an electrician refusing to wear protective clothing', it is much more like an electrical engineer that knows when to use auto-routing and when to route things themselves.

Besides, I'd love to see you make your case to HR: "I want to fire this person because they don't edit their text like I do".

Good luck with your career as a boss.

While I wouldn't want to fire someone for using bad/incomplete/incapable tooling, the Nth time someone doesn't follow the style guide (which is automated for everyone else, but not for this guy because his 1337 editor doesn't support it) or leaves bugs in that are caught automatically for everyone else because of editor support it's time to consider if his constant breaking of convention is an issue and he either needs to use more capable tooling or leave.

Less extreme than the previous poster, I'd actually like to provide JetBrains licenses for my teams and strongly suggest using them. The amount of help WebStorm, PyCharm, etc. give is honestly way too much to pass up and the kind of uniformity you can get from everyone using them is great, all out of the box.

I used to only use Vim and Emacs but there's no question they're much more incomplete tools for development. I don't see why one would pass up JetBrains IDEs considering they have a passable Vim mode and for the languages they have plugins and/or product lines for they're just better.

Yes, but that's different. You are judging people by their output, not by their tools, and that's just fine.

I've seen people produce absolute miracles using fairly archaic tools showing a very deep level of understanding of both the problem and the domain. Forcing them into some kind of straightjacket to use 'modern tools' would be the same as taking Itzhak Perlman's Soil Stradivarius away to force him to play on an electric violin just to get with the times.

For things like formatting/finding bugs, shouldn't those be command line tools anyway, so they can be built into your CI?

Even if not, there's no reason not to allow someone to edit text however they like, and then just load their changes into Intellij or whatever to double-check formatting and use its static analysis tools before raising a pull request.

> I don't see why one would pass up JetBrains IDEs considering they have a passable Vim mode and for the languages they have plugins and/or product lines for they're just better.

I use Intellij at work for Java stuff, and I could easily see why someone would want to use something less resource intensive (especially for less IDE-dependent languages than Java). I regularly run into issue where I get pauses while I type.

> I regularly run into issue where I get pauses while I type.

Close your web browser or install "auto tab discard" plugin.

I should clarify. It happens in Intellij, not in the browser.

I can have Intellij, Firefix, and Chrome all open while typing in emacs and no typing pauses at all.

On the other hand, I can run Intellij alone with no other applications open, and still get pauses while typing.

It's an issue with Intellij itself, not a matter of system resources.

That said, at least for Java, I find the benefits outweigh the costs. But I don't find that to be true for any other language I use.

> I don't see why one would pass up JetBrains IDEs considering they have a passable Vim mode ...

Because I am suspicious of "the magic" of those IDEs..

I truly respect the "old" code, I mimic the coding (and naming) styles/conventions of any code that I work on.

My goal is that (except when cheating with git-blame) others cannot divide the code between original and added by me...

And it is definitely NOT a question about cost.. I am willing to (and have) spend a lot of money on good tools.

But for me, 2/3 of my time goes to thinking and 1/3 of my time goes to writing/typing...

This may only apply to junior people. Take James Gosling's super dense style of coding and disregard for style guides. These ultimate geeks would just leave.

I completely understand the position of the person you replied to. One video outlining it is here: https://www.youtube.com/watch?v=Q3XuFr7rw84 . Many people disagree with it but I think thats because they don't imagine being productive without auto-completion.

> If I were a boss of a company and saw one of my employees do this, I would seriously reconsider their employment. Purposely limiting yourself has no place in development.

If I was a boss of a company I would try to judge people based on some objective measure, rather than subjective opinions about how one should be doing things.

I write in languages with and without IDE. With autocompletion, I'm more productive than without. Even in shell I prefer to use autocompletion or two panel file commander, because it lowers burden on my brain. I don't need to spend brain cycles on correctness of typed code. I know names, I type fast, but with Tab it even faster to type, and less error prone.

For example, when I started to use Rust, IDE was not available, so I used plain text editor for about 2 years. When I switched to halfbaked IDE, my productivity is raised because of autocompletion and error checking on the fly.

> https://www.youtube.com/watch?v=Q3XuFr7rw84

Cool video, thanks. That is going straight to my treasure chest..

So if someone is a solid performer without using autocomplete... would you fire her?

As a boss you would be judging the performance of an employee against the group average -- coding tools be damned.

I think an employee would prefer to be rated on the quality and quantity of their output, not on whether they used autocomplete or not.

Hopefully not quantity as measured by lines-of-code...

Right, not quantity in that sense, but as a fraction of the working product expected of you.

I have known a couple of people who fussed and fussed with little chunks of code until they were little gems, but always missed the big picture and missed deadlines. I have also known a few whose instinct was to write a framework first, and that takes a life of its own; the most egregious one was a CLOS (common lisp) style system using C macros. Debugging was a nightmare.

> If I were a boss of a company

I hope you do your colleagues a favor and never become the boss of a company.

The attitude you have is totally inappropriate to become a boss.

I think that's the point being made, they are not limited by this decision, in fact they find it more efficient.

For me it's the opposite.

When I interview some of the things I look for:

- Are they comfortable and productive in their own coding environment?

- Do they understand the code they are writing?

There are more things I look for, but those two touch upon this... if someone interviewed and were fluently moving around their coding environment and the quality was high and they understood what they were doing (complexity, allocs, maintainability, readability, approach to the problem, etc)... then they'd be hired.

Further, their future perf reviews would never care about this stuff. Or if it did, it's only to say that this is part of the health and wellbeing of the individual who has chosen a work environment in which they are happy and productive - which is a net positive to the company.

Not GP, but I have a linter that runs on commit, and generally it doesn’t catch anything because I’ve learned not to make the mistakes.

I have never liked autocomplete. If I know the type or method I’m looking for (which is most of the time) then typing its name is not a hardship, and takes really no more time than finding it in a list.

If I don’t know the type/method, most of the time I have the documentation up in another window or monitor, and I’m going to want to read that in depth anyway, since I’m not familiar with the type/method, so autocomplete wouldn’t save me any meaningful time.

I agree with you, but this depends on the language. Some languages and libraries take more liberties with the length of identifiers, the amount of abstraction layers, and maybe more. Java is the classic example where using a plain text editor is really a liability; I can use C++ without any editor support and be fast. But I'm not sure what this really depends on. (Disclaimer: my argument is flawed because I know C++ well and not Java.)

Despite your disclaimer I think you are onto something.

I am experienced in both Java and C++ and while I can read/write/refactor code in C++ just fine with Vim, doing so in Java without a sophisticated IDE is a painful experience.

There may definitely be something in that. I’m writing Rust or C most of the time.

Plugins are a bonus for vim, but one doesn't really use vim just because of the plugins. There are far better editors for this. Decidated vimmer usually make heavy usage of external tools, instead of integration which plugins bring. There is the term "Unix IDE" for this, you can read a bit online about this (for example: https://mkaz.blog/code/unix-is-my-ide/ )

Also vim user. I use fairly minimal plugins. Mostly Nerdtree and the tabs plugin for that, formatting plugins for various languages, and CtrlP. I've tried autocomplete a few times, but never found it worth the trouble. Might be because I mostly work in dynamic languages where autocomplete is mostly awful, and it's easier to just remember, yank from elsewhere, or lookup function names and signatures than to get anything useful from autocomplete.

I don't really like realtime linting, autoformatting, or error highlighting either. I find it highly distracting, and usually it's complaining about something I was already going to fix anyways. I'd rather have such things done only when I intentionally trigger them. I'd say please stop whining about syntax errors and test failures in code that I haven't finished writing yet.

I've tried some Git plugins, but never got into those either. I still prefer the gitsh cli application for most of my Git work.

I also use no plugins (because I often have to ssh to many network servers). I have found a surprising benefit in my coding to "coming to know" things about library APIs and projects through mental "muscle memory". For instance, by not relying on a file browser or even a fuzzy finder, I eventually come to learn where certain files probably are... and the probability goes up the longer I am in the code base. Similar for lib APIs; although my vim session may be on a remote machine via xterm, that doesn't prevent me from having a local browser window open and reading API docs to find what I need often helps me understand the library better.

Vim has built-in auto completion, for some languages (Python, C, ...) it can even be kind of smart. There are many videos showcasing the power of vanilla Vim

https://youtube.com/watch?v=XA2WjJbmmoM

https://youtube.com/watch?v=Gs1VDYnS-Ac