writing an essay in vim

Configuring Vim as a Writing Tool

• Share on Twitter
• Share on Facebook
• Share on Pinterest
• Share on LinkedIn
• Share on WhatsApp
• Share via Email

In my first column I spoke about why I moved my writing to Vim – away from the standard tools of modern writers such as word processors (MS Word and their open source equivalents), text editors (Notepad since I’ve been a Windows user until last year), and cloud based storage technology. If you are a writer, I urge you to read that part 1 before continuing here.

Essentially, I argued that the more devices you use, the more writing tools you’ll need, the more complex the workflow eventually becomes. This is pertinent because I have four devices, including an Android phone, a main daily driver laptop running Linux, and a couple of older laptops, including a Mac, I take when I go outdoors for shoots.

Vim was the perfect solution for me, and how I work; while I won’t argue that my new workflow is the best way for writers to work in the modern world, I will argue that it is important for writers to have a tool that works across all our devices, and is powerful enough to meet the needs for the different kinds of writing that we writers engage in everyday.

Vim’s main benefit from this perspective, therefore, is that it is cross-platform – no matter what device you are on, Vim will work. I won’t speak extensively about using Vim in the Apple ecosystem, but a cursory glance at the reviews for this app tells me that somewhere someone needs Vim no matter what device they are using.

Now let’s say you are a writer who wants to start using Vim. Where do you start once you’ve installed it?

This part of the article isn’t necessarily a tutorial but a series of recommendations, including an examination of a .vimrc configuration file for prose writing. Wherever possible I will link to the respective YouTube tutorial that I learnt from.

Linux users already have Vim pre-installed – launch it via the terminal emulator of choice. For Windows and Mac users, you can download it from the official site .

Recommendations

Post Vim Installation/Launch

