1. 20
  1. 27

    The author points to an anecdote about learning a language with an IDE vs without, and I have an anecdote to share about this exact scenario! I tried doing Advent of Code 2020 as a way to learn Rust, and I specifically used vi without crutches to Learn It Better, but all it did was frustrate me with errors until I gave up on Day 6. For AoC2021, I used IDEA and made it to the end, more successfully learning Rust and its common idioms than by fumbling through the compiler loop and getting frustrated.

    1. 3

      Good way to overcome that frustration is to learn by building an actual service or app, if possible. The end makes the means more tolerable. Then you get the hang of it and the means sorta become an end in itself. Virtuous cycle

    2. 25

      I read an essay once that I’ve been trying to find again. I believe it was written by a professor on department-hosted personal website. The question it posed was whether the “perfect” editor was one that only displayed what you absolutely needed or one that displayed everything you might need. It was, to my mind, a perfect way to talk about the IDE debate without really mentioning IDEs. IIRC their conclusion (as well as mine) was that your preference depends a lot on what you’re doing (is it familiar or not) and mode of work (is it exploratory or rote) and thus there is no perfect editor that will be the best for every task you need an editor for. Hopefully one of you fine folks also read that and can help me find it again ;)

      1. 9

        That’s a great observation! I hadn’t realized it, but this describes how I work, at least on many projects, particularly those where I’m doing different tasks at different times (writing docs, writing configuration, writing code, and so on). Just today I used Vim, VS Code, and PyCharm, all for significant amounts of time!

        1. 2

          not quite what you’re thinking of, but an old edward djikstra piece first came to mind on novelty and visualization - “On the cruelty of really teaching computing science” : https://www.cs.utexas.edu/~EWD/transcriptions/EWD10xx/EWD1036.html

          (found myself disagreeing with it when reading it a decade ago but surely my values and knowledge have shifted since then)

        2. 18

          I find it kinda funny that he talks about IDEs being not good for discovery, when a lot of folks use code-completion/Intellisense to explore APIs.

          1. 7

            Yes, this is key for me. I work on a large C++ codebase that 99+% of it I didn’t write. Most of my work is thinking “this function I want probably exists in some form”, typing out the variable name, pressing the period, then buttoning through all the completions until I find something that looks right.

            Docs only work for things that are documented, and documented well. Standard libs: sure. That code Steve down the hall wrote 6 months ago?: nope, it’s source or nothing. Code completion gets me to Steves code.

            1. 1

              Personally, grep gets me to Steve’s code.

              I see your point, it’s just not something that only works in IDEs. The shell does offer (ad-hoc) avenues for discovery.

              Where I work, avoiding code duplication is something that mostly happens in review and during pairing. Somebody rewrites a common function, somebody else says “hang on, we have for that in the helper library so-and-so.”

              I guess I’d need more experience with autocomplete to tell how much better that would make this. I think it’s probably a feature that benefits from a very strong compiler/ide integration.

          2. 15

            He’s a really good programmer, but that’s not why his solutions were better. Since he didn’t have suggestions to guide him, he read the docs and by simply perusing them, was aware of methods and other features that the IDE did not suggest.

            I like Emacs and I liked UltraEdit before that but the valuable lesson here is “read the docs”, not “use a text editor”. It’s not like the doc browser is guarded by an Emacs Lisp-wielding leprechaun who, upon seeing you, goes whoa, buddy, no puny IDE normies allowed past this point.

            I’m not sure if it was Joel Spolsky who first famously remarked that various properties of tooling do reflect upon the programmers – for example, it’s tempting to start coding things from the bottom layer and up towards the interfaces than the other way around, because that way IntelliSense can pick it up. But I read that a very long time ago (long enough that I don’t even recall where I first read it, and it was already a common observation by then). But this process goes both ways – once you’re aware of these things, their grip loosens considerably. At the end of the day, you’re steering the computer, not the other way ’round.

            1. 4

              the valuable lesson here is “read the docs”, not “use a text editor”

              I don’t see this as being about editors at all so much as a caution against relying too heavily on tooling in the abstract. He mentions using Copilot with neovim, after all.

              Sure you can always read the docs, but tools like Intellisense and Copilot are designed to make you feel like you don’t need to.

              1. 2

                I do enjoy how Haskell allows me to leave a lot undefined while sketching, while still holding my hand where it matters.

                Can’t really do the same in other languages I know, since the amount of bugs left in when I finish sketching would be overwhelming.

              2. 24

                tl;dr

                Someone who does not like IDEs, tries out github copilot and finds something they don’t like. They use this to support several notions including the idea that IDEs cause complex code, and that being dependent on tools is bad. (Says the person using a computer.)

                I haven’t tried out github copilot, but I code for a living and am grateful for all the automation I can get.

                1. 26

                  I think this is an unfair characterization of the post. IMO the main line of thought – that IDEs guide the programmer in a specific and limited way – is perfectly reasonable. The anecdote about a non-IDE programmer producing very different code from IDE programmers is thought-provoking. The observation about Java being language where the complexity is out of the programmer’s hands, so to speak, is interesting. And I found the post as a whole to be well-written.

                  1. 7

                    I too, dislike IDEs, mainly because I don’t want to learn yet another editor [1], but over the years, I’ve also found out they refuse to deal with the code I wrote [2]. Or they crash. Hard. After a few minutes of use [3]. Over the three decades of attempts, I’m at the point where I pretty much ignore IDEs these days as just not worth it.

                    I also wrote about this in general: When does technology pass from being a tool to being a crutch?

                    [1] I recall using Turbo Pascal 3, which technically was an IDE. I hated using it because the editor used different key bindings from what I was used to, and it couldn’t be changed. Yes, I am seriously dating myself here.

                    [2] One of the first Java IDEs back in 1997. The authors of that piece of crap didn’t expect anyone to write their own Java layout manager for applets.

                    [3] I’m not even talking about ancient history here, but recently. Some popular IDE that claimed to be for C/C++ but was lying because it assumed you were always using C++. I don’t. I use C. And class is a perfectly cromulent C identifier. Yes, I know. I don’t care. I’m writing C code.

                  2. 3

                    NotePad++ is my IDE

                    1. 3

                      I have a question: for folks who do not like IDEs and use non-language specific editors.

                      How do you re-factor code (eg restructure function relations, or change arguments type, order that some common function needs to change) ?
                      Say, for a code base that’s 100K+ lines and above, or a code base for 1.5mln lines and has may be 5-8 devs working on it, concurrently.

                      I cannot imagine doing without a type/language aware IDE help.

                      I am sure in the future formal methods for things like global state, data flow verifications, will be built into IDEs. Property-based testing will be done (optionally) at compile time, security assessment of dependencies will be made visible through IDE…

                      Perhaps, I agree to a degree with an author, that statistics/ML based code suggestions as a ‘central element’ of coding, are not that useful. But that’s not a fault of an IDE as a concept, it is a just the particular focus Github’s co-pilot that might not be that visionary.

                      1. 5

                        90 % of my refactor work is contained to a couple files max. For those times when I need to refactor at the scale you describe it’s usually not feasible to do so in a single pass anyway. That means I need to keep the old interface around. There are a lot of automated refactoring tools that aren’t IDE specific as well. This is very much a matter of preference though.

                        1. 4

                          The last time I did a refactor to push an additional parameter onto a stack of methods in golang, it was laborious. Next time I try that I’ll be setting up the go language server for emacs and if that doesn’t have it I’ll try an ide.

                          1. 4

                            I would say neovim is “non-language specific”, but you can get refactoring support, live diagnostics, and such IDE features through LSP.

                            I find it more convenient than “real” IDEs, since I don’t have to switch between different ones for working on different projects in different languages.

                            I use it among other things at work, on a large monorepo with various Java services and also frontend clients, for which IntelliJ IDEA tell me to download another IDE.

                            1. 1

                              also frontend clients, for which IntelliJ IDEA tell me to download another IDE

                              This is surprising to me. I regularly use a single instance of IntelliJ IDEA Ultimate to work in Kotlin, Python, Java, and TypeScript. Sometimes I use it to edit HCL (Terraform) too. I had to install language plugins but everything coexists without much trouble in my experience, both single projects with multiple languages and separate single-language projects.

                              What other IDE was it telling you to download, if you happen to remember?

                              1. 1

                                What other IDE was it telling you to download, if you happen to remember?

                                I think it was WebStorm, when I opened up an Angular file.

                                There’s also the issue that it’s all pixelated on a scaled Wayland display, and that I can’t use a pointing device, and even with the vim plugin there’s many things I don’t know how to do, or do comfortably, without a pointing device. And the sluggishness.

                                I tried to fix those things but it was easier for me to add capabilities to Neovim.

                            2. 1

                              We avoid having codebases that size. The largest we got was 75kloc, before we broke it up into smaller components. It was still maintainable because it was decomposed into sub-areas that would talk to each other over well-defined interfaces, and it was supported by a bunch of helper code that was pulled out into libraries.

                              Generally speaking if you can make any change and it will affect an appreciable fraction of the entire codebase, you’re either developing a compiler or your repository’s architecture is questionable.

                            3. 2

                              I found this very reminiscent of In the Beginning was the Command Line if you’d like to read the same point made in a lot more words.

                              1. 2

                                It’s amazing the lengths that the author (probably unwittingly) went to to make this page unmodernly unresponsive. The <p>s are wrapped in a single giant <font> parent, which itself is in a <td> of a <table width="100%">.

                                1. 3

                                  Well, that page was written in 2002 and hasn’t changed since then.

                                  I agree it’s long overdue for reformatting if the authors care about readers. In 2002, it was already antiquated, but it wouldn’t cause any problems for a typical visitor. Maybe they intentionally made it that way to support old browsers that didn’t have a correct CSS implementation.

                                  1. 3

                                    It’s an unauthorized copy of the original, which is copyrighted by Stephenson

                                    https://en.wikipedia.org/wiki/In_the_Beginning..._Was_the_Command_Line

                                    I remember reading it (when it was available online from his site) on duplex-printed paper, which was how I consumed long form media on the subway at the time.

                                    1. 2

                                      Yeah, I did something similar at the time. The original site is still accessible via the wayback machine, but I didn’t want to make people go through the trouble.

                                    2. 2

                                      No, that table didn’t do anything useful back then either. Not assuming the code’s author was ignorant, I’m guessing it’s a wrapper for all pages including those where it is actually useful.

                                2. 1

                                  He’s right about garbage in garbage out in principle with statistical learning driven development. However, it’s a matter of providing code examples with higher guarantees. You can’t get that off random commits and stackoverflow answers at the moment. We may get there in not too distant future with other stuff not yet built that’s social network driven