1. 20
  1.  

  2. 15

    Disclaimer: This probably is more of a blog-post than a reply. It started out as a reply and kept expanding, so my apologies if you’re irritated at scrolling past this!

    I’ve written about this before, but I’ve spent a good chunk of time (on the order of years) reading about the history of UNIX, about the tooling choices made in other operating systems that didn’t quite take off, etc.

    It always seemed to me that programming is a specialist task, a skill and therefore it should have specialist tools. How come financial advisors have their own specific computer interface (The Bloomberg Terminal), whereas programmers for the most part, do not? For that reason I learned Vim, after switching from Sublime around 2012. It often isn’t the best tool for the job, so I simply do not use it for that(!). A lot of the time I will cat > /dev/null for some notes in a separate terminal, or grab my notebook out and push pen to paper for an hour. You use the tool that is best-suited to the task at hand.

    There are some things that I cannot do without Vim, at least not without a lot of irritation. The muscle memory of editing tasks is part of that, because while I can write code in other editors, it doesn’t feel pleasurable to do so. This has been said many times, by thousands of people the world over, however I shall restate it: When I’m using vim, changing the text structure of the code is much, much more fluid. A single sequence of inputs map to something that would be more frustrating and error-prone to do in other editors, because that involves very sloppily changing text using a mouse (Gravislizard has written in-depth on this topic).

    It’s for this reason I refrained from learning Emacs for some time. I did try, because it seemed like a different tool that was sharper on some edges, but the interface was jagged at some points. I didn’t quite understand it and I didn’t want to understand it because it didn’t seem to give me anything that wasn’t improved upon by Vim.

    Even so, the image of a weathered skilled dwarf-styled programmer, growing into his tools, sounded very pleasurable to me. When I found Doom Emacs, it was a joy because the jagged edges were for the most part, gone. What’s more, I had access to Emacs and all of the valuable parts of Vim’s interface, so I switched, and I honestly feel like I’ll be using it for the next 10 years, if not longer.

    It seems to me that people who partake in a craft, a lot of the time will build their own tools. Part of it is to learn how to do it – so say, a blacksmith will make their own tongs, etc. partly to improve their practice at that, partly to play around with the concept, and often just because they can – you can see this with things like Kakoune and dozens of new tiny editors, and with the (collectively) billions of little shell scripts and dotfiles everyone has. Someone who is good at their craft finds a misfit, a place where the design doesn’t meet their needs, and says “Ok, I’ll put some time aside to replace that”.

    Likewise, the value of Emacs to me is that I can look at what other people’s tools do, and replicate that extremely easily. It might take a little bit to find the right section of documentation, but the tooling around investigating what is already happening in my editor – around figuring out what I need to change – is so extremely easy to access now that it’s actually fun to do so. That doesn’t seem like a huge negative to me, it just seems to be how you grow and develop into a skill. Sure, there are lots of skills that aren’t like that on the surface. Music, for example, you can for the most part just pick up someone else’s instrument and play – but even then the tone or timbre of the instrument might sound off to you, the pegs might stick, or the shoulder rest might need adjusting.

    I don’t feel that everyone should do this – by which I don’t mean that those people aren’t skilled. While I’ve spent a good deal in this conflating skill with tooling, one of the best programmers I know has spent years using first Geany, and after that, Gedit. It’s a personal choice based on whether you want to do that or not. At the same time, I don’t feel that any of this is the sunk-cost fallacy, but I can only talk about my experience with it. I’m generally not someone who will spend a week reimplementing a calculator in my text editor rather than opening up wcalc(1), because there’s a happy medium between effort you spend on something and what you get out of it.

    While I do recommend to people around me that they try Vim or Emacs, with the advice that someone uses vimtutor(1) and avoids the arrow keys, I don’t expect everyone to do it, and I certainly don’t expect everyone to stick to it – it took me several tries to “get” Vim. And while the cost was worth it for me, it very much won’t be for some other people. I still feel the experience of trying new tooling is valuable because it helps you find other workflows, and ultimately the point is to figure out what you want out of a tool, which is the most important thing in all of this.

    1. 6

      Fun timing - I was just telling myself that I should stop not recommending/advocating Emacs to my colleagues.

      Usually I shy away from doing so, explaining that I like Emacs a lot, but not going further than that. I think primarily because I don’t want the experience of them being disappointed with Emacs and abandoning it after trying it on my recommendation.

      But I need to remind myself that I will be seeing them using Microsoft Visual Studio Code instead, because that certainly has a lot of advocacy… shudder.

      1. 1

        While I don’t actively advocate anyone to switch from any other editor, I do generally share some of the Emacs findings/tricks I discover… it often generates enough interest over time. Folks eventually try it out on their own time and come to me with questions. Having someone accessible to clear initial bumps seems to be pretty handy. It may get folks enjoying the experience sooner and,perhaps make it all that much more sticky.

        1. 2

          This is the same for everything in Programming though. It’s largely something you can learn yourself, but having a network of people to prod for questions is extremely useful.

      2. 5

        This - the internal comment nor the blog post - doesn’t really resonate with me.

        It doesn’t resonate with me in terms of my personal experience: I WAS a full-time emacs user for a few years straight, and I have recently switched back to neovim, and honestly, I’m fine. I relearned the editor bindings, I am settling on the plugins and config that I want, and my life goes on. Before emacs was kakoune, before kakoune was vim again.

        But it also doesn’t resonate with me in terms of what I see in my peers. I have met tons of folks who were dyed in the wool emacs - or vim for that matter - users, and who nevertheless decided to start using VS Code or the Jetbrains IDE for the language they used at work. The most common reason was simply that it was what their coworkers were using, and they found it reduced friction if everybody was using the same thing.

        In other words: I have switched text editors based on their technical merits. I know lots of people who have switched based on something seemingly even less substantial than that (less substantial, of course, from the perspective that seems to view accumulated habit and rc files as the biggest multiplier in the equation). We were all full-time professional users of these programs, and found ways to get everything done in rather short order. I don’t resonate either with the Reddit poster who seems almost to be stuck in an abusive relationship with his text editor, nor with the blogger - though I confess I don’t fully understand his point of view one way or the other.

        Honestly, both writers feel a bit like cautionary tales to me: the former, who feels at worst trapped and at best ambivalent about his software, and the latter, who feels the need to stake an intellectual and philosophical position on using emacs or not.

        I think the thing they both have in common is that they’re clearly heavily bought in to an information ecosystem that is so complex that it doesn’t make sense outside of a particular program. I take this to be org-mode, and I imagine their org-mode setups have lots of custom actions or syntax that they’ve accumulated. To me, what this suggests is that, even if we are using an open, standard format like plaintext, theoretically addressable by any text editor under the sun, we still should be intentional about keeping the systems we use simple - maybe even primitive! It suggests to me that there is really value, if I’m going to take notes in my computer, in simply using some text files and maybe some Markdown formatting. I never want to be in a position where I’m chained to my software—not because it’s proprietary, but also not because the systems, syntax, scripts or formatting themselves are so complex that I can’t do my work without them. Personal information management, in other words, is a phantom. The substance should be in the information itself—or even better, in the person! The management should be minimal-to-nonexistent.

        1. 4

          Very nice rebuttals, however to me the main reason why emacs[*] is worth it, is because text-centric interfaces are, in many ways, superior to alternatives we have so far.

          Think about it: every piece of the UI is manipulable with the same, uniform interface. Getting better at one task within this system makes knowledge transfer instantly applicable to any other task. This is why in emacs there’s a tendency to include everything into this system, because by doing that it becomes instantly manipulable and uniform. It’s not about the language, or the editor itself, it’s a combination of factors. By making the UI using the same actual medium which is used for data entry (text), we allow interactions which do not need to be foreseen by the developer. It’s homoiconicity at the user-facing level.

          The reason I want to use my favorite editor instead of the editor already in the IDE is that I want to use all my uniform manipulation knowledge, always, everywhere.

          Likewise, this is why in many cases the CLI feels more powerful than a GUI, not just at a superficial level. The bare-bone I/O system, even when primitive (such as *nix style plumbing) is much more amenable to manipulation and transformations by the operator.

          I haven’t seen anything that allows the same degree of flexibility in any other GUI system (which doesn’t just degrade in “you have scripting”) so far. Can we do better? I honestly cannot imagine we can do that until our input system is text. I feel like we need a breakthrough in the physical layer to unlock something new here. Maybe VR can do that.

          [*] I’m a 20+ years emacs and vi user, btw. I juggle through both. Everything I said applies to both.

          1. 3

            There are a hard core of emacs users who have a huge number of customisations and whose life revolves around emacs to a considerable extent. I don’t mind them but I do think it’s unhealthy for the wider emacs community to think of as the main users of emacs.

            I am personally in some other niche. I can’t get into org-mode as I prefer putting notes on paper and don’t really see any need to keep notes beyond a week or so. I do use the calculator a bit but not for anything advanced, just because the RPN calculator is built in and good for simple sums. I certainly don’t use email or RSS from emacs and probably would never as networking has always been a weak point of emacs and I think of any non-local IO as a risk. I do have some customisations but over recent years I feel like I remove more than I add.

            The parts of emacs I do use a lot:

            • occur/clickable greps
            • compile mode
              • clickable tracebacks
              • clickable warnings
            • some Python jump-to-def thing
            • ibuffer
            • dired
            • keyboard macros (and saving them)
            • bookmarks
            • hippie-expand, which is so dumb but feels very smart
            • a save and session level backup thing
            • magit
            • any mode for a languages/filetypes

            I have used other editors over the years when required. I’ve used Intellij to write Java/Scala and used Visual Studio for about a year at work when a client required it. Visual Studio is a lot like emacs - I think a ripoff of it actually - except that instead of M-x you hit C-q, IIRC.

            Consequently I do encourage people to start using emacs and I do help them get started. I don’t think it is so hard but there are a lot of idiosyncratic keybindings which aren’t common outside of emacs (g to cancel is a classic emacsism). I tend to discourage new users from doing lots of configuration.

            1. 1

              Yeah, I’m a pretty serious emacs user but I don’t get into the emacsOS stuff. If I want an IRC client or a browser or a news reader, I’ll use a dedicated program.

              But for writing text? Haven’t found anything better. I love that evil-mode is a thing that works as well as it does, I love being able to customize it and script it and M-:.