• Open Vim Tutor via terminal. (Mac users can launch it this way, while Windows users can launch it using this method. You will not be using Vim to do any writing during this phase – instead you will spend 15 minutes everyday doing the Vim Tutorial. Don’t spend a minute longer or shorter; see how much progress you can make inside the tutorial within the allotted 15 minutes. You will find that every day, you progress that much deeper into the tutorial. Inside a month, you should be able to complete the entire tutorial within those 15 minutes.
• Becoming a better typist has immense benefits for Vim usage. This is optional, but I am relearning to type from scratch and it is having the side effect of making Vim even more useful. I began spending 15 minutes everyday on this site as a warm up before I went into the Vim Tutorial.

I allocated 30 minutes at the start of every day for both these exercises to warm up, and 30 minutes every evening to cool down before I went to bed. This may have contributed to my quick transition from my old tool kit to Vim, but your mileage may vary.

Once again, let me stress that the above steps other than Vim Tutor is optional; it all depends on your individual motivation levels.

We now come to the meat of this article: How do you configure Vim to be writer-friendly?

How to configure .vimrc for writing

Before I begin, I’d like to remind readers here that I am not a tech person – I am a novelist – and that any errors you see in the below are my own; I would love for feedback from experienced Vim users on how to refine my configuration file even further.

Below is my .vimrc file. You can clone mine from my GitHub and refine it further.

Learn how to install Vim Plugin. This tutorial helped me. I use Vim Plugged because it was the simplest and most elegant in my view.

.vimrc housekeeping for writers

• syntax on : this ensures that vim acknowledges what syntax I am using. I primarily use markdown for most note-taking and writing articles such as this one; while plain-text is my preferred method when working on my fiction.
• set noerrorbells : for the sake of your sanity, I highly recommend turning this on
• set textwidth=100 : For ease of reading because no one wants to be horizontal scrolling a text document
• `set spell“
• set wrap : ensures text wraps like how writers, not coders, would want it. You will notice that I haven’t spent much time discussing some of the other basic configuration, but I don’t feel those are salient for writers. I do some hobbyist coding so my .vimrc is a reflection of that. If all you want to do is to write on Vim, then the above configuration ought to get you started.

From that point, your .vimrc is a living document of what you want to do with Vim, and how you want Vim to do that for you.

A note on plug-ins

Plug-ins are specified between lines 43-98. Assuming you’ve followed the tutorial on how to install vim plug-ins, I highly recommend the following vim writing-specific plug-ins to get started:

• vim-LanguageTool
• thesaurus_query.vim
• vim-markdown

In this article, we gently introduced how writers can get started on vim, including a basic primer on configuring .vimrc for writing. In addition to mine, I am going to link here to the .vimrc of other writers that I found on GitHub, and have used as inspiration for my own.

Remember that this is just a starter kit of a .vimrc for writers. As your needs evolve, you will find that Vim can evolve with it. Therefore, learning to configure your .vimrc is worth investing some time in.

In the next article, I will be examining specifics of my writing workflow, using Vim and Git and GitHub.

Contributed by Theena

More from It's FOSS...

• Learn Bash scripting for FREE with this Bash Tutorial series .
• Join our community forum .
• 📩 Stay updated with the latest on Linux and Open Source. Get our weekly Newsletter .

Wow! Windows is Coming up With its Linux Like Sudo Command

6 predictions for linux and open source in 2024, big news gentoo linux is now providing binary packages for quick software installation, so, google wants firefox users to have a poor youtube experience, a good upgrade for developers: qt 6.7 releases with new platform support and improved fonts, nitrux linux distro to drop kde plasma in favor of maui shell, the xz utils backdoor in linux: how it happened, flowblade 2.14 video editor releases with essential refinements.

A Writer’s NeoVim

• 🔥 Transform your Neovim into a full-fledged Integrated Writing Environment (IWE): Write, Edit and World-build at the speed of thought
• 💤 Easily customize and extend your config with lazy.nvim
• 🚀 Stupid fast
• 🧹 Sane default settings and options for writers
• 😻 Eye candy in the form of beautiful color schemes, in dark and light modes, including flavours of Catppuccin, Gruvbox, Nord, NightFox
• 📦 Comes with a wealth of plugins for longform writing, interconnected note-taking (wikis, etc.), and screenwriting. All pre-configured and ready to use

🔎 OVI-WHAT-NOW?

OVIWrite is a NeoVim powered Integrated Writing Environment (IWE) built using LazyVim and 💤 lazy.nvim .

The goal is to make it as easy as possible for writers to start using NeoVim out of the box.

This begs the question: what kind of writer would gravitate towards OVIWrite in the first place? Good question. I spend some time discussing it below.

At first Vim, and now NeoVim, have formed the basis of my dream writing environment. Who even dreams of their writing tools? I have no answers except to say that I do venture outside regularly to touch grass and talk to people - don’t worry.

I wanted a writing tool that ticked these boxes:

• Long form prose (i.e. novels, academic writing, reports, essays)
• Research and note-taking

Screenwriting

• Supported a wide range of plain text standards including Markdown and LaTeX.
• Adaptable to any platform, Unix style OSs (MacOS, Linux) or otherwise (Windows), desktop or mobile, Android or iOS
• Offered the features of traditional word processors (Spell and Grammar checking for instance)
• Offered opinionated quality of life improvements such as Version Control through Git

This is a tall order to ask for word processors. It is why conventional word processing software such as MS Word fails, at least for me.

Granted I wrote my first novel on MS Word, I came to find that it wasn’t extensible enough to scale with my needs, nor was it nimble and fast.

An ideal writing tool should adapt to a writer’s needs at a moment’s notice.

• Get back to working on the novel? Sure, here’s a beautiful LaTeX template for me to work on my novel.
• Write a screenplay? Why not?
• Build an inter-connected network of notes like Obsidian or Notion? Done.

Here are two demos I presented at the NeoVimConf where I presented two early versions of OVIWrite.

• Writing, Editing and World-Building at the Speed of Thought (version 0.1) (Nov 2021)
• Vimkipedia: Or How I Built my Second Brain Using Vim (version 0.2) (Dec 2022)

Essentially, these two talks served as early demos of OVIWrite versions 0.1 and 0.2. However, the eagle-eyed among you will notice I used a combination of Vim and NeoVim during these talks. This was because I couldn’t get some Vim-specific plugins to work with NeoVim, a problem that has since been solved.

This version of OVIWrite is built entirely in Lua, and follows the modular structure of LazyVim.

This is version 0.4 (Dec 11th 2023)

Nomenclature

You will notice that Vim and NeoVim are used interchangeably here. This might appear confusing at first so let’s be clear:

• Vim is a text editor whose roots go back to the early 80s. Its creator was the late Bram Moolenaar . Among its many innovations that have aged well in its four decades is the notion of Modal Editing . Modal editing text editors like Vim change your keyboard functionality based on what mode you are in.
• Vim allows for a number of modes: Normal, Insert, Visual, Command and Replace modes.
• NeoVim is a ‘fork’ of Vim, a modern interpretation of what Vim can be. It’s about a decade old and is maintained by a core group of maintainers, led by Justin M. Keyes . It inherits Vim’s modal-editing philosophy, but has moved to a modern programming language: Lua
• Both Vim and NeoVim have rich eco-systems that extend the editor’s functionality to suit the exact needs of the user.
• These eco-systems are thriving as a result of tireless plugin makers, some of whom have created, and continue to maintain, dozens of plugins
• Most plugins are created for explicit software engineering/programming tasks. A few plugins are created for writing of prose or other text manipulation tasks outside of conventional programming
• OVIWrite is based on NeoVim; specifically it is based on an existing NeoVim starter kit LazyVim
• OVIWrite uses a curated list of writing-centric plugins along with some plugins that are traditionally for software engineering tasks, but whose functionality has application in the work of writers or anyone working with large chunks of text

👨💻 AUDIENCE

I hear you: Who is this for?

Personally, I think of Vim/NeoVim as analogous to a musical instrument, say a piano. Are pianos meant only for world-class pianists? No.

The first interaction with a piano is often messy, confusing and overwhelming; stick with it, and there is a little bit of magic waiting to be experienced.

This mindset has helped immensely in scaling the steep learning curve that comes with Vim’s modal editing philosophy.

But unlike me, writers like you don’t have to invest the additional time in learning how to wrangle Vim to be a tool for writing. All you need is a couple of weeks practicing Vim motions and understanding its different modes.

Once you overcome that hurdle, install OVIWrite and get writing!

I am not a tech person. I don’t know programming or how to read code. This looks overwhelming. Is this for me?

Only you can answer that. I don’t consider myself to be a tech person - tech savvy, yes but I can barely read code myself.

So no lies here: (Neo)Vim motions and modal editing requires a rewiring of our writer brains. But the good news is that it shouldn’t take more than two weeks of 10-15 minutes a day. Vimtutor , built into Vim, is the best place to practice.

There is also some steep knowledge acquisition required to understand NeoVim’s internal nuts and bolts. This is only required if you want Vim to work exactly as you want it to. I did, which is why I set off on this journey three years ago.

OVIWrite offers a higher floor from which to start your own explorations.

You don’t need to know how to program or read Lua code, to use OVIWrite. All that work has been done for you. Nothing is stopping you from peaking behind the curtains at the source code. Add or modify the code as you see fit if you are feeling extra adventurous

More good news: Vim is almost 40 years old. The community has been around for decades, and have extensively documented tips, tricks and hacks. Chances are the error message you are seeing has been seen countless times before by countless people, and in all those occasions there was an experienced Vim user helping out a new-comer. I can speak from experience on this last fact.

Once again, thinking of OVIWrite as akin to a musical instrument might be the best way to overcome its apparent complexity; instead of music, OVIWrite is purpose-built for efficient (and damn near magical) textual recall, creation and manipulation.

Being tech-savvy will make this easier but it is not a requirement.

Being patient is.

Heavy Googling is (as any programmer will tell you).

Rewarding Long-Term Benefits:

I can only offer personal anecdotes here in lieu of a more scientific approach.

I have steadily become very productive in the three years since my first encounter with Vim.

The procrastination associated with writing has disappeared, and I believe part of that is because I don’t have to struggle through the bloated mess that is MSWord.

Editing, too, has become a joy because editing is Vim’s superpower. Combined with the curated plugins included in OVIWrite, you should be writing, editing and world-building at the speed of thought!

The Promise of Plain Text

Most writers writing on word processors use Rich Text. Rich Text, for all its benefits, does come back with significant drawbacks: vendor lock-in being a primary concern. Rich Text also doesn’t age well. Rich text’s older, less glamorous kin, Plain Text ages better, doesn’t lock you into a vendor, and gives you the freedom to choose the tools that are suited for your work. For more, read The Case for Plain Text

Embracing Git For Writing

Git is a robust version control system initially designed for software development, and has emerged as an invaluable asset for my writing workflow. Really, I think it’s damn near criminal that we don’t teach writers Git at some point in their developmental stage. Read more here

• Write, Edit, World-Build at the speed of thought : OVIWrite liberates your writing process by focusing on plain text , freeing you from vendor lock-in for unparalleled flexibility.
• Effortless Collaboration : Built-in version control using LazyGit ensures seamless tracking and collaborative writing experiences
• Versatile Syntax Support : From LaTeX to Markdown and from Org-mode to Fountain, enjoy comprehensive syntax support for every writing endeavor—from reports and essays to screenplays and personal wikis
• Flawless Composition : Spellcheck, thesaurus, and dictionary tools integrated for a seamless writing experience
• Built-in Translator : A built-in translator effortlessly translates between English and a diverse range of languages, breaking down language barriers with ease.

I use OVIWrite for the following use-cases:

• LaTex documents for my novels and academic writing
• Fountain files for writing scripts and screenplays
• Markdown and Org Mode files for writing simpler reports and blogs
• Vim-wiki for my personal Zettelkasten

See screenshots below.

I needed an Integrated Writing Environment, a toolkit that was fast, yet extensible enough to scale with a writer’s changing requirements.

I spent a lot of time writing on diverse IDEs to get a sense of what I wanted out of my IWE; in fact, my inspirations for OVIWrite were VSCode , PyCharm and indeed the many Vim/NeoVim inspired distros like NVChad , LunarVim , and Doom Emacs .

I currently run this version of OVIWrite on my Mac (MacOS Sonoma 14.1.2), Linux (popOS 22.04 on my desktop, and Ubuntu Server 22.04 on my server), and Android 12 (OxygenOS 12.1 on a OnePlus 7T). I don’t have a Windows machine to test at the moment. iPad testing is ongoing. I am fairly confident that OVIWrite will work pretty great on a semi-recent Android tablet (I don’t have an Android tablet to test), as long as Termux is installed.

📺 SCREENSHOTS

Note: The screenshots below show a variety of color schemes at play: Nightfox, DawnFox and NordFox. Also included in the config: Gruvbox and flavours of Catppuccin. I’ve included my favourite color schemes; users are, of course, free to add whatever color scheme that is available in the NeoVim ecosystem.

Long-form Writing

• Longform Writing; LaTeX

• Longform Writing; Org-Mode

• Longform Writing; Markdown

• Screenwriting in Fountain format

Note-taking and Research

• Zettelkasten

INSTALLATION

⚡️ requirements.

• Neovim >= 0.8.0 and its associated dependencies (needs to be built with LuaJIT )
• Git >= 2.19.0 (for partial clones support)
• a Nerd Font (optional but highly recommended)
• LaTeX compiler

Installing OVIWrite

Detailed Installation instructions can be found on our wiki

You can download the zip file containing all the source code. Copy it into the appropriate folder.

Unix Systems (Linux and MacOS)

Keyboard shortcuts.

OVIWrite uses which-key.nvim to help you remember your keymaps. Just press any key like <space> and you’ll see a popup with all possible keymaps starting with <space> .

• default <leader> is <space>

🤝 CAN I CONTRIBUTE?

Please, and thank you.

Contributions are encouraged. Feel free to make a pull request with modifications. If you want to contribute at a deeper level - maybe even forking NeoVim for writing outright - do reach out to me. I will be happy to collaborate and learn from the community.

• @MiragianCycle , Theena Kumaragurunathan
• @mhegreberg , Mark Hegreberg

🎁 ACKNOWLEDGEMENTS

None of this would be possible without the contributions of the entire Vim and NeoVim eco-systems. Please contribute in anyway, financial or otherwise, to these incredible projects and the tireless people who maintain them.

Additional Reading

• Friction: Or How I Learnt to Stop Worrying and Love Vim
• Configuring Vim as a writing tool
• Every year is someone’s year of Linux Desktop
• Using Git Version Control as a writer

Jamie Todd Rubin

Writer, Coder, Avid Reader

Writing with Vim

I am back to writing with Vim again. I have been flip-flopping among writing tools, and finally settled back on Vim. For those who are not familiar with Vim, it is a text editor that has been around forever. It is not for the feint of heart. It can be somewhat difficult to learn, especially if you are not used to a modal tool, or not a fan of keyboard commands.

So then why use it? I’ve given this quite a bit of thought over the last week or so that I’ve been back with it, and there are several reasons I think I will stick with it going forward.

1. Future compatibility

A few months ago, I began to try to collect all of my old writing. My intention was to build an archive of my writing from the time I first started, right through the present, and then keep it going forward. I wanted an easy way to see anything I’d ever written with the intent of paid publication. I started to write with the intent to sell stories in December 1992. Believe it or not, I still have those files 27 years later. I used Microsoft Word 5.5. for DOS back then, and these files are all in that format. The latest version of Microsoft Word can’t read them.

This is an example of a compatibility problem I want to avoid going forward. If my writing is going to be stored digitally, I want it to be in a format that is mostly immune to compatibility issues. Plain text is the answer. Vim is a text editor and allows me to write plain text files. I use Markdown in my plain text to get formatting I want in the output, but the files themselves are nothing more than simple text.

There are many advantages to this, a few of which I will touch on later.

2. Separating content from presentation

WYSIWYG just doesn’t work for me the way I envisioned it would when it first came out. I remember the first version of Microsoft Word that had a what-you-see-is-what-you-get interface. Even earlier, I remember AppleWorks, which also had a WYSIWYG interface. It was very cool to be able to layout the document on the screen to appear exactly as you want it on the page.

As I began to write, however, I quickly learned two things:

• I spent too much time playing around with formatting options, when I should have been writing.
• There are really only a small handful of standard formats that I use on a day-to-day basis.

Scrivener was the first writing tool I used that did a very good job of separating the content form the presentation of a document. In Scrivener, you write content and then compile it into one of many formats. You can move text around easily, and make the screen look however you want it to look, but the presentation–that is, the document that Scrivener compiles–can look completely different from what appears on the screen.

Vim allows me this separation as well. How things look on my screen is completely different from how the document they produce looks, but that is okay, because I still only use a few standard output formats (standard manuscript, letter, etc.). I use Pandoc to compile my Vim markdown into a Word document, or a PDF.

3. Look and feel

I’ve mentioned that my favorite word process of all time was Microsoft Word 5.5 for DOS. Maybe it’s because it was the first word processor I used when I started writing to sell stories, and its look and feel somehow imprinted on me at an impressionable age, but I like the look of white text on that blue screen.I have tried to mimic that look and feel in a variety of text editors and word processors over the years. When I came back to Vim a week ago, I took another focused crack at it–and managed to get as close as I possibly can. The text on the screen looks exactly as I want it to look:

• White text with a blue background.
• Show underlines instead of italics in markup–because underline is how you represent italics in a standard manuscript format, and it stands out better on the screen.
• Not too much else on the screen.

I realize that I can come close to this in other word processors. What I have not been able to do is get the look and feel that I want, while maintaining compatibility, and separating the content from the presentation layer–until now.

4. Change history

I like being able to see the evolution of what I write. Plain text makes it easy to see differences from one version to the next. I use flashbake, which is a tool that automatically checks in what I am working on to git’s revision control system every 15 minutes. Everything I write has an automated history of its construction. I tag certain check-ins, like “first draft”, “second draft”, “submitted draft”, “corrected draft”, “published draft”, etc. I can check out any of these and compare to any other.

I learn from these changes. It is interesting to be able to go back into time and look at things I took out, or left in. It also means nothing is ever wasted or deleted. If I write a scene that I really like, but doesn’t quite work in the story, I can remove it and yet the scene is still retained in git where I can always find it.

Here is a recent example of part of the git change log from a story that I have been working on.

5. One tool for all my writing

Over the years, I’ve found myself using different tools for different types of writing: one for paid writing, another (WordPress) for blogging, another still when writing correspondence. It means having to remember a variety of different key commands (which tend to vary from one tool to the next) as well as differences in the way they function.

I want one tool for all of my writing. I look back to writers in the first half of the twentieth century, doing the bulk of their writing on one typewriter, and using it until the poor machine wore down. Story drafts, letters, essays, everything goes through that one machine. It becomes an extension of the writer. In an effort to simplify, I’d like to be able to use just one tool for all of my writing. Of course, there is writing that I do that won’t get into Vim–mostly email–but there are always exception.

I can do this easily with Vim thanks to Pandoc , which can take my markdown file and convert it to any format I want, using template files. I have a letter template, a standard manuscript template, etc. From the plain text markup, I can produce with a single command, a properly formatted manuscript in Word format, or PDF format. I can do the same for letters, notes, critiques, etc.

6. Searching

With all my files as plain text, searching is much easier. Plus, tools like Vim make it easy to use regular expressions for searching, and I can easily search multiple files at once.

I’ve been using Vim for all of my writing for the last two weeks or so and I’ve gotten more and more comfortable with it. I’m trying hard to stick with Vim’s standard keyboard navigation (instead of the arrow keys) because I think it will make it easier to use with other computers over time. Plus, as I get more familiar with them, I find Vim’s navigation to be a power tool.

And yes, as you can see from the screenshot above, this post was written in Vim.

Share this:

• Writing Posts

14 comments

As with all good Swiss Army knives, there are more addons and extensions than you can shake a stick at with vim. For browsing interests, you might find some useful ideas over at http://www.naperwrimo.org/wiki/index.php?title=Vim_for_Writers

Viva la editor!

Yeah, I’m using a few. I particularly like Goyo for its clutter-free interface.

Hey, I’m a returning reader of your blog (been following you back in the Evernote days). I also used to use Evernote, and then a few other apps until I found Org-mode and Emacs.

What I’m curious about (not sure how much you want to get into it or can in a comment), is why/how did you leave Evernote?

From this post I see what got you to write into Vim and I’d say 80% of what you say here is true for me an Emacs as well. If you’re curious, btw, there are a couple of examples using Emacs for writing, I’m sure some of it applies to vim as well.

Thanks for writing! 🙂

Josh, thanks for reading! I’ve never left Evernote. I never used Evernote for writing. I still use for the same things I’ve always used it for, and it has recently been very helpful as we get our house ready to sell so that we can buy a new one. I stopped writing the Going Paperless posts because I felt I was getting repetitive, and wanted to write about other things. That said, I’ve got a post in the works based on my recent experience using Evernote to manage this whole real estate process. Stay-tuned!

I used to be an Emacs user back in the mid-late-1990s. Did my share of elisp coding. I can’t remember why I ultimately gave it up.

I wrote an article years ago about how I use Markdown & an IDE to write, and a custom ruby app to compile it into PDF or ePUB. I had previously written my first novel in LaTeX and compiled with a simple make file, but it wasn’t very ePUB friendly.

While I liked the Ruby app, I wanted to move more towards CI/CD so that I didn’t have to keep going to the command line (of which I was once a native).

On 12 January 2019, I started full tilt on a Pandoc toolchain leveraging Docker and Circle CI (both being free at my level of usage). The link is below. I need to build out the documentation, and make the template more extensible. But basically, check the book into Github, and about 2 minutes later a compiled copy of what you’ve written is pushed as a release to the GH repository. Not apparent in the current version is that the Markdown files can be in subdirectories (as chapters or stories) and individual files. (I know the date because Git remembers. ;))

https://github.com/Merovex/pandoc-book

The repo has everything necessary to use the CI/CD feature, but without documentation of the setup may be a bit of a PITA to use at first. It has a DOCX version which is good for sending to editors. It doesn’t do MOBI because that conversion can happen at KDP.

As an author (not very active of late), I like one scene per file, and one directory per chapter…though I am moving away from chapters. It runs a straight sort, so Directory & Filenames should be in numerical order (01..99). I need to set this up so that it can compile multiple books at one time, since this is all feeding in to a novella series I am developing.

I’ve been working a side project where I’ve been applying Pandoc Book, and have made quite a few enhancements that I’ve not yet brought back to Pandoc Book. I was planning tonight to clean it up a bit more (family’s out-of-town). So, check it out and let me know if it is interesting. I’d like to make it useful for like-minded authors, so any suggestions, defects, enhancements suggested will be seriously considered.

I use Atom for my IDE, which has some nice plugins for Markdown, and a Git plugin that lets me do the code check-in and push from the IDE.

As for Vim, I’ve found myself dropping to my old favorite from time to time; when I have short things to write up or need to bulk edit. It’s like a familiar friend I’ve not seen in a while. The state-of-the-art with Vim has progressed considerably, so I might give it another look. But, I like the speed I get with Atom.

If you guys have recommended plugins for someone who’s not been on VIM since…2007…I would appreciate the advice.

I enjoyed reading about your use of VIM and especially about using MS Word for DOS. My first job out of University was support Word for DOS. It really was a great program. Thanks Jamie and take care!

Hi there Jamie

I used Microsoft Word 5.5. for DOS back then, and these files are all in that format. The latest version of Microsoft Word can’t read them.

You may want to try using LibreOffice to open those old docs so you can reformat them for further preservation. It looks like LibreOffice may well open those docs:

Thanks, Paul. I was able to get at them with a text editor, and pull out what I needed from most of them, but it took a little work.

It looks like my Markdown image link didn’t work there. Here’s a screenshot of supported file types: https://cld.wthms.co/zjkjPF

only one problem… VIM on the phone/mobile?

Not a problem for me for two reasons: (1) I don’t write or code on my mobile device, and (2) because I was curious, I did find a version of vim (iVim on the App Store) that works great on my iPhone and iPad. So if I did write on these devices, I’d have a tool.

I agree on the “faint of heart”-ness of Vim. I made the transition from Notepad to Vim in ’00 (VI, actually) when I started my first professional developer gig. My team lead handed me the nutshell book and told me she’d break my knuckles if she saw Notepad opened again.

The learning curve is reduced when you’re already a touch-typist, which I am.

I love Vim, though I only find myself using it every few weeks…usually when I have to edit a configuration file. It’s funny that even though I use Atom IDE for day-to-day writing…and could easily edit the config files that way, I drop into Vim for config files. I’m rusty as hell, but can still do 80% of the commands I used to by feel.

I’d be hard pressed to use Vim on a phone. The touch interface and key placement sort of trumps the value of Vim’s keyboard-friendly navigation. Nano or Pico might be better options…I can’t remember which one (or both) retains the edit/maneuver nature of Vim.

If you want to do Vim on a mobile device such as a smartphone or tablet it can be done providing you are online. All you really need is a ssh terminal app, a cloud hosted Linux instance and you can use ssh, blink, tmux, etc. Highly recommend a bluetooth keyboard or an iPad w/keyboard Air or Pro model. Using a cloud based Linux shell means you can connect and disconnect with tmux and pick up right where you left off, you can run multiple tmux sessions for different purposes or projects and have your workflow windows and panes organized for each project. There are ways to preserve these sessions between reboots of the server as well.

Also be sure to checkout the latest Neovim which has a built-in Lua JIT and you can use Lua based configuration files and Lua based plugins. The latest cutting edge Lua plugins are ridiculously fast. Many times faster than Vimscript plugins. Treesitter is a tree parser model and it can be used to color syntax highlight much faster. Support for advanced language autocompletion with built-in Lsp. A new Telescope plugin for advanced fuzzy find that is wicked fast. Yes you can do most of this in ViM but Neovim is seriously upping the bar lately. There’s also a lot of videos and tutorials to get all this working. Checkout Lunarvim’s GitHub repo and see the Neovim from scratch course. You can either use Lunarvim (opinionated sensible config) or build your own by going through the excellent Neovim from scratch tutorial. Lunarvim is worth trying, it keeps itself apart from your Vim / Neovim configs and you execute lvim instead of vim or vim to run it.

Comments Cancel reply

This site uses Akismet to reduce spam. Learn how your comment data is processed .

Subscribe by email

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Email Address

Follow the blog

Site Policies

• Guest Posts, Collaboration, Link Sharing

Discover more from Jamie Todd Rubin

Subscribe now to keep reading and get access to the full archive.

Type your email…

Continue reading

How to Use Vim – Tutorial for Beginners

Vim is one of the most popular text editors among Linux users. Linux System Administrators especially often prefer it to other editors.

In this article, you'll learn a lot about Vim and see how you can quickly start using Vim as a developer.

What is Vim?

Vim is an acronym for Vi IM proved. It is a free and open-source cross-platform text editor. It was first released by Bram Moolenaar in 1991 for UNIX variants.

Vim is based on the original Vi editor, which was created by Bill Joy in 1976. In the 90’s, it started becoming clear that Vi was lacking in some features when compared with the Emacs editor. So Bram implemented many missing features and released it under the name Vim.

How to Install Vim

Vim runs across various platforms such as Windows, Linux, and Mac.

To install Vim on Windows, download the executable file from the Vim site and run the file. Follow the instructions shown on the screen and you'll be good to go.

Vim comes pre-installed on most *nix operating systems. But if it's not installed on your system, you can install it with a package manager of your choice.

Here's the installation command for Debian-based operating systems:

To ensure that it's installed properly, run which vim and you should get /usr/bin/vim in your output.

How to Get Started with Vim

You can get started with Vim by typing its name on the terminal like this:

Once you enter the above command, you'll be able to see a screen displaying info about Vim and some instruction to find help and exit Vim.

You should be aware of the most important concept in Vim before moving on: modes in Vim.

Everything in Vim is considered a mode. You can achieve whatever you want if you understand modes in Vim. There are many modes in Vim. But, we'll be looking at the 4 most important modes.

• Command Mode
• Command-Line Mode
• Insert Mode
• Visual Mode

Let's explore them one by one.

What is Command Mode?

This is the default mode (also called Normal mode) in Vim. Whenever Vim starts, you'll be in this mode. You can switch to any mode from this mode. You can't do this in any other modes.

Basically, to switch from one mode to another, you have to come to Command Mode first and then navigate to the other mode. The commands that you run without any prefix (colon) indicate that you're running the command in command mode.

What is Insert Mode?

This mode is used to edit the contents of the file. You can switch to insert mode by pressing i from command mode. You can use the Esc key to switch back to command mode.

What is Command Line Mode?

You can use this mode to play around with some commands. But the commands in this mode are prefixed with a colon (:). You can switch to this mode by pressing : (colon) in command mode.

What is Visual Mode?

You use this mode to visually select some text and run commands over that section of code. You can switch to this mode by pressing v from the command mode.

The above 4 modes are enough to perform a basic set of file operations in Vim.

Ok the theory is done. Let's explore Vim practically.

Common Text Editor Operations in Vim

How to create a new file.

Creating a new file with Vim is simple. You can do it from command line mode.

Run the following command to create a new file:

The above command opens a sample.txt file in edit mode if it exists, and creates a new file otherwise.

After running that command, you'll be in command mode (as shown in the below screenshot), and you'll not be able to enter any text:

To add some text to the created file, press i in the keyboard. You use the i command to enter some text in the file. Once you press i , you'll be able to see that you entered Insert mode in Vim by looking at the bottom left of the file.

In this mode, you can type whatever you want into the file.

We're done with writing our content. And now we'll want to save the file. If you do not save and just close the terminal at this point, all your content will be lost.

How to Save a File

To save a file, you have to switch from Insert mode to Command Line mode. Remember I told you earlier – whenever you want to switch from one mode to another, you have to first switch to Command mode and then you can easily switch to whatever mode you want.

To switch to Command mode from Insert mode, you have to press the Esc key.

After you press the Esc key, you'll not be able to see the --INSERT-- at the bottom left. This indicates that you're not in Insert mode anymore and you're now in Command mode.

To save the file, type the following command:

How to Close a File and Exit Vim

Once you save the file, you can close Vim by closing the terminal. But, the proper way to close the file and the Vim editor is by using the following command:

The above command closes the file and quits the vim editor.

Alternatively, you can use a command that's the combination of the above 2 commands (save & quit) to quickly save and quit Vim. The command is:

The above command quits the Vim editor immediately after saving the file.

How to Edit a File in Vim

To edit a file, you have to open the file using Vim and switch to Insert mode.

Let's open the sample.txt file we created above:

We are in Command mode now. To edit the file, we have to switch to Insert mode. As we saw earlier, pressing i from the Command mode will switch to Insert mode.

Follow the same procedure for saving the file and quitting Vim. Press Esc on the keyboard and type :w to save the file and :q to quit Vim.

You may wonder, though, what if I want to close the file without saving my changes? (Ignore the changes I made and bring the file back to the old state).

How to close the file without saving the changes

To close the file without saving the changes, you have to run :q! from Command mode.

Let's explore this with an example:

I've added some more content to the file.

But, I don't want to save the changes I made now. To close the file without saving this change, we have to switch to Command mode (by pressing the Esc key). Type :q! in the Command mode. This will close the file ignoring the changes made.

Let's view the file and confirm if we get the expected output:

Yeah. The file does not have the last line which we added recently. So, the changes were not saved.

How to Cut, Copy, and Paste Text from a File using Vim

You can Cut, Copy, and Paste in 2 ways in Vim. They are:

• Using Visual mode
• Using keyboard

Out of these two ways, Visual mode is simpler to understand. Since this is a beginner-friendly guide, let's explore how to cut, copy, and paste in Visual mode.

Let's open the file in command mode before we proceed:

Let's assume you want to copy the word "Hello" from the 1st line and paste it into the 3rd line.

The first step is to place your cursor in the place from where you want to copy the text (being in command mode).

Enter Visual mode by pressing the v key on the keyboard.

The -- VISUAL –- text at the bottom left indicates that we're in visual mode.

Move the cursor to the place where the text you want to copy ends.

In this case, I'm moving the cursor to the letter o of the word Hello .

While you move your cursor, Visual mode highlights the text from the beginning up to your cursor.

Once you're done moving your cursor to the right place, hit y to copy the text or hit d to cut the text.

In this case, I'm copying the text. So, I press y on my keyboard.

Move the cursor to the place where you want to paste the text.

In our case, we have to move the cursor to the 3rd line.

Press p (in lowercase) to paste the text after the cursor and P (in uppercase) to paste the text before the cursor.

Press :wq to save and close the file

How to Find and Replace Text in Vim

Finding text and replacing it with some other text is simple and straightforward in Vim. There's a one-line command that simplifies this entire process.

Here's the syntax:

Let's dismantle each part and understand how it all works.

• [range] indicates that you can pass the range of lines. Pass % to find and replace in all lines. The range is separated by a comma. To find and replace between lines 5 to 10, pass 5,10. Use . to represent the current line and $ the last line of the file.
• {pattern} indicates the pattern to find the text. You can pass regex patterns here.
• {string} is the string to replace in the found text.  
• [flags] indicates if you wish to pass any additional flags (for example, the flag c is passed to confirm before replacing the text). By default, this does a case-sensitive search. You can change it to do a case-insensitive search by passing a i flag.

Alright, let's explore this with an example.

Our sample.txt file has 2 "Hello"s. Let's replace "Hello" with "Hi" at both places.

The command to do that is:

• %s indicates replacing the content in the entire file
• Hello is the search text
• Hi is the text to replace
• g indicates making the change globally

Let's understand this with another example.

This time, I want to change the word "Hi" (case-insensitive search) that occurs between lines 2 and 3 and replace it with "Hello and Welcome", with a confirmation to change each occurrence.

Here's a description for each option:

• y - Replace the match
• n - Skip the match
• a - Substitutes the match and all remaining occurrences of the match
• q or Esc - Quit substitution
• l - Replace the match and quit
• CTRL+Y - Scroll the screen down
• CTRL+E - Scroll the screen up

I want to accept the change. So, I press y . Here's the output after pressing y .

Since we have only one occurrence of "Hi" between lines 2 and 3, it did not ask for any further confirmation and the operation is complete.

How to Undo or Redo in Vim

To undo a change in Vim, press u in command mode. To redo, press CTRL + R . You can prepend a number (n) with u to undo n times. for example, 2u will undo 2 times. To list the available undo options, type :undolist in command mode.

Let's understand this with an example.

Here's the current state of our sample.txt file:

I have my cursor at "a" in the "Hello and Welcome" text on 3rd line. Let's remove the word "and" by typing dw on command mode:

Let's undo to bring the word "and" back into the file. To do so, press u in command mode.

Let's redo and take away the word "and" by typing CTRL + R in command mode.

In this article, you have learned the basics of Vim. This article should be enough to get you going and do some basic file read/write operations with Vim.

Just keep in mind that I've not even covered 1% of Vim. But I'm sure these basics will help you explore Vim quickly and confidently.

To learn more about Vim, subscribe to my email newsletter at my site and follow me on social media.

Project Manager by Profession. Software Developer by Passion. Curious to explore technologies. Live in Chennai

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

• Articles Automation Career Cloud Containers Kubernetes Linux Programming Security

Linux basics: A beginner's guide to text editing with vim

%t min read | by Tyler Carrigan (Editorial Team, Red Hat)

Image by Andrew Martin from https://pixabay.com

Vim is a text editor I can identify with: Vim and I are both 90's babies, and we prefer to work smarter, not harder. There are a multitude of reasons to learn vim , from its simple navigation tools to its quick and dirty character correction. Here is a crash course in an outstanding tool that every sysadmin should learn. 

[ Download now: Vim cheat sheet ]

What is Vim? 

Vim's common modes.

The Vim editor has three modes that determine how the editor functions: Normal (or Command), Insert, and GUI.

[ Looking for a different text editor? Download the  Emacs cheat sheet . ]

Normal mode

Normal mode allows you to give commands to the editor. Functions such as the following can be found here:

• :w to write/save.
• :q to quit.
• :w <filename.txt> to name a new file.
• :q!  to quit without saving the changes to the file

Press the Esc key to start the Normal mode and enter  :(desired command) [Enter]  to perform your intended task. For example, if I was working in a new file and wanted to name it 'file.txt', I would use the following: 

:w file.txt [ENTER]

Insert mode

If you have made it this far, you probably know what the Insert mode does. However, for those who don't, if you press the I key (lowercase  i ) once you will see the "INSERT" prompt at the bottom of the screen, indicating that you can now edit or add text.

To exit this mode and return to Normal mode, press the Esc key once. 

GUI mode is only available in some environments. It offers a graphical, point-and-click interface to be utilized with a mouse and keyboard. 

Vim tips and tricks

Now, imagine Vim being that shady guy on the corner in a trenchcoat selling faux Rolex watches from inside his lapel, only instead of knockoff watches, VIM has tricks and shortcuts on offer. Seriously, there are too many to list in this article, but I will list some of my favorites here: 

• dd  removes all text from the current line (deleting the full line) and saves the removed text to the clipboard. 
• p pastes (puts) anything from the Vim clipboard to the current cursor, and pairs nicely with the full line delete shortcut above. 
• r  replaces a character and is great for a quick correction.

Using r is a bit more complicated than the others:

• Press Esc to enter Normal mode.
• Move the cursor onto the character you wish to correct.
• Type r  followed by the character that you wish to use. 

For example, "Goodbee" can be edited to "Goodbye" by highlighting the first "e" and then entering ry . 

[ Get more out of your text editor:  5 Vim features for power users . ]

Where to start

I encourage you to give these tricks a try. There is no better way to learn than creating a text file and then making random edits.

Actually, that may not be true, which brings me to the absolute best way that I have found to learn Vim. I learn best with a bit of direction, so it's no surprise that a tutor is just what I needed. Vim has a built-in tutor that can be accessed by entering vimtutor  in the terminal. This tutor will give you lessons on specific topics, starting from beginner to advanced. I highly recommend this tool for first-timers.

If you're someone who enjoys having fun with technology, check out the free Vim-based adventure game Vim-Adventures . This game is a great way to learn a new skill while also enjoying some old-school gaming eye candy. 

This article is only a small tease of what Vim actually has on offer. Once you are more comfortable with the things we have talked about here, I encourage you to look into "operators and motions" as well as dotfiles for customizing your Vim experience. If you are looking for further info on text editors, check out our other text editor articles .

Tyler Carrigan

Tyler is the Sr. Community Manager at Enable Sysadmin, a submarine veteran, and an all-round tech enthusiast! He was first introduced to Red Hat in 2012 by way of a Red Hat Enterprise Linux-based combat system inside the USS Georgia Missile Control Center. More about me

Try Red Hat Enterprise Linux

Download it at no charge from the red hat developer program., related content.

Getting Started With Vim - A Practical Guide

So you want to use Vim full time do ya? It’s not going to be easy, but I believe the choice is worth it. I made the switch from VSCode to Vim a few weeks ago . I’ve been diving deep and learning a ton, and I still feel like I’ve only scratched the surface. To be honest, I don’t even feel qualified to write this post. But my recent efforts have to count for something, right ?

Vim presents you with a thousand roads to wander. There is no shortage of configuration options, plugins and unfamiliar syntax, leaving newbies like us lost and paralyzed with decision fatigue. If this is how you feel, you’re not alone. But I urge you to push through.

Vim can be an incredibly powerful tool in your arsenal. When you have it tuned to your liking, it's an absolute joy to use. This post is aimed at guiding you through the difficult bits so you can get to the joyful bits as fast as possible. I will go through everything I know so far, helping you go from 0 to 1.

We will create a strong foundation that you can build on over time. One that gets out of your way and allows you to produce your best work. So grab a coffee (maybe 2) and get your mind right. We will dine in the gates of Vim this day!

Table of contents

• General Settings
• Manage plugins with vim-plug
• Pick a color scheme
• Search with telescope
• Better status lines with lightline
• Git integration with vim-fugitive
• gitsigns for git decorations
• Using lspconfig
• Language servers
• Autcompletion with nvim-cmp
• Tips and Tricks

Instead of using good ole’ Vim, the one that comes preinstalled on your MacOS or Linux machine (sorry Windows users), we will opt to use Neovim . If you’re unfamiliar, Neovim “is not a rewrite but a continuation and extension of Vim” . There isn’t much difference between Vim and Neovim from a user’s perspective. However, Neovim is optimized out-of-the-box and has an active development team that is pushing the tool to greater heights quickly.

Installation

First, you’ll need to install Neovim on your machine. There are many ways to do this . I use MacOS and opted for Homebrew:

Once the install is complete, you can test that it’s working by using the following command in your terminal:

Vim uses a .vimrc file to hold your configuration settings, but Neovim is a little different. It uses an init.vim file located at the path:

The ~/ represents your home directory. You might already have a ~/.config directory, as it is common amongst other tools. Whatever your situation, you will want to create an init.vim file at the path above.

In this file, you can define general settings, plugins, color schemes, keybindings (called remaps) and more.

General settings

Now that your config file is created, let’s open it up:

The file will be empty. Let’s add some basic settings:

I’ve collected these settings from community suggestions and others' dotfiles. I believe they are a great base without being too opinionated. Comments have been added for each setting to give some insight as to what they do. If you want more information on each, you can type :h <setting-name> inside Neovim to bring up the help manual for that specific setting. For example:

Will bring up the help section for the incsearch option.

If you have suggestions on other settings to include, let me know on Twitter !

Now that we have some basic settings out of the way, let’s get to the fun part. Plugins! In Vim, plugins are scripts that operate in a global scope or per filetype. Authoring these plugins is done in Vimscript . I’ve never worked with Vimscript, but I’ve heard it’s tricky, and a barrier to entry for developers who want to build plugins or contribute to Vim’s core.

Neovim’s vision is to :

• Enable new contributors
• Remove barriers to entry
• Unblock plugin authors
• Deliver a first-class scripting alternative to Vimscript

This alternative scripting language is Lua . Neovim still supports Vimscript, but the core development team encourages plugin authors to write plugins in Lua. I’ve only been exposed to the language for a few weeks, but it is relatively simple to understand. Here are a few resources if you’d like to learn more:

• nanotee/nvim-lua-guide
• Learn X in Y Minutes, Where X = Lua

You will need to use Neovim for a little bit before you can understand where your pain points are. For this reason, I’m going to keep my list of plugin recommendations short. I will only recommend plugins that I feel are “blue chips” in the Neovim community.

That being said, both Vim and Neovim make it easy to pop plugins into your configuration and try them out for an hour or two. If you like them you can stick, but you don’t have to marry anything.

In order to install plugins we need a plugin manager. Enter vim-plug . There are other options that I have my eye on (looking at you packer.nvim ), but for now we will use vim-plug . It has 25k stars on GitHub, so I think we’re in good hands.

To install it you can checkout the docs in the GitHub repository . Once installed, we’ll add a few lines to our init.vim :

We call plug#begin() , passing in the directory where we want to install our plugins, and plug#end() , which signifies the end of our plugin declarations.

But we haven’t declared any…yet!

A color scheme

Most colors schemes in Neovim can be installed as a plugin. A color scheme is 100% preference, and there are a lot of really good ones. Here’s a list of some of my favorites:

Inside of plug#begin() and plug#end() , let’s declare our color scheme. I will use Gruvbox to illustrate:

The above example illustrates how to declare plugins you wish to install with vim-plug . It is shorthand notation for:

You can see more examples of declaring plugins with vim-plug here .

Once you declare your plugin in init.vim , you need to take a few more steps to install it:

• Save your init.vim with :w
• Source your init.vim with :so %
• Run :PlugInstall

The commands above need to be entered in NORMAL mode. See here for an explanation on Vim’s “modes” .

Step one saves your init.vim file without closing it.

Step two “sources” your init.vim . The command is shorthand for :source CURRENT_FILEPATH .

Step three calls a global function named PlugInstall which is made available to you by vim-plug . It will open a vertical buffer to the left of your init.vim . In this buffer you will be able to see a list of all the plugins you’ve installed along with the most recent installation’s progress. Once the plugin has finished installing, you can close the vim-plug buffer by typing :q! .

After installing your color scheme, we’ll need to tell Neovim to use it. Inside of your init.vim and below your plugin declarations, add the following lines of code:

If you aren’t using gruvbox then make sure to refer to your color scheme’s documentation for clear instructions on how to declare it.

Save and exit with :wq . Next time you reopen Neovim you should see a crisp new paint job!

The first function-focused plugin on the list is Telescope , created by one of Neovim’s core team members - TJ Devries .

Side note, TJ puts out a lot of Neovim-related content on his YouTube channel and his Twitch streams . His YouTube channel in particular has been a great resource. Check him out!

Telescope is a must-have plugin in my opinion. It is a fuzzy finder built in Lua that can be configured every which way. It adds a ton of functionality to your Neovim setup. I haven’t realized its true potential so far, but for finding files and searching for text it’s amazing.

Let’s install it:

Note that we are installing more than one plugin here. Telescope requires another plugin named plenary to function. And the other plugin is a Telescope Sorter that supports fzf syntax. Telescope recommends installing it for performance improvements . We like the gains, so we’ll take the gains.

Make sure to perform these three steps to complete installation:

• Save init.vim with :w
• Source init.vim with :so %
• Install the plugins with :PlugInstall .

Next we need to configure Telescope. This is a common practice amongst Vim plugins, and in my opinion the most challenging aspect of Vim. If you’re working with a Vimscript-based plugin it can be even more so. This is why I’ve tried to stick to Lua-based plugins when possible.

Telescope happens to be a Lua-based plugin, which is awesome! Since it’s the first plugin on the list, we’ll need to do some basic setup.

First, we will need to create a new directory in ~/.config/nvim named lua :

Inside of the lua directory we want to create a subdirectory to namespace our plugin configurations. To understand why this is necessary requires explaining how Vim handles file lookup. In short, creating a namespace subdirectory inside the lua directory prevents unwanted filename collisions .

I’ve opted to use my GitHub handle as the name of my subdirectory:

You can make it whatever you like. It really doesn’t matter. Once you’ve created it, you’ll want to cd into it:

YOUR_NAMESPACE is being used as a placeholder. Replace it with the name of your namespace directory.

In your namespace directory you will create a .lua file for every plugin you want/need to configure. Telescope is the first one:

A helpful Vim tip is that you can open files before they exist. If you close the file without saving it, it won’t be created! In the example above, we open telescope.lua in Neovim. As long as we save the file it will be created.

Our configuration for Telescope will be short and sweet:

The above example gives us our first taste of Lua. See? Not that intimidating! I’ve found that, at a minimum, a lot of plugins need:

I won’t be diving deep into Telescope configuration in this post. If you want to see some of the available setup options and other customizations, check the docs .

Make sure to save telescope.lua and exit Neovim with :wq .

Next, we need to tell our init.vim that it exists:

In my case I would put:

A couple of notes:

• Put this command below the vim-plug functions!
• You don’t need to specify the .lua filetype

What does this do? It seems a little magical at first, and understanding requires Vim lookup knowledge, but essentially this command will look for a lua folder in your Vim runtime, and source the specific .lua file based on the path. So in this example the following file will be sourced:

This is great! But we can certainly improve on it.

Instead of requiring each configuration file in our init.vim , we can just require the namespace directory. In order for this to work, we’ll need to add a new file to our namespace directory called init.lua :

The init.lua file can be thought of as an index file, similar to index.js for you JavaScript friends. Inside init.lua we can require all of our configuration files:

Now, inside of our init.vim all we need to do is require the namespace:

In my case it would be:

From this point on, any new configuration files in lua/YOUR_NAMESPACE can be required within lua/YOUR_NAMESPACE/init.lua and they will be sourced in your init.vim !

Ok, back to Telescope.

Telescope exposes a number of commands that can be accessed using :Telescope in NORMAL mode. A quick way to see all of the available commands is to enter :Telescope followed by a space, and then hit <Tab> . The tab button will open an autocomplete list full of available Telescope commands. You can navigate the list using <Tab> and <Shift-Tab> to go backwards.

Below are a list of Telescope commands that I have found extremely useful thus far:

:Telescope find_files

This command will search your current directory for filenames matching your query. It will not show hidden files by default, and it will also ignore files in .ignore files like .gitignore .

This command will also try to identify if you are in a larger project using special directories like .git . This gives you access to subdirectories and parent directories if you have moved away from the project root.

:Telescope buffers

• Search for files that have been opened in a buffer in your current Neovim instance. Really helpful when you are working on a few files at a time, and you want to “narrow your world”.

:Telescope live_grep

• Similar to find_files , but searches for a string match rather than a file name. Note, this command will only work if you have ripgrep installed . ripgrep is a command-line search utility that makes searching for text really fast. It can be installed like any other command-line tool, and Telescope will use it for its live_grep command.

The commands above are just a few I’ve been leaning on lately, and there's many more. Another helpful tip is to think about mapping the commands above to a keybinding. For instance, I have the find_files command mapped to <Ctrl-p> .

You can view documentation on Telescope within Neovim using:

Lightline is a status line plugin for Vim. The status line exists at the bottom of your Vim window, and exposes a few helpful pieces of information, such as the current MODE (normal, insert, visual, etc.), and what type of file you are in.

I enjoy developer tools that do a small list of things well without trying to support every use case under the sun. Lightline fits that mold. It is relatively “light” in configuration options when compared to other popular alternatives like vim-airline .

To install Lightline, let’s open up our init.vim again:

Remember, each time you declare a new plugin you have to take 3 steps to get it installed:

We will preemptively create a configuration file for Lightline now, because shortly we will install a plugin that integrates with the status line in a unique way.

In our namespace directory, let’s create a lightline.lua file:

Inside the file, we’ll add a placeholder config object:

The config above looks different from that of Telescope’s. The reason for this is that Lightline is not written in Lua, and so to hook into its configuration requires using the Vim namespace within the Lua standard library:

Neovim exposes a global vim variable which serves as an entry point to interact with its APIs from Lua. It provides users with an extended “standard library” of functions as well as various sub-modules.

vim.g is a meta-accessor that lets you interact with Vim’s global variable. The config above sets a new global variable named lightline to an empty object.

Go ahead and save your lightline.lua file before sourcing it within your namespace directory’s init.lua file:

My init.lua currently reads:

Save init.lua with :w and source it with :so % .

One last thing we want to do is hide the Vim Mode text at the bottom left of our window. This is no longer necessary since Lightline is showing us the mode too.

In your init.vim file, append the following setting to your General Settings:

Excellent! That wraps up the Lightline section for now. If you want to view documentation on Lightline in the future, you can do so within Neovim using:

vim-fugitive

If ever there was a “blue chip” plugin in the Vim ecosystem, vim-fugitive would probably be it:

A Git wrapper so awesome, it should be illegal.

It has taken some getting used to, but the integrations provided by vim-fugitive are powerful. Let’s install it. You know the drill by now:

There’s no configuration required for this plugin. Just save, source, install and you’re off to the races.

I have a very familiar workflow with Git via the command line. Trying to re-train my brain to utilize vim-fugitive is going to take some time. You might be in a similar boat, so let me give you some helpful tips.

This is the “crown jewel” (straight from the Docs!) of vim-fugitive . As you may have come to recognize with these types of commands, you can use <Tab> autocomplete to see what else it can do:

And there is a lot you can do! In fact, it’s a little overwhelming, but if you’re familiar with Git, then you will find vim-fugitive is pretty intuitive:

Entering :Git with no command will bring up the fugitive-summary window . I actually like this feature a lot. You will see a list of untracked, staged and unstaged files along with the current branch name. Placing your cursor over these files will let you run certain “maps” like staging/unstaging, discarding changes, toggling inline diffs etc.

For more info on what maps are available within the fugitive-summary window, enter:

Or check out this link .

vim-fugitive can integrate with Lightline to display the current working branch. Let’s set that up. In our placeholder lightline.lua file from before, let’s add some configuration:

There’s a lot going on here, but know that this comes straight out of Lightline’s README in the Advanced Configuration section. In short, we define a component named gitbranch and set it equal to fugitive#head , and then add the component to the left side of the status line.

Save and source the file. If you are working in a git project (pssst. you should! ) , you will see the branch name on the bottom left!

For more information on vim-fugitive enter the following command in Neovim:

One thing I sorely miss from VSCode is the ability to view new, modified and deleted lines in a git project. Neovim doesn’t support this by default, so we’ll use gitsigns :

Super fast git decorations implemented purely in lua/teal.

Yes please.

gitsigns requires nvim-lua/plenary.nvim as well. Since we’ve installed this with Telescope (see above), we’re covered.

You know what to do - Save, source and :PlugInstall .

Gitsigns requires calling a setup function in your configuration for it to work. Let’s create a gitsigns.lua file in our namespaced directory:

And inside of this file we’ll get things started:

Passing no options will init the plugin using the default settings, which can be found here .

Now let’s add gitsigns.lua to our namespace directory’s init.lua file:

Mine looks like this:

Source this file and you’re good to go! You can see gitsigns in action by navigating to a project on your machine that is version controlled with git. Any tracked file that has been modified will display that modification with a colored pipe on the left hand side of Vim.

Although this is technically what we want, the placing of the sign is a little off. This is because we need to tell Vim to show diagnostics signs in the number column, rather than to the left of the number. Open up your init.vim file and add a new set option to your general settings:

Save and source your init.vim file and view the changes. Now your signs should be displayed in the number column, rather than to the left. To learn more about the signcolumn option, run the following command in Neovim:

Git signs also supports a Git blame feature very similar to VSCode, and it’s a feature I desperately miss. When you are in a project that uses Git, keeping your cursor over a line for a certain period of time will cause some virtual text to display in a dim color. The text will read the name of the developer that last modified the line, the modification date and the commit message.

I love this feature, but it’s not a requirement. vim-fugitive has a :Git blame command that solves the same use case, but I prefer the virtual text. To enable it, simply add the following to your Git signs configuration:

And that’s it! Saving and sourcing the file will result in some inline Git blame goodness.

Language support

At this point we have some general settings applied that make Neovim easier to work with. We have some plugins installed that improve our productivity. But we still haven’t done anything about language support.

In text editors like VSCode, this isn’t a huge concern. Some languages like JavaScript and HTML are supported out of the box. Others, like Python and C++, have dedicated extensions that make your life a lot easier. These extensions provide Intellisense , code completion, formatting, linting and more.

Extensions like this are possible because VSCode supports the Language Server Protocol , a Microsoft-created standard for defining communications between language tooling and text editors.

Before the Language Server Protocol (LSP), language tools and text editors had no uniform way of talking with each other. Each language tool needed a separate implementation for each editor, and each editor needed to adapt to each tool.

LSP provides a reliable standard so language tools can be built once, and editors that support LSP will be able to utilize them.

Neovim supports LSP natively as of v0.5.0 , meaning we can get the same benefits VSCode provides, albeit with a “little” configuration.

There is a second option to Neovim’s native LSP called coc.nvim . It has been around for a while and a lot of people use it with success. I showed up to the Neovim party around the time that native LSP became a thing, so I never really tried coc . I’ve heard that it is much easier to configure, but comes with significant features that you may or may not need.

I like the idea of opting for the native solution when possible, and even though it can be a pain to configure at the moment, the fact that the core team is supporting LSP means that in the future things should improve. For this reason, we’ll opt for native LSP, but feel free to check out coc if things get dicey.

In order for the rest of this section to work for you, make sure you are on v.0.5.0 of Neovim or above.

To get started with Neovim’s native LSP, we need to install a few plugins. The first is nvim-lspconfig . Per the README, this plugin:

Handles automatically launching and initializing language servers that are installed on your system.

We can install it the same we install any other plugin in our init.vim file:

Remember to save, source and :PlugInstall !

Install a language server

The next step is installing the necessary language server(s) for your development environment. This is equivalent to installing a VSCode language extension. Neovim lists available language servers here . Find one that supports your language of choice, and install it on your machine .

For example, I work with Typescript every day, so I need to install a Typescript language server. The list of available servers tells me that I should install tsserver . It can be installed via npm globally like so:

A few things to note here:

• You are not installing the language server as a Neovim plugin. You are installing the server as a global package on your computer.
• Not all language servers are installed the same. tsserver can be installed via npm , but others may require different installation methods.
• Always refer to the list of available language servers to find the one you need. If installation instructions are not provided, look at the server’s official README .

Configure the language server

After you have successfully installed your language server(s), it’s time to tell Neovim about them. This is going to be the most challenging aspect of setting up native LSP. I am still trying to understand all the moving parts!

Let’s create a new .lua file in our namespace directory called lsp.lua :

This file will hold all of our LSP-related configuration. Inside, we need to add some boilerplate code. Note that the code we are adding here is not only documented on the lspconfig README , but it’s also the recommended configuration by Michael Lingelbach , one of Neovim’s core team members, who has worked heavily on the native LSP implementation.

I will walk through setting up this file step-by-step using tsserver is an example.

The code above is a minimal representation of how we can get Neovim’s LSP working with tsserver . This works just fine, however we can improve on this:

The code above is now capable of setting up any arbitrary amount of servers defined in the servers variable. Installing more than one server? This will effectively loop through each one and wire it up to nvim_lsp .

For example, maybe you added a few more language servers to your setup:

The only thing that has to change in your code is the servers variable. Everything else can stay the same!

ipairs is a lua function that returns index-value pairs. We don’t need the index, hence the _ .

Each server’s setup function is capable of accepting a special on_attach function that runs when a server attaches to your current Neovim buffer. Think of the current buffer as the current file you are editing in Neovim. Based on the filetype, you can have LSP configured to do certain things.

The code above creates a new on_attach function and passes it to each server in our list of servers . But what to put in it?

The Keybindings and completion section of the lspconfig README illustrates adding some basic remaps that will work across every language server. Let’s add these:

This is a lot to digest. Let’s walk through it one step at a time.

We define a function named buf_set_keymap that accepts a variable number of arguments, denoted by the … .

• buf_set_keymap is an abstraction over the vim.api.nvim_buf_set_keymap function.

We define a table named opts that holds some basic options for all of our remaps.

• opts.noremap means “no recursive mapping”
• opts.silent means the command will not be echoed in the command line

We call buf_set_keymap for the first time, passing in 4 parameters.

• 'n' tells LSP that this remap can run in NORMAL MODE
• 'gD' is the remap itself. The letters that you will type to perform some action.
• '<cmd>lua vim.lsp.buf.declaration()<CR>' is the actual command you want to perform. Without the remap, you would have to write this every time. <cmd> is like typing : . <CR> denotes a carriage return, such as hitting ENTER .
• opts is the options table we declared earlier

Our first remap is 'gD' . Typing it will be equivalent to typing :lua vim.lsp.buf.declaration() followed by ENTER . This remap will jump to the definition of the symbol under your cursor while in Neovim. It’s a really helpful remap that I use all the time.

Now that you have the basics down, let’s add the rest of the remaps defined in the lspconfig README :

Now your language server(s) will be able to run these remaps whenever you please. There’s a lot here, and there’s a good chance you won’t use them all. But it’s helpful to have them in case you do. I like to keep my lsp.lua file close while I work, referencing these remaps in case I want to perform some actions. Here are a few that I like to use:

• gD - see the declaration of a symbol (function, variable, etc.)
• K - see some info about a symbol in a hover window
• gr - show a list of references to a symbol
• <space>e - show any issues on the current line

Once the rest of our remaps have been added to our on_attach function, let’s save the file and require it inside of init.lua :

To give your remaps a test drive, make sure to save and source this file. Hop into a project that utilizes one of your language servers and you’re all set! If you're not sure that LSP is working in a particular file, type the command :LspInfo .

You can read more about Neovim's built-in LSP using the command:

Autocompletion

Next on the list of language-related items to configure is autocompletion. Autocompletion is a huge productivity improvement for developers, and it does not come baked into Neovim. We need to install a few plugins to make it happen.

Yes we just installed 5 plugins for autocompletion. Don’t freak out. They each have their purpose:

• nvim-cmp - The main plugin
• cmp-nvim-lsp - A dependency of nvim-cmp
• LuaSnip - Autocomplete your snippets .
• cmp_luasnip - Snippet completion source . Not quite sure what it does? But it’s recommended in defaults.nvim .
• lspkind-nvim - Autocompletion icons

Save, source and :PlugInstall .

Now that all of these plugins are installed, let’s glue them together. But, instead of configuring it within its own .lua file, we’ll want to colocate it with our LSP config. You'll see why:

A lot to take in. Let’s walk it out.

• formatting.format - Formats the autocomplete menu using lspkind , a plugin we installed earlier. This adds icons to keywords and variables to autocomplete options.
• mapping - Custom keybindings for better autocomplete menu navigation. Press <Tab> to navigate forward, and <Shift-Tab> to navigate backwards. Press <CR> (Enter) to confirm selection.
• snippet - Enables snippet autocompletion via LuaSnip
• sources - Declare autocompletion sources.

After configuring the autocompletion plugins, we need to wire it all up with our language servers:

The above code adds a new property named capabilities to each language server. All together, lsp.lua now looks like this:

The last plugin to improve Neovim's language support is treesitter . We will be installing it for improved syntax highlighting. In your init.vim , add the following to you list of declared plugins:

Next, create a treesitter.lua file in your namespace directory:

Inside this file we'll add the following:

Finally, update your init.lua to include treesitter.lua :

And that's it! Source your init.vim and you should see an improved syntax highlighting experience.

The following will not be a tutorial on remaps themselves, as remaps in Vim are a topic worthy of a separate article. There are also plenty of great resources on the topic:

• Mapping Keys in Vim
• Understand Vim Mappings and Create Your Own Shortcuts!
• Basic Mapping - Learn Vimscript the Hard Way

Instead, I will quickly explain what they are and why you would want to use them, and ultimately hope to inspire you to seek out your own.

Let's begin.

Over the course of this article, we've covered many plugins that introduce their own commands:

On top of these plugin-specific commands, Vim has its own set of commands. It can be cumbersome to type out the entire command every time you want to use it. Instead, you can "map" these commands to a pattern of keystrokes. These are remaps.

I declare my remaps inside init.vim . Here's an example of one of my favorites:

The remap above is <C-p> , or CTRL+p . Each time I type this pattern, the command :Telescope find_files<Cr> will run. <Cr> must be explicitly declared in order for the command to be "entered", i.e - with <Enter> .

Here are a few others:

A mapleader is a special character you can appoint to "lead" your remaps. This both simplifies remap keystrokes and prevents unwanted remap collisions. It defaults to \ , but here I'm setting it to an empty space, ' ' .

<leader>h is equivalent to typing the <Space> bar followed by the letter h . Doing so will run the command :wincmd h<Cr> .

I believe remaps are one of those things you'll undoubtedly look for as you notice pain points in your own workflow. It can be helpful to puruse others' Vim configurations and see what they use for inspiration.

Tips and tricks

• Use relative line numbers

Your Neovim terminal supports line numbers with the following setting:

When you get more advanced with your Vim movements, you'll look for ways to move vertically faster. One of the ways to do this is to explicitly type the line number you want to go to. This is easier with relative line numbers:

How does it work? The line your cursor is currently on will be denoted "line 0". The rest of the lines above and below will be numbered relative to their distance from line 0. For example, the line directly below your cursor will be line 1. So will the line directly above. To jump to line 1 below, type the number 1 plus the letter j . To go to line 1 above, type the number 1 plus the letter k .

• Alias the nvim command

An alias is a shortcut defined in your terminal shell’s settings that allows you to run regular commands with custom names. An example alias that many people use is:

Instead of typing git checkout every time I want to check out a branch, I just need to type gc . My terminal knows that when I enter gc , what I really mean is git checkout .

Defining your aliases is dependent on which terminal shell you are using. There are a number of shells that people use these days, like bash , zsh and fish . I use zsh , but you may not be. If you don’t know what shell you are using, you can run the following command in your terminal:

Aliases are defined in your shell’s configuration file. For bash users, that would be .bashrc . For zsh users, .zshrc . etc. etc. Your mileage may vary. Locate your specific file, and add the following:

Now anytime you run the command vim , you will really be running the command nvim . If you still want access to the original vim command, you can prefix it with a \ character:

The command above will use the unaliased vim command. The more you know, right?

• Save your Neovim configuration in Git

This is a major key! I've written a blog post on this very topic . I suggest you take a look. Your Neovim configuration is a subset of a larger group of configuration files dubbed "dotfiles". Dotfiles are the life blood of a good development environment. Make sure you keep yours portable!

• Experiment!

Programming is way more fun when you're being efficient. Neovim can get you there over time, but you have to be willing to try new things. New plugins, new remaps, etc.

• Keep an eye on the community

Neovim has an active subreddit and forum . These are great places to learn and find new plugins to experiment with.

Phew! If you've stuck with me to the end, I appreciate you! This was a massive article, one of the biggest I've ever written. We discussed settings, plugins, color schemes, language support, autocompletion and remaps. I hope you learned something!

If you're curious to see my configuration, you can checkout my dotfiles on GitHub, specifically the nvim directory . And if you're just getting started on your Vim journey, please let me know! It's been a challenging and exciting one for me, and I'm only getting started.

Hey! 👋 I'm Jake

Thanks for reading! I write about software and building on the Web. Learn more about me here.

Subscribe To Original Copy

A weekly email for makers on the Web.

William Brawner

Writing essays in vim.

This month I went back to school, so I now find myself needing to write essays once again. It's been quite a few years since I last had to do homework like this, and I now find word processors to be rather clunky and inefficient compared to just using vim. The only thing I needed was to know how many words I had written to see if I had fulfilled the requirements yet. While I could have just used the wc command, I did a little searching and it turns out that vim has word counting capabilities built in. Pressing g followed by Ctrl + G will show you a quick summary of your position in the document you're writing. Doing so on the file for this post for example looks something like this:

Note: You'll need to be in Normal mode (not Insert mode) for this to work.

6 - Writing Scripts with Vim

Writing files with vim.

Overview Objectives Use the vim text editor to modify text files. Write a basic shell script.

Writing files

We’ve been able to do a lot of work with files that already exist, but what if we want to write our own files? We’re not going to type in a FASTA file, but we’ll see as we go through other tutorials, there are a lot of reasons we’ll want to write a file, or edit an existing file.

To add text to files, we’re going to use a text editor called vim. We’re going to create a file to take notes about what we’ve been doing with the data files in data .

This is good practice when working in bioinformatics. We can create a file called README.txt that describes the data files in the directory or documents how the files in that directory were generated. As the name suggests, it’s a file that we or others should read to understand the information in that directory.

Let’s change our working directory to data using cd , then run vim to create a file called README.txt :

The text at the bottom of the screen shows the keyboard shortcuts for performing various tasks in vim . We will talk more about how to interpret this information soon.

Which Editor? When we say, “ vim is a text editor. On Unix systems (such as Linux and Mac OS X), many programmers use Emacs or Vim (both of which require more time to learn), or a graphical editor such as Gedit . On Windows, you may wish to use Notepad++ . Windows also has a built-in editor called notepad that can be run from the command line in the same way as nano for the purposes of this lesson.

Now you’ve written a file. You can take a look at it with less or cat , or open it up again and edit it with vim .

Creating and Closing a Vim File With and Without Saving

To create a new file, you just have to use a new file name

To prevent you editing unneccesarily you need to be able to navigate across modes. By default, you can move around with arrows keys or keystrokes.

Whenever in any other mode navigate to normal mode press Esc . To navigate to Command navigate to normal mode press Esc . To navigate to command line mode, press Control and [ . This is how you can then quit without saving by entering :q! . Once you press enter you will have exited vim.

Saving modifications with Vim

Reopening the file and enter in a few words.

First, hit Esc to check you are in normal mode. Press i to enter the Inset mode. In the lower-left hand side, you should see --INSET-- . Save the file by writing : followed by wq .

Exercise Open README.txt and add the date to the top of the file and save the file.

Navigation around a file

By default, you can always use the arrows to move around a file. In a large file, it would be really hard to navigate. Switch to the Normal mode using the Esc key. Then type :line_number and hit Enter .

Let say we want to navigate to line 5.

To navigate till your last line you can type :$ .

Searcing in a file

Vim’s search is really helpful. Go into the Command Line mode by (1) pressing Esc key, then (2) pressing colon : key.

We can search a keyword by entering :/word_of_interest , where word_of_interest is the text string you want to find.

Exercise Open README.txt and search for the letter h .

Writing scripts

A really powerful thing about the command line is that you can write scripts. Scripts let you save commands to run them and also lets you put multiple commands together. Though writing scripts may require an additional time investment initially, this can save you time as you run them repeatedly. Scripts can also address the challenge of reproducibility: if you need to repeat an analysis, you retain a record of your command history within the script.

One thing we will commonly want to do with sequencing results is pull out bad reads and write them to a file to see if we can figure out what’s going on with them. We’re going to look for reads with long sequences of N’s like we did before, but now we’re going to write a script, so we can run it each time we get new sequences, rather than type the code in by hand each time.

We’re going to create a new file to put this command in. We’ll call it bad-reads-script.sh . The sh isn’t required, but using that extension tells us that it’s a shell script.

Bad reads have a lot of N’s, so we’re going to look for NNNNNNNNNN with grep . We want the whole FASTQ record, so we’re also going to get the one line above the sequence and the two lines below. We also want to look in all the files that end with .fastq , so we’re going to use the * wildcard.

Custom grep control We introduced the -v option previously, now we are using -h to “Suppress the prefixing of file names on output” according to the documentation shown by man grep .

Type your grep command into the file and save it as before. Be careful that you did not add the $ at the beginning of the line.

Now comes the neat part. We can run this script. Type:

It will look like nothing happened, but now if you look at scripted_bad_reads.txt , you can see that there are now reads in the file.

Exercise We want the script to tell us when it’s done. Open bad-reads-script.sh and add the line echo "Script finished!" after the grep command and save the file. Run the updated script.

Making the script into a program

We had to type bash because we needed to tell the computer what program to use to run this script. Instead, we can turn this script into its own program. We need to tell the computer that this script is a program by making the script file executable. We can do this by changing the file permissions.

First, let’s look at the current permissions.

We see that it says -rw-r--r-- . This shows that the file can be read by any user and written to by the file owner (you). We want to change these permissions so that the file can be executed as a program. We use the command chmod like we did earlier when we removed write permissions. Here we are adding ( + ) executable permissions ( +x ).

Now let’s look at the permissions again.

Now we see that it says -rwxr-xr-x . The x ’s that are there now tell us we can run it as a program. So, let’s try it! We’ll need to put ./ at the beginning so the computer knows to look here in this directory for the program.

The script should run the same way as before, but now we’ve created our very own computer program!

Key Points Scripts are a collection of commands executed together.

Adapted from the Data Carpentry Intro to Command Line -shell genomics https://datacarpentry.org/shell-genomics/

Licensed under CC-BY 4.0 2018–2021 by The Carpentries Licensed under CC-BY 4.0 2016–2018 by Data Carpentry

Vim: Introduction

Quick, look at the calendar, because today, if you are someone who spends more than 6 hours a day in front of a text editor, your life is going to change. Let me repeat that, you won't look at editing text the same way; if you manage to hang around till the end, your brain will be rewired to demand nothing less than a powerful editor like Vim.

There are really just 3 types of editors:

• Everything else

Emacs is an magnificient text editor, make no mistake. If you can think of doing any transformation of text–writing code, sending emails, reading news, connecting to databases, creating websites 1 , taking notes–Emacs does a brilliant job. Emacs just isn't Vim 2 . And this essay is about Vim.

Some of Vim's niche:

• Vim has modal interface which makes editing text and navigation extremely efficient.
• Vim command can be composed : if you know how to delete and know how to jump n lines you can combine these two commands to delete n lines. Know how to copy and now you know how to copy n lines.
• Omnipresence : Whether you like or not, you will encounter Vim if you are working with remote machines a lot. It is pre-installed in almost all *NIX machines.
• Fast , not just to start up but also to use.
• Extensible : Vim was released in 1991 based on vi, which was first released in 1976. And still according to Stack Overflow 2015 survey 3 it is 3rd most popular text editor 4 . This is possible due to great plugins developed by individual contributors which keeps Vim competitive with newer editors.

If you are a power user of any other text editor-like Sublime, Notepad++, atom-and you feel you do not need to learn anything new, that's okay, you are better off spending your time in something else. You may want to read on if you want to know just a few commands to make peace with Vim while sshing , or maybe want to hang around to see what the hype about. There just a sincere request, please do not judge Vim based on emulation done by other editors 5 . All the Vim emulation that I have used, except for Evil mode in Emacs, simply suck. Besides, Vim is much more than the keyboard bindings.

Dive In, head first

Installation.

There is a very good chance that Vim is pre-installed on your system, so head over to your terminal and hit vim . Unless you have already played around with .vimrc , you will be greeted with a black (or any other solid color), dull splash screen which may force you to think that Vim was indeed made in 1991 and wasn't updated after that, except for a few bug fixes . Don't worry about it just yet, you can make your Vim look like any of these quite easily.

If you are using Windows, there are two simple options. The first one includes wiping your OS and installing Linux, if that is not possible then I would recommend installing gvim .

You can quit Vim using :q yes, you need to press : too.

:q is short form for :quit , just like :w is short form for :write (writing a file is same as saving a file).

Vim is our friend, it tries to save us from doing silly things like editing and then writing a file which was meant to be readonly or quitting without saving a file. But sometimes we do want to quit without saving because we want to discard the changes. In such cases, append ! in front command to tell Vim that you know what you are doing.

Append ! to override Vim.

Thus you can type in :q! to discard the changes in the current file and quit or :w! to write a readonly file 6

And that's it, you now know how to open Vim and close it. If you wondering if your life has really changed, it's probably not, yet. But now, at least you are a little less intimidated and know how to make your beast sit . Learning Vim takes time, like all the good things in life.

Click here for part 2

In fact, this website is build using Emacs. Emacs Rocks.

but it does a very good job in enacting Vim: Evil Mode

2015 Results

slipping to 4th position in 2016 in Development Environments which isn't actually text editor segment

Trying Vintage mode in Sublime doesn't count as trying Vim.

This will only succeed if Vim has permission to write the file on disk.

Date: 2017-05-28

Author: Anurag Peshne

Emacs 25.2.2 ( Org mode 9.1.14)

Testimonials

Finished Papers

Get Professional Writing Services Today!

Get a free quote from our professional essay writing service and an idea of how much the paper will cost before it even begins. If the price is satisfactory, accept the bid and watch your concerns slowly fade away! Our team will make sure that staying up until 4 am becomes a thing of the past. The essay service is known for providing some of the best writing, editing, and proofreading available online. What are you waiting for? Join our global educational community today!

Eloise Braun

For expository writing, our writers investigate a given idea, evaluate its various evidence, set forth interesting arguments by expounding on the idea, and that too concisely and clearly. Our online essay writing service has the eligibility to write marvelous expository essays for you.

What if I can’t write my essay?

• Words to pages
• Pages to words

Finished Papers

Customer Reviews

What We Guarantee

• No Plagiarism
• On Time Delevery
• Privacy Policy
• Complaint Resolution

Jalan Zamrud Raya Ruko Permata Puri 1 Blok L1 No. 10, Kecamatan Cimanggis, Kota Depok, Jawa Barat 16452

Some attractive features that you will get with our write essay service

Grab these brilliant features with the best essay writing service of PenMyPaper. With our service, not the quality but the quantity of the draft will be thoroughly under check, and you will be able to get hold of good grades effortlessly. So, hurry up and connect with the essay writer for me now to write.

Look up our reviews and see what our clients have to say! We have thousands of returning clients that use our writing services every chance they get. We value your reputation, anonymity, and trust in us.

Customer Reviews

Finished Papers

Get Professional Writing Services Today!

Get a free quote from our professional essay writing service and an idea of how much the paper will cost before it even begins. If the price is satisfactory, accept the bid and watch your concerns slowly fade away! Our team will make sure that staying up until 4 am becomes a thing of the past. The essay service is known for providing some of the best writing, editing, and proofreading available online. What are you waiting for? Join our global educational community today!

How to Write an Essay For Me

Ultimate Guide to Writing Your College Essay

Tips for writing an effective college essay.

College admissions essays are an important part of your college application and gives you the chance to show colleges and universities your character and experiences. This guide will give you tips to write an effective college essay.

Want free help with your college essay?

UPchieve connects you with knowledgeable and friendly college advisors—online, 24/7, and completely free. Get 1:1 help brainstorming topics, outlining your essay, revising a draft, or editing grammar.

Writing a strong college admissions essay

Learn about the elements of a solid admissions essay.

Avoiding common admissions essay mistakes

Learn some of the most common mistakes made on college essays

Brainstorming tips for your college essay

Stuck on what to write your college essay about? Here are some exercises to help you get started.

How formal should the tone of your college essay be?

Learn how formal your college essay should be and get tips on how to bring out your natural voice.

Taking your college essay to the next level

Hear an admissions expert discuss the appropriate level of depth necessary in your college essay.

Student Stories

Student Story: Admissions essay about a formative experience

Get the perspective of a current college student on how he approached the admissions essay.

Student Story: Admissions essay about personal identity

Get the perspective of a current college student on how she approached the admissions essay.

Student Story: Admissions essay about community impact

Student story: admissions essay about a past mistake, how to write a college application essay, tips for writing an effective application essay, sample college essay 1 with feedback, sample college essay 2 with feedback.

This content is licensed by Khan Academy and is available for free at www.khanacademy.org.

Finished Papers

Finish Your Essay Today! EssayBot Suggests Best Contents and Helps You Write. No Plagiarism!

The essay writers who will write an essay for me have been in this domain for years and know the consequences that you will face if the draft is found to have plagiarism. Thus, they take notes and then put the information in their own words for the draft. To be double sure about this entire thing, your final draft is being analyzed through anti-plagiarism software, Turnitin. If any sign of plagiarism is detected, immediately the changes will be made. You can get the Turnitin report from the writer on request along with the final deliverable.

My experience here started with an essay on English lit. As of today, it is quite difficult for me to imagine my life without these awesome writers. Thanks. Always.

Customer Reviews

Bennie Hawra

• Newsletters
• Account Activating this button will toggle the display of additional content Account Sign out

The Anti-Abortion Endgame That Erin Hawley Admitted to the Supreme Court

Somewhat lost in the debate around abortion pills and oral arguments that took place at the Supreme Court in FDA v. Alliance for Hippocratic Medicine on Tuesday was one deeply uncomfortable truth: The very notion of what it means to practice emergency medicine is in dispute, with anti-abortion doctors insisting upon a right to refuse treatment for any patient who doesn’t meet their test of moral purity. Indeed, the right asserted is that in the absence of certainty about which patients are morally pure, the doctors want to deny medication to all patients, nationwide.

In public, the plaintiffs in this case—a group of doctors and dentists seeking to ban medication abortion—have long claimed they object to ending “unborn life” by finishing an “incomplete or failed” abortion at the hospital. But in court, they went much further. Their lawyer, Erin Hawley, admitted at oral argument that her clients don’t merely oppose terminating a pregnancy—they are pursuing the right to turn away a patient whose pregnancy has already been terminated . Indeed, they appear to want to deny even emergency care to patients whose fetus is no longer “alive,” on the grounds that the patient used an abortion drug earlier in the process. And they aim to deploy this broad fear of “complicity” against the FDA, to demand a nationwide prohibition on the abortion pill to ensure that they need never again see (and be forced to turn away) patients who’ve previously taken it. This is not a theory of being “complicit” in ending life. It is a theory that doctors can pick and choose their patients based on the “moral distress” they might feel in helping them.

It should come as no surprise that the same judge who tried to ban mifepristone in this case, Matthew Kacsmaryk, has also attempted to legalize anti-LGBTQ+ discrimination in health care nationwide. This is the ballgame: weaponize subjective religious beliefs against secular society to degrade the quality of care for everyone. If you can’t persuade Americans to adopt hardcore evangelical views, exploit the legal system to coerce them into it anyway.

Alliance for Hippocratic Medicine is at once embarrassingly frivolous and existentially important. Don’t let the jokes about how silly the Comstock Act seems , or how speculative the theory of standing is, get in the way of taking a serious look at the claims on offer. The plaintiffs say they are terrified that one day, a patient may walk into their emergency room suffering complications from a medication abortion prescribed by some other doctor. This patient may need their assistance completing the abortion or simply recovering from the complete abortion, which these plaintiffs deem “complicity” in sin. And they say the solution is either a total, nationwide ban on mifepristone, the first drug in the medication abortion sequence, or a draconian (and medically unnecessary) set of restrictions that would place mifepristone out of reach for many patients. (The U.S. Court of Appeals for the 5 th Circuit ruled to reinstate those restrictions at their behest.)

It is a twisted line of logic, one that should never have reached the Supreme Court in the first place. But it is also a product of the court’s past indulgence of outlandish claims about moral “complicity.” As was made plain in the oral arguments and briefing, activist doctors are no longer satisfied with personal conscience exemptions already granted under state and federal law; they now insist that nobody, anywhere, should have access to the abortion pill, in order to ensure that they themselves won’t have to treat patients who took one. At a minimum, they say, they should be able to radically roll back access to the pill in all 50 states to reduce the odds that one of these handful of objectors might someday encounter a patient who took it. This extremist argument lays bare the transformation of the idea of “complicity” from a shield for religious dissenters to a sword for ideologues desperate to seize control over other people’s lives and bodies.

At oral arguments, several justices pressed Hawley, who argued on behalf of Alliance for Hippocratic Medicine, with an obvious retort: Why can’t her clients simply refuse to treat these hypothetical someday patients on the grounds that they cannot help end the “life” of a fetus or embryo? After all, federal law guarantees doctors the right not to have to provide an abortion if doing so is “contrary to his religious beliefs or moral convictions.” Justices Amy Coney Barrett and Brett Kavanaugh secured assurances from Solicitor General Elizabeth Prelogar, early in the arguments, that under no circumstances could the government force any health care provider to ever participate in an abortion in violation of their conscience. Justice Elena Kagan asked Prelogar: “Suppose somebody has bled significantly, needs a transfusion, or, you know, any of a number of other things that might happen.” Would the plaintiffs object to treating them? Prelogar said the record was unclear.

Hawley, who is married to far-right Republican Sen. Josh Hawley, then approached the lectern and cleared up any confusion: Yes, she insisted, treating a patient who has undergone a medication abortion violates the conscience of the plaintiff physicians even if there is no “live” fetus or embryo to terminate anymore. “Completing an elective abortion means removing an embryo fetus, whether or not they’re alive, as well as placental tissue,” Hawley told Kagan. So the plaintiffs don’t object just to taking a “life.” They also object to the mere act of removing leftover tissue, even from the placenta.

Of course, these doctors must remove “dead” fetal tissue and placentas all the time—from patients who experienced a spontaneous miscarriage. By their own admission, the plaintiffs regularly help women complete miscarriages through surgery or medication. Those women they will gladly treat. Other women, though—the ones who induced their own miscarriage via medication—are too sinful to touch. Before the plaintiffs can administer even lifesaving emergency treatment, they need to know the circumstances of this pregnancy loss: Spontaneous miscarriages are OK; medication abortions are not.

Justice Ketanji Brown Jackson, too, zeroed in on this admission. She told Hawley that she had thought the objection was to “participating in a procedure that is ending the life [of the fetus].” Hawley told her no: Any participation in an abortion, even through the indirect treatment of a patient without a “live” fetus, violated the doctors’ conscience. So, wait. What about “handing them a water bottle?” Jackson asked. Hawley dodged the question, declining to say whether helping a patient hydrate would constitute impermissible complicity in sin.

All this is reminiscent of Little Sisters of the Poor , a case about a Catholic charitable group that was afforded an exemption from the Affordable Care Act’s contraception mandate. The Little Sisters were asked to check a box signaling to the government that they could not comply with the mandate, at which point the government would step in to cover their employees. But the Little Sisters refused, viewing this action—the checking of a box to opt out of coverage—as “complicity” in abortion because it would in turn trigger government payment for contraception (which they viewed as abortifacients). The Supreme Court and the Trump administration ultimately indulged the Little Sisters’ claim .

Here, we have emergency room physicians asserting that they will not participate in lifesaving medical intervention unless they approve of the reason for the pregnancy loss. Presumably, if the pregnant patient is an unwed mother, or a gay or transgender person, the doctor would be similarly complicit in sin and decline service. Seen through this lens, since one can never know which sins one is enabling in the ER, each and every day, a narrow conscience exemption becomes a sweeping guarantee that absolutely nobody in the country can ever have access to basic health care, let alone miscarriage management. (Of course, these plaintiffs might focus only on one set of “sins” they see as relevant.) In a country effectively governed by Kacsmaryk and his plaintiff friends, a gay person suffering a stroke could be turned away from any hospital because of his sexual orientation, all to spare a doctor from a glancing encounter with prior sin. As Tobias Barrington Wolff, a professor of law at the University of Pennsylvania Law School, put it to us in an email, this unbounded view of complicity “is part of enacting the social death of people and practices you abhor, which in turn can contribute to the material death of people and practices you abhor.”

One of the most exhausting lessons of post- Roe America is that being “pro-life” definitively means privileging the life of the presumptively sin-free unborn—or even their “dead” remains—over the life of the sin-racked adults who carry them. This is why women are left to go septic or to hemorrhage in hospital parking lots; it is why C-sections are performed in nonviable pregnancies, at high risk to mothers; it’s why the women who sued in Texas to secure exceptions to that state’s abortion ban are condemned by the state as sinners and whores . And it’s why—in the eyes of the Alliance for Hippocratic Medicine — it is a greater hardship for a physician to “waste precious moments scrubbing in, scrubbing out” of emergency surgery, as Hawley put it, so long as they don’t believe that the emergency warrants their professional services, than it is for a pregnant person, anywhere in the country, including in states that permit abortion, to be forced to give birth.

At oral argument, Hawley explained that her clients have “structured [their] medical practice to bring life into the world. When they are called from their labor and delivery floor down to the operating room to treat a woman suffering from abortion drug harm, that is diametrically opposed to why they entered the medical profession. It comes along with emotional harm.” The emotional harm alleged here is that unless these doctors approve of the specific circumstances of the ER visit, they violate not only their own medical preference but also their religious convictions. But they will never truly know enough about the sins of their patients to be able to shield themselves against being a link in a chain of subjective lifelong sin. And to be a doctor, especially an emergency physician, should be to understand that your patients’ private choices and spiritual life are not really open to your pervasive and vigilant medical veto. This deep-rooted suspicion of patients deemed insufficiently pure for lifesaving treatment didn’t begin with the availability of medication abortion. It will assuredly not end there.

• Share full article

Advertisement

Gloriously Crispy Chicken for Tonight

Put Christian Reynoso’s schnitzel-like chile crisp chicken cutlets on your cooking bucket list immediately.

By Melissa Clark

The great epicure and writer Joseph Wechsberg once wrote that the hallmark of a good schnitzel was the absence of a grease stain on your pants if you sat on it. Why anyone would sit on a schnitzel is a mystery to me, but the principle stands, that the ideal thin fried cutlet must be perfectly crisp without being at all greasy.

I wouldn’t sit on Christian Reynoso’s schnitzel-like chile crisp chicken cutlets either, but I’m sure they’d pass the Wechsberg test if I did. Christian puts a clever spin on the recipe. After marinating the chicken in chile crisp, soy sauce and vinegar, that same mixture is added to the eggs, giving the cutlets a fiery boost of flavor. With their crackling golden crust and tender interiors, these cutlets are well worth heating up a pot of oil for.

FEATURED RECIPE

Chile Crisp Chicken Cutlets

View Recipe →

Here’s a meatless way to showcase your chile crisp: Ali Slagle’s one-pot tofu and broccoli rice . In it, she stirs together chile crisp, peanut butter and a dash of soy sauce as a coating for the tofu, which is layered on a pot of fluffy, gingery rice and bright-green broccoli florets. It’s an easy weeknight meal that’s on the lighter side and still very satisfying.

If you follow Ali’s work, you know she’s a big fan of chile pastes and sauces of all kinds. She makes her roasted pork tenderloin positively sing with spicy-sweet goodness by glazing it with a simple mix of harissa paste and honey, a minimalist pairing that harmonizes beautifully with the brawny, juicy meat. Serve slices of the seared pork with a tangy citrus salad for a cool and mellow contrast.

To give his easy, new sheet-pan quesadillas their chile kick, Eric Kim goes for powder instead of paste, but then offers plenty of options. Chipotle chile powder, gochugaru, Aleppo pepper or smoked paprika all work, and any of them will add zip to the molten cheese filling that’s dotted with succulent corn kernels.

If you’re chile-shy, there’s no need for it at all in Kay Chun’s speedy shrimp piccata spaghetti , which gets all the vim and vigor it needs from the classic combination of garlic and briny capers sharpened with lemon juice. There’s butter in the pan, too, which gives the velvety sauce enough body to coat the pasta.

Then, for dessert, everyone knows that most muffins are really cupcakes in disguise, but Yossy Arefi’s inspired twist gives muffins a doughnut makeover. Her pillowy chocolate doughnut muffins are made with sour cream, lending these cinnamon-sugar dusted treats irresistible staying power. They’ll keep nice and moist for days if you store them in an airtight container at room temperature.

And, as always, you’ll want to subscribe to access all these smart recipes and so many more (in the tens of thousands range). If you need any technical help, the brilliant people at [email protected] are there for you. And I’m at [email protected] , if you want to say hi.

That’s all for now, see you on Wednesday.

Melissa Clark has been writing her column, A Good Appetite , for The Times’s Food section since 2007. She creates recipes for New York Times Cooking, makes videos and reports on food trends. She is the author of 45 cookbooks, and counting. More about Melissa Clark

More on Food and Dining

Keep tabs on dining trends, restaurant reviews and recipes..

Whether for a casual cookout or an elegant dinner, these three festive dishes are easy to pull off for any spring party .

Dal, the ultimate comfort food for many across South Asia and its diaspora, is cheap, unfussy and adaptable .

In the South, many Black families have made and eaten chew bread — a dessert similar to a blondie  — for generations.

Flamboyant displays of fake flowers at restaurants have turned into a maximalist design movement , with one man as a chief trendsetter.

Sign up for our “ The Veggie ” newsletter to get vegetarian recipes  for weeknight cooking, packed lunches and dinner parties.

Eating in New York City

Pete Wells, our dining critic, has unveiled his annual ranking of the 100 best restaurants in New York City .

Once the pre-eminent food court in Flushing, Queens, for regional Chinese cuisines, the Golden Mall has reopened after a four-year renovation. A new one in Manhattan  is on the horizon.

At Noksu, dinner is served below the street, a few yards from the subway turnstiles. But the room and the food seem unmoored from any particular place .

You thought Old World opulence was over ? A prolific chef gives it a new and very personal spin at Café Carmellini.