Editorhopping

Today’s topic will again be about text editing software (one of my favorite topics actually). However, instead of discussing text editors themselves, I’ll share my opinion on such things as editor-hopping.

What is editor-hopping? It’s, well, when you change text editors every day/week/month/year. Not because you have to, as it is required by task or something doesn’t work as intended, but because you’re bored.

To discuss this topic I want to list these questions I’ll ask, and (try to) answer:

• Why this happens?
• How this happens?
• What should I do?
• Is it okay to hop around?

Without further ado, the first question:

Why this happens?

I don’t know.

Seriously, why would I know? Ask scientists or psychologists. Why are you looking at me like that? Next question.

How this happens? Why this might happen?

On a more serious note, I think that most of the time this happens out of boredom. But I’ll get to this a bit later. Sometimes though, you have to hop around when you search for a specific feature, that is not well known. And it is hard to immediately tell which editor has it or has the best implementation.

For example, Parinfer - it’s a niche plugin for Lisp editing. There are a lot of editors that are supported, mainly Atom, Visual Studio Code, Emacs, Vim, Cursive, Sublime Text, and others. But Parinfer is a tricky piece of software, and there are some quirks in implementation, therefore not all versions are equal. For example, parinfer-mode for Emacs, listed among other implementations, has no Smart mode¹, as of this moment. And what exactly is a smart mode? It’s not presented on Parinfer’s web page, and it’s not clear what it does compare to indent or paren modes. To find out you either have to download another editor, which has it, but which one does? Therefore, the search begins, and hopping is kinda required.

But again, this is not exactly what I mean by editor-hopping. Because there’s a difference when you change editors because you need to, or out of curiosity/boredom. Let’s take a look at how someone may become an editor-hopper.

How this happens?

Well, imagine this. You’re a happy Notepad++ user, and someone in a fabulous suit just passed by with the newest Macbook in one hand and a cup of elite coffee in another. But most notable, they were actively writing code in some dark-colored, stylish-looking, colorful text editor. Curious, you jump in front of this person, making they spill their coffee on you, and have this dialogue:

– Excusez-moi, monsieur, what is this bizarre, cool-looking software you’re using for writing another software, that I have never seen?

– Sublime Te..

And immediately you jump back at your laptop, open your favorite web search engine, and type in this newly acquired knowledge. You hit Enter, and you’re presented with a modern, slick website dedicated to demonstrating you key features of this editor.

That’s it, you no longer can stand the look and feel of Notepad++, and you’re installing this new shiny toy on your PC. And it’s great, it’s fast, it’s everything you’ve wanted, and, uh oh… What’s this? Atom? VSCode? Brackets? Nah, Sublime is just fine! Only, there’s a plugin for Atom, that looks interesting… /Nonono, I’ve just switched from Notepad++, why would I change editor again? On the other hand… I’ve not that used to Sublime yet, so it’s not a problem to try another thing or two…

Of course, this is more like a made-up example, although it is still a real scenario. Another possible way is by watching someone doing some weird things with their text editor, and wanting this kind of power. But since you have no skill yet, when you hop in, you quickly find that you can’t really do the same stuff, so you jump back to where you were. But now there’s a chance that you already shifted a bit more towards using another editor, and it will be buzzing in the back of your head until you give up. This can happen several times, thus making you shift more and more in small steps, eventually making you switch. I’ve tried to get into Emacs 5 times :)².

What should I do with editor-hopping-thingy? Is it a bad habit?

This is an interesting question. Well, trying new things is good, it is like a breath of fresh air - you can find facilities you didn’t know you wanted, you can see different approaches to the same tasks you do, and so on.

A friend of mine shoot a video about a similar problem: Is Distrohopping a Dangerous Addiction? This is a common problem of many Linux enthusiasts, and I’m no exception - I was distro-hopping for ~6 years.

But if distro-hopping usually means changing preset environments in search of a perfect setup - most users hop between user-friendly distributions, like Linux Mint, Ubuntu, Fedora, ZorinOS, Pop_OS!. These distributions are more or less the same, and there’s nothing wrong with this. But some hoppers remain unsatisfied and go deeper into more advanced distributions, such as Void, ArchLinux, and Gentoo, which allow more configuration options. And there are two³ possible endings - either you return to one user-friendly distribution, like Fedora, and embrace it, or you shape advanced distribution into something you really like.

Editor-hopping⁴ can start the same - you try out some preconfigured editors, like Atom, Sublime Text, or Visual Studio Code, and go down the rabbit hole to Emacs, Kakoune, Vim, Vis, Ed, Micro, Acme, and all those other weird editors available on GNU/Linux systems for everyone to use. I’ve done a pretty big review of text editors that I’ve used or tried among the years of my Programming career, so I was editor-hopping for some time already.

