Choosing a Text Editor (Vim, Nano, VS Code)

When writing shell scripts or configuring Linux systems, choosing the right text editor is an essential first step. Whether operating locally on a desktop interface or remotely inside a headless cloud server over SSH, understanding how to open, edit, save, and manage files directly from the command line is a core foundational skill for any DevOps engineer.

1. Why Do We Need a Command-Line Text Editor?

In local software development, developers frequently rely on graphical user interface (GUI) editors like VS Code, Sublime Text, or gedit. However, in Linux system administration and cloud DevOps workflows, systems are typically running without a graphical desktop (headless environments).

When connected to a remote EC2 instance or bare-metal server, you only have access to a terminal interface. Command-line interface (CLI) text editors allow you to:

• Modify configuration files (.conf, .yaml, .json) directly on remote servers.
• Write, debug, and execute shell scripts (.sh) without requiring desktop environments.
• Maintain a lightweight footprint with minimal memory consumption during production hotfixes.

2. Overview of Popular Linux Text Editors

Linux environments offer a variety of text editors tailored to different skill levels and operational requirements.

1. vi (Visual Editor):
   • The classic, original Unix terminal editor available natively on almost every POSIX-compliant operating system.
2. vim (Vi IMproved):
   • An expanded, modern version of vi. It features syntax highlighting, undo trees, and powerful search-and-replace capabilities. It is heavily favored by systems engineers and experienced DevOps practitioners.
3. nano:
   • A straightforward, beginner-friendly terminal editor. It displays all primary key bindings directly at the bottom of the screen, requiring no prior familiarity with modal editing.
4. gedit:
   • The default graphical text editor for GNOME desktop environments. It provides a familiar windowed writing environment but requires a graphical desktop (X11/Wayland).
5. VS Code (Visual Studio Code):
   • A modern, feature-rich graphical IDE. Using extensions like "Remote - SSH", developers can write code locally while seamlessly executing and saving files on a remote server.

3. Comparative Synthesis of Text Editors

4. File Extensions in Linux (.txt, .sh)

When working with terminal editors, files are typically opened or created by passing the filename as an argument to the editor command:

vim hello.txt

Key Rules Regarding File Extensions in Linux:

• Extensions as Metadata: Unlike Windows, Linux does not strictly require file extensions to determine how a file is handled or executed.
• Human Readability: Extensions like .txt (plain text) or .sh (shell script) serve primarily as organizational context for human developers and enable syntax highlighting inside text editors.
• Execution Rights: A file named script.txt or script.sh can be executed as a shell script in Linux as long as it contains valid code and has executable permissions granted via chmod +x.

5. Core Mental Model: Understanding Vim Modes

Unlike standard text processors (where typing on the keyboard immediately outputs characters to the screen), Vim is a modal editor. Key presses perform different actions depending on the active mode.

The Three Fundamental Modes in Vim:

1. Normal Mode (Default):
   • Entered automatically when Vim opens.
   • Keys act as commands for navigation (e.g., cursor movements), deleting text, copying, and pasting.
2. Insert Mode:
   • Entered by pressing i while in Normal Mode.
   • Allows typing text directly into the file.
3. Command Mode (Last-Line Mode):
   • Entered by pressing : while in Normal Mode.
   • Used for administrative commands such as saving (:w), quitting (:q), or searching.

6. Complete Walkthrough: Creating a File in Vim

The following vertical workflow details the exact execution steps required to create, write, save, and exit a text file named hello.txt using Vim:

7. Essential Vim Command Reference

To work efficiently in Vim without getting stuck inside the editor, keep the following foundational commands in mind:

Navigating & Switching Modes

i : Enter Insert Mode before the cursor position.

• Esc : Exit current mode and return to Normal Mode.
• : : Open Command Mode prompt.

Saving & Quitting (Command Mode)

• :w : Write (save) the file to disk without exiting.
• :q : Quit Vim (fails if there are unsaved changes).
• :wq or :x : Write (save) changes and quit immediately.
• :q! : Force quit Vim, discarding all unsaved changes.

Basic Editing (Normal Mode)

• x : Delete the character directly under the cursor.
• dd : Delete (cut) the entire current line.
• yy : Yank (copy) the current line.
• p : Paste the copied/cut buffer after the cursor position.
• u : Undo the last operation.

8. Working with Nano: The Beginner-Friendly Alternative

For quick modifications where memorizing modes is inconvenient, nano provides an intuitive experience:

nano hello.txt

Nano Workflow & Shortcuts:

• Typing text works directly upon opening (no separate Insert Mode).
• Save File: Press Ctrl + O (WriteOut), confirm the filename, and hit Enter.
• Exit Editor: Press Ctrl + X.
• Get Help: Press Ctrl + G to view built-in documentation.

Note: Inside nano, the caret symbol ^ represents the Ctrl key on your keyboard. For example, ^X translates to pressing Ctrl + X.

9. Real-World DevOps Industry Best Practices

1. Vim Familiarity is Non-Negotiable for Cloud Engineers: While GUI tools like VS Code are standard for local development, Linux servers often lack graphical capabilities. Knowing basic Vim syntax ensures you can debug systems during production downtime.
2. Use VS Code Remote-SSH for Large Projects: When working with large shell automation repositories, use VS Code with the Remote - SSH plugin. This provides a GUI development environment locally while executing commands directly on remote cloud servers.
3. Set Default Text Editors in Environment Variables: You can configure your shell environment to default to your preferred editor for administrative commands (such as git commit or crontab -e):
   BASH

   Copy

   export EDITOR="vim"
   export VISUAL="vim"
   

10. Summary and Key Takeaways

• Choice of Editor: Select an editor based on accessibility and environment—vim for remote cloud instances, nano for simple terminal edits, and VS Code for local development.
• Terminal Primacy: CLI editors are essential in DevOps because cloud instances and container environments usually operate without graphical interfaces.
• File Extensions in Linux: Extensions like .txt or .sh are organizational conventions for developers; Linux relies on file permissions (chmod) rather than extensions to execute files.
• Vim Modal Architecture: Vim uses distinct modes—Normal Mode for navigation/commands, Insert Mode for typing, and Command Mode (:) for file operations.
• Entering Insert Mode: Pressing i in Vim transitions from Normal Mode to Insert Mode, allowing text entry.
• Saving and Exiting Vim: Use :w to write changes, :q to quit, :wq to save and quit, or :q! to force quit without saving.
• Nano Key Notation: In nano, short-keys prefixed with ^ indicate the Ctrl modifier key (e.g., ^O means Ctrl + O).
• Default System Configuration: Assign your editor preference globally using export EDITOR="vim" within your .bashrc or .zshrc shell profile.