But there’s a difference between distro-hopping and editor-hopping, that can easily be seen. In his video⁵, Wolfgang mentions that

Tinkering with your computer, and trying out different Linux distros is actually a very cool way to spend your time, and might teach you a lot of useful skills that you can use later for a job if you want to get into a Linux job, for example, DevOps, or SysOps, or Sysadmin.

This can’t really be applied to text editors. Or can it?

Maybe if we’re talking about configuring such editors, like VSCode, or Atom, then I don’t think that it can be really good for you or for your possible job. No offense, but I doubt that anytime soon we’ll see something like TextEditorOps job offers. However, being able to set up complex text editing environments still is a good skill. For example, knowledge of how to configure an IDE can help with the onboarding of a new employee. But I doubt that you’ll get paid for that kind of thing.

However, if we’re talking about more complex editors, like Vim or Emacs, knowing how to extend those means knowing how to write programs. Because both editors are extended via programming in the respective language - Vimscript, or Emacs Lisp. Emacs Lisp can make you better, because it is quite a different language, and Vimscript also can teach you a thing or two. And yes, you can write plugins for VSCode and Atom in some dialect of JavaScript, and this can boost your skills in the same way as writing for Vim or Emacs.

There’s also Kakoune. It is a bit different, as it has no programming language embedded into it, and uses shell scripting as a way of interacting with other tools and user scripts. When I switched from Vim to Kakoune, I didn’t knew awk or Perl, and thanks to Kakoune, I now know awk and Perl to some degree. Kakoune also expanded my knowledge of other command line tools and their parameters. But is it good? Yes. Do I need Perl or awk at work? No. Did it improve my skills? Yes. So, in my opinion, editor-hopping can be useful for your job, but only when you learn new things, and the things you learn to make you better at doing your job.

To hop or not to hop?

You decide, but my word is - go for it. You’ll never know where it will make you end up. I was pretty much a happy C programmer for a long time, but at some point, I discovered Emacs, and now my focus has shifted towards Lisp a lot. And I’ve tried a lot of other editors before that. Now C is no longer my main language, and I write more and more Lisp code. But even if not talking about Lisp, writing editor plugins also ignited my interest in programming a lot, and introduced me to a lot of new and fun tech, such as Kakoune. Of course, editor-hopping should not interfere with other hobbies and cause a loss of time. Too much tinkering with the text editor (or operating system) can be a problem if you notice that this is the only thing you do, and it’s not really making you better, or more productive. It’s good to know when to stop and observe what tools you have, and which one suits your needs best.

My complete editor-hopping history is: Embarcadero Delphi → Code::Blocks → Gedit → Kate → Mousepad → VSCode → Vim → Kakoune → Atom → Emacs.

It was somewhere in 2010, and Embarcadero Delphi wasn’t an editor, but an IDE, though it was the first thing I’ve started with as something I can code in. We used it at the university for doing our computer science classes. After some time we moved from Delphi to C, and the next thing I used was Code::Blocks. Again, it was fine for doing C, but I quickly understood that it is not really versatile, and can’t be comfortable used to take notes, or write prose. So I moved to Gedit, as at the time I was using Ubuntu, and it was shipped with Gedit by default. It was a nice experience, but there was a little number of plugins that I could utilize. Kate has proven that it is a bit better option, as it had many plugins, integrated terminal, snippets, and so on. But I’ve got a new job and Kate there was from the KDE4 era, thus outdated, and a bit buggy. Afraid of losing data, I’ve switched to Mousepad, while at the same moment tinkering with VSCode and remote file access. Unable to set up remote access without constant failures, I’ve embraced remote editing in Vim and used vim for about 4 years since. Until some of my friends, who were mentioning Kakoune every day, actually made me try it out, and I was hooked. I wrote a lot of plugins for Kakoune, and somewhere at this point I started tinkering with Lisps, and thus Emacs, and Atom. Initially, I’ve chosen Atom, as it had this very interesting REPL, but quickly understood that it is not as good as Emacs. And now I’m on Emacs, which I’ve modified to look as close as possible to Atom because I like how it looks.

This was going on for the last ten years, and I don’t regret any moment in this journey. The first two switches were not because of hopping, but still gave me a taste of what different environments can offer. And yes, there was a situation when I saw someone using Sublime Text 2 on their Macbook, and I’ve actually tried it out, but it wasn’t free. Later on, Vim and Kakoune introduced me to some nice people, and we still chat with each other, even though I’m no longer using Vim or Kakoune.

Don’t be scared of change and new things, try, explore, and experiment!