Forem: Nisal Sashmitha

Vim Essential Shortcuts (Linux VI Editor — part 3)

Nisal Sashmitha — Mon, 04 Aug 2025 09:51:16 +0000

Vim Essential Shortcuts (Linux VI Editor — part 3)

So far we’ve learned about vim editor’s basics, modes, and how to exit and save files. You now know how to create a file, add basic text, manipulate it a bit, and save your work.

Now it’s time to supercharge your vim skills! Learning vim shortcuts will make you significantly more efficient. We’ll cover navigation shortcuts, deletion, cutting (yanking), pasting (putting), and text transformation. These commands will transform how you work with text.

📝Quick Note: There are many more powerful shortcuts available than what’s covered in this document. Think of this as your foundation — a way to understand what’s possible with vim and inspire further exploration. I’ve included a comprehensive cheat sheet at the end for your reference.

💡Pro Tip: Once you master these basics, you can unlock even more power by learning operators , text objects , and macros — which we’ll cover in future articles. These concepts will help you combine commands in powerful ways!

Navigation: Moving Around Like a Pro

Remember, These navigation commands work in Normal mode (press Esc to get there). One of vim's greatest strengths is that you can navigate without moving your hands from our normal typing position.

Basic Movement (The Foundation)

h - move left (think: h is on the left)
j - move down (think: j points down)
k - move up (think: k points up) 
l - move right (think: l is on the right)

Navigation Map:
    k (up)
    ↑
h ← • → l
    ↓
  j (down)

Memory trick: The hjkl keys are arranged on your keyboard from left to right, just like the directions they represent!

Line Navigation

0 - jump to start of line (beginning of line = 0)
^ - jump to first non-whitespace character
$ - jump to end of line (think: $ is at the end in shell prompts)

Word Movement

w - jump forwards to start of next word
W - jump forwards to start of next WORD (ignores punctuation)
b - move backward word by word (think: b = back)
e - move forward to end of current word (think: e = end)

Example: If your cursor is on the ‘H’ in “Hello, world! How are you?”:

w moves to the comma ,
W moves to world!
e moves to the 'o' in "Hello"

Page and Document Navigation

Ctrl + f - page down (think: f = forward)
Ctrl + b - page up (think: b = back)
gg - go to first line of document 
G - go to last line of document
{number}gg or {number}G - go to specific line

Example: To go to line 25, type: 25gg or 25G

Deletion: Removing Text Efficiently

In Insert mode , you use Delete and Backspace as normal. But Normal mode offers much more powerful deletion options.

Basic Deletion

x - delete character under cursor (think: x marks the spot to delete)
X - delete character before cursor

Advanced Deletion (The Real Power)

dd - delete entire line
dw - delete from cursor to start of next word
d$ - delete from cursor to end of line
d0 - delete from cursor to beginning of line

A way to easily remember: Notice the pattern? d (delete) + movement command!

d + w = delete word
d + $ = delete to end of line
d + d = delete whole line

Practical Example:

Original: "The quick brown fox jumps over the lazy dog"
Cursor on 'b' in "brown"

dw → "The quick fox jumps over the lazy dog"
d$ → "The quick "
dd → (entire line deleted)

Cut (Yanking) and Paste (Putting): Moving Text Around

Vim calls copying “yanking” and pasting “putting” — think of it as yanking text out and putting it somewhere else.

Yanking (Copying)

yy - yank (copy) entire line
yw - yank word from cursor position
y$ - yank from cursor to end of line

Putting (Pasting)

p - put (paste) after cursor or below current line depending on what you copied or the place you in.
P - put (paste) before cursor or above current line

Practical Example:

Original text:
Line 1: "Hello World"
Line 2: "Goodbye World"

1. Position cursor on Line 1
2. Type: yy (yanks the line)
3. Move to Line 2
4. Type: p (puts the copied line below)

Result:
Line 1: "Hello World"
Line 2: "Goodbye World" 
Line 3: "Hello World"

Pro Pattern: Notice that yank commands follow the same pattern as delete:

y + movement = yank that text
d + movement = delete that text

Text Transformation: Changing and Substituting

Case Changes

~ - toggle case of character under cursor
guu - make entire line lowercase
gUU - make entire line UPPERCASE

Search and Replace

:s/old/new/ - replace first occurrence of 'old' with 'new' on current line
:s/old/new/g - replace all occurrences of 'old' with 'new' on current line
:%s/old/new/g - replace all occurrences in entire file
:%s/old/new/gc - replace all with confirmation prompts

Practical Example:

Original: "This cat in the hat sat on the mat"

:%s/the/a/g

Result: "This cat in a hat sat on a mog"

Quick Changes

r{char} - replace single character under cursor with {char}
cw - change word (deletes word and enters insert mode)
cc - change entire line
c$ - change from cursor to end of line

Example:

Original: "Hello World"
Cursor on 'W' in "World"

r + M → "Hello Morld"
cw + "Universe" → "Hello Universe"

Quick Short Note

Movement Cheat Sheet:
┌─────────────────────────────────────┐
│ Navigation │ Text Objects │
├─────────────────┼───────────────────┤
│ h j k l │ w = word │
│ 0 ^ $ │ $ = line end │
│ gg G │ 0 = line start │
│ Ctrl+f Ctrl+b │ gg G = document │
└─────────────────┴───────────────────┘

Action Commands Pattern:
[action][count][motion]
Examples:
d2w = delete 2 words
y3j = yank 3 lines down  
c$ = change to end of line

Summary and Pro Tips

Key Patterns to Remember:

Action + Movement = Power : Most vim commands combine an action (d, y, c) with a movement (w, $, j)
Double letters often mean “whole line” : dd, yy, cc
Uppercase usually means “stronger version” : W vs w, P vs p

Practice Tips:

Start with hjkl navigation - avoid arrow keys to build muscle memory
Practice the d + movement pattern with different combinations
Use :help [command] in vim to learn more about any command

Next Steps: Once these commands become second nature, you’ll be ready to learn about operators , text objects , and macros — which will multiply your efficiency even further!

Remember : vim has a learning curve, but every shortcut you master saves you countless keystrokes in the future. Start with a few commands, use them daily, then gradually add more to your toolkit. Here is a good cheat sheet I found.

✈️ This is a article I wrote as a contribution to a open-source DevOps Roadmap repository . While it focuses on the Vi editor, the repo includes many other valuable resources to support your DevOps journey — be sure to check them out too!

YAML: A Beginner’s Introduction

Nisal Sashmitha — Sat, 02 Aug 2025 06:17:37 +0000

YAML (Yet Another Markup Language or YAML Ain’t Markup Language) is a human-readable data serialization standard that’s commonly used for configuration files, data exchange, and storing structured data. It’s designed to be easy to read and write, making it popular for DevOps, applications configuration, and data representation.

Why YAML? Comparing Data Formats

Let’s see how the same data looks in different formats:

XML Format

<person>
    <name>John Doe</name>
    <age>30</age>
    <languages>
        <language>Python</language>
        <language>JavaScript</language>
    </languages>
</person>

JSON Format

{
  "person": {
    "name": "John Doe",
    "age": 30,
    "languages": ["Python", "JavaScript"]
  }
}

YAML Format

person:
  name: John Doe
  age: 30
  languages:
    - Python
    - JavaScript

As you can see, YAML is much cleaner and easier to read! No brackets, braces, or closing tags needed.

Key-Value Pairs in YAML

The foundation of YAML is the key-value pair, separated by a colon and space:

# Basic key-value pairs
name: John Doe
age: 30
city: New York
is_student: false
height: 5.8

Important: Always use a space after the colon!

# ✅ Correct
name: John

# ❌ Wrong
name:John

Arrays/Lists in YAML

Arrays (or lists) are represented using dashes (-). Each dash indicates an element of the array:

# Simple list
fruits:
  - apple
  - banana
  - orange

# Alternative inline format
colors: [red, green, blue]

# List of numbers
scores:
  - 95
  - 87
  - 92

Dictionaries/Maps in YAML

Dictionaries (or maps) are collections of key-value pairs. Indentation is crucial — all properties of a single item must have the same number of spaces:

# Dictionary example
person:
  name: Alice
  age: 25
  address:
    street: 123 Main St
    city: Boston
    zip: 02101

Visualization of the Dictionary

person:
├─ name: Alice
├─ age: 25
└─ address:
   ├─ street: 123 Main St
   ├─ city: Boston
   └─ zip: 02101

The Power and Danger of Indentation

In YAML, spaces matter! Different indentation levels create different meanings:

Correct Indentation

# All properties at same level (2 spaces)
person:
  name: John
  age: 30
  job: Developer

Incorrect Indentation

# Mixed indentation - This will cause errors!
person:
  name: John
   age: 30 # 3 spaces - WRONG!
  job: Developer # 2 spaces - Different from age

Nested Structure Example

company:
  name: Tech Corp
  employees:
    - name: Alice
      role: Developer
      skills:
        - Python
        - Docker
    - name: Bob
      role: Designer
      skills:
        - Photoshop
        - Figma

Note: In above example you can see that under employees there is a array of dictionaries. ”-” indicates a start of the item.

Dictionary vs List vs List of Dictionaries

Let’s understand the differences with examples:

Simple Dictionary

# A single person
person:
  name: John
  age: 30
  city: NYC

Simple List

# List of names
names:
  - John
  - Alice
  - Bob

List of Dictionaries

# Multiple people (list of dictionaries)
people:
  - name: John
    age: 30
    city: NYC
  - name: Alice
    age: 25
    city: Boston
  - name: Bob
    age: 35
    city: Seattle

Order Matters in Lists, Not in Dictionaries

Dictionaries: Order Doesn’t Matter

These two dictionaries are identical :

# Dictionary 1
person:
  name: John
  age: 30
  city: NYC

# Dictionary 2 - Same as above!
person:
  city: NYC
  name: John
  age: 30

Lists: Order Matters

These two lists are different :

# List 1
fruits:
  - apple
  - banana
  - orange

# List 2 - Different from above!
fruits:
  - banana
  - apple
  - orange

Comments in YAML

Any line starting with # is a comment and is ignored:

# This is a comment
name: John Doe # This is also a comment

# Configuration for database
database:
  host: localhost # Local development
  port: 5432
  # password: secret # Commented out for security

Complete Example: Putting It All Together

Here’s a comprehensive YAML example combining all concepts:

# Application Configuration File
app_name: "My Awesome App"
version: 2.1.0
debug: true

# Database configuration
database:
  host: localhost
  port: 5432
  name: myapp_db
  credentials:
    username: admin
    password: secret123
# List of supported languages
languages:
  - English
  - Spanish
  - French
# List of server configurations
servers:
  - name: web-server-1
    ip: 192.168.1.10
    roles:
      - web
      - api
    specs:
      cpu: 4
      memory: 8GB
  - name: db-server-1
    ip: 192.168.1.20
    roles:
      - database
    specs:
      cpu: 8
      memory: 16GB
# Feature flags
features:
  user_registration: true
  email_notifications: false
  premium_features: true

Key Takeaways and Tips

✅ Best Practices

Always use spaces, never tabs for indentation
Be consistent with indentation (usually 2 or 4 spaces)
Use quotes for strings that might be ambiguous
Add comments to explain complex configurations
Validate your YAML before using it in production

⚠️ Common Pitfalls

Mixing tabs and spaces
Inconsistent indentation levels
Forgetting the space after colons
Not quoting strings that start with numbers or special characters

YAML’s simplicity and readability make it an excellent choice for configuration files and data serialization. Remember: indentation is everything in YAML, and when in doubt, validate your syntax!

Happy YAML writing! 🚀

Docker Engine Architecture

Nisal Sashmitha — Fri, 01 Aug 2025 07:17:29 +0000

Have you ever wondered what happens behind the scenes when you run docker run hello-world? Let's dive into the inner workings of Docker and understand how it manages to isolate applications so effectively.

The Three Pillars of Docker Engine

When you install Docker on a Linux system, you’re actually installing three distinct components that work together seamlessly:

1. Docker CLI (Command Line Interface)

This is what you interact with directly. The docker command you type in your terminal. Think of it as the remote control for your TV; it's just the interface, not the actual TV.

# These are all Docker CLI commands
docker run nginx
docker ps
docker stop container_name
docker build -t myapp .

2. Docker REST API

This is the communication bridge between the Docker client and the Docker daemon. Every command you type gets translated into HTTP requests that the daemon can understand. It’s like a translator that converts your English commands into a language the daemon speaks.

This API can be accessed directly using HTTP clients like curl or wget, or through HTTP libraries available in most programming languages.

3. Docker Daemon (dockerd)

This is the heavy lifter, a background process that does all the actual work. It manages:

Images : The blueprints for containers
Containers : Running instances of images
Volumes : Persistent data storage
Networks : Communication between containers

The Core Challenge: Application Isolation

Before we dive into how Docker works, let’s understand the fundamental problem it solves. When you run multiple applications on a single machine, they all share the same operating system resources. This creates several critical issues:

The Problems with Traditional Application Deployment

1. Resource Conflicts

# Two web servers trying to use port 80
nginx starts on port 80 ✓
apache tries to start on port 80 ✗ (Port already in use!)

2. Dependency Hell

# App A needs Python 3.8, App B needs Python 3.9
App A: "I need libssl version 1.1"
App B: "I need libssl version 1.0" 
System: "I can only have one version installed!"

3. Process ID Collisions

# What if two applications create processes with the same ID?
App A creates process with PID 1000
App B tries to create process with PID 1000 → CONFLICT!

4. Security Concerns

# Applications can see and potentially interfere with each other
ps aux # Shows ALL processes from ALL applications
kill 1000 # Can accidentally kill other app's process

Why This Matters for Docker

Docker’s promise is: “Package an application with all its dependencies and run it anywhere, isolated from other applications.”

But how can you achieve this isolation when all applications are running on the same Linux kernel? You can’t install multiple operating systems for each application — that would be too resource-intensive.

The Solution: Linux Namespaces and C groups

How Applications Get Containerized

Now comes the fascinating part, how does Docker isolate applications so effectively? The secret lies in Namespaces.

Docker uses a concept called namespaces to handle this isolation.

The Problem: Process ID Conflicts

Imagine you’re running two applications on your system, and both try to create a process with ID 1000. Without isolation, this would cause a conflict:

Without Namespaces:

The Solution: Namespaces

Docker uses namespaces to create isolated workspaces for each container. Even though you tried to create two processes with same id you gets a your container specific process Id and the host system specific process Id. Now you can have as many as containers without conflicting.

With Namespaces:

Seeing Namespaces in Action

# Run a container and check its process ID from inside
docker run -it ubuntu bash
# Inside the container:
echo $$ # This will show PID 1 (the bash process)
ps aux # You'll see a minimal process list

# From another terminal on the host:
docker ps # Find your container ID
docker exec <container_id> ps aux # Same minimal process list
ps aux | grep bash # You'll see the actual PID on the host (much higher number)

Visual explanation

Host System View:
PID 1 → systemd
PID 2 → kthreadd
...
PID 15847 → docker-containerd-shim
PID 15864 → bash (your container process)

Container View:
PID 1 → bash (appears as the main process)

The Complete Picture: Namespaces + Cgroups

Now, here’s an important point: Namespaces alone don’t provide complete isolation!

Namespaces solve the “visibility” problem — they create separate views of system resources. But what about resource usage? What stops one container from consuming all the CPU or memory and starving other containers?

# This is still a problem with namespaces alone:
Container A: "I need all 16GB of RAM!"
Container B: "Hey, leave some RAM for me!"
System: "First come, first served!"

Docker uses TWO technologies together:

Namespaces → Provide isolation (separate views)
Cgroups → Provide resource control (limits and quotas)

Complete Docker Isolation

💡 Key Takeaway

The Docker CLI, REST API, and daemon orchestrate both namespaces and cgroups to create secure, isolated, and resource-controlled containers. Each container gets its own view of processes, network, filesystem, AND guaranteed resource limits.

Docker’s complete isolation magic comes from two Linux technologies working together :

Namespaces create isolated views — each container thinks it’s running alone
Cgroups control resource usage — preventing containers from monopolizing system resources

Introduction to VI Editor (Linux VI Editor — part 1)

Nisal Sashmitha — Mon, 28 Jul 2025 10:23:27 +0000

📖 Quick Note: This introduction gives you a high-level overview of VIM to spark your interest. Don’t worry about memorizing and understanding everything here — we’ll learn step by step in the following sections. Feel free to scan through this as a starting point and then dive into the detailed guides!

Why VI Over Simple Text Commands?

While the cat command is handy for viewing small files, it falls short when you need to actually edit text:

# cat is great for viewing...
cat myfile.txt

# But what if you need to edit, search, or manipulate text?
# This is where VI shines!

VI (pronounced “vee-eye”) is a powerful console-based text editor that comes pre-installed on virtually every Linux distribution. It’s your reliable companion whether you’re editing configuration files, writing code, or managing text on remote servers.

What is VI Really?

VI is short for “visual” — it was revolutionary when introduced because it allowed full-screen editing, unlike earlier line-based editors.

Here’s an important fact: VI has been replaced by VIM (Vi IMproved). Many Linux distributions (like Ubuntu) use Vim to provide the vi command, meaning when you type vi in the terminal, you are actually running a version of Vim configured to behave like the original Vi, or a more feature-rich version with specific settings.

Why Choose VI/VIM Over Other Editors?

Better Than Nano

While nano is simpler for beginners, VI/VIM offers:

More powerful editing capabilities
Better for large files
Extensive customization options
Available on every Unix-like system

VIM is Like a Language

VIM uses a unique approach with verbs, nouns (objects), and adjectives:

Verb + Object = Action
d + w = delete word
c + w = change word  
y + w = yank (copy) word

# Add numbers (adjectives) for even more power:
d + 3w = delete 3 words
c + 2w = change 2 words
y + 5w = yank 5 words

This makes it incredibly efficient once you learn the “vocabulary.”

Basic Example Commands

# Start editing a file
vi myfile.txt

# Basic navigation (in normal mode)
h # Move left
j # Move down  
k # Move up
l # Move right

# Essential commands
i # Enter insert mode
Esc # Return to normal mode
:w # Save file
:q # Quit
:wq # Save and quit

VIM’s Built-in Help System

One of VIM’s best features is its comprehensive help system:

# Access help (from within VIM)
:help # General help
:help w # Help for 'w' command
:help :w # Help for ':w' command

You can even split your screen to view help while editing your file — no need to leave the editor!

VIM Modes

Mode Usage Summary:

Normal Mode: Navigate, delete, copy, search, and execute commands
Insert Mode: Actually type and add text to your file
Visual Mode: Select text for copying, deleting, or formatting

The Joy of Efficiency

VIM encourages creative problem-solving. There are usually multiple ways to accomplish the same task:

# Delete a word - multiple methods:
dw # Delete word (cursor to end)
cw # Change word (delete and enter insert mode)
x # Delete single character (repeat as needed)

You can even make it a game: “How can I accomplish this edit with the fewest keystrokes?” This mindset naturally leads to becoming more efficient over time.

Summary & Tips

VI = VIM in most modern systems
Three main modes: Normal (command), Insert (typing), Visual (selection)
Think in terms of verbs and objects for powerful combinations
Use :help extensively - it's your best learning resource
Practice regularly — muscle memory is key to VIM mastery

💡 Pro Tip: Don’t try to learn everything at once. Start with basic navigation and insertion, then gradually add new commands to your toolkit.

Next: Continue your VI/VIM journey with VIM Modes section and other resources for hands-on learning and practical techniques!

VIM Modes: The Heart of VIM (Linux VI Editor — part 2)

Nisal Sashmitha — Mon, 28 Jul 2025 08:22:44 +0000

VIM Modes: The Heart of VIM (Linux VI Editor — part 2)

📖 Overview Note: This is an overview of VIM modes. You’ll learn these concepts in more depth as we explore other VIM features. Being aware of modes and understanding what they do will really help you quickly learn other features of the VI editor. You’ll need to work between these modes to practice all upcoming tasks!

What Makes VIM Different?

One of the key features that makes VIM different from other editors is its concept of modes. While most editors have just one mode where you type and use menus, VIM has distinct modes for different tasks.

The Three Main Modes

1. Normal Mode (Command Mode)

Default mode when you start VIM
Anything you type in Normal mode is a command
Used for navigation, deletion, copying, and other file operations
VIM is case sensitive — d and D do different things!

2. Insert Mode

Used for actually typing and adding text to your file
To enter Insert mode: Press i (or other insert commands)
To exit Insert mode: Press Escape

3. Line Mode (Command Line Mode)

Line mode is also called Last Line Mode or Command Line Mode. You use line mode to:

Save files (:w)
Quit VIM (:q)
Go to exact locations in the file (:10 goes to line 10)
Search and replace text
Execute advanced commands
Set VIM options and preferences

Your First VIM Session

Let’s create a file and practice moving between modes:

Create and open a new file

vim myfile.txt

Once VIM opens, you’ll be in Normal mode. Here’s how to move between modes:

You start in NORMAL MODE

Press ‘i’ to enter INSERT MODE

Now type some text

Press Escape to return to NORMAL MODE

Press : to enter command mode, then type w to save or wq to save and quit. If you type w, you’ll return to normal mode after saving.

Mode flow

Visual Mode (Bonus)

There’s also Visual Mode for selecting text:

To enter: Press v in Normal mode
Purpose: Select text for copying, deleting, or formatting
To exit: Press Escape

Complete Mode Switching Examples

# Starting in Normal mode
i # Enter Insert mode
<Esc> # Back to Normal mode
: # Enter Line mode
<Esc> # Back to Normal mode (abandon command)
:w # Enter Line mode and save
<Enter> # Execute command, return to Normal mode
v # Enter Visual mode
<Esc> # Back to Normal mode

Other Modes Exist Too!

VIM has additional modes like:

Replace mode
Binary mode
Org mode

These are slight variations of the main modes and you’ll learn about them later as you become more comfortable with VIM.

Summary & Tips

Three main modes: Normal (commands), Insert (typing), Line (file operations)
Always start in Normal mode when opening VIM
Escape is your friend — it always returns you to Normal mode
Case sensitivity matters — i and I are different commands
Line mode starts with : - used for file operations and advanced commands
Practice mode switching — it becomes second nature quickly

💡 Pro Tip: When in doubt, press Escape twice to ensure you're in Normal mode, then proceed with your desired command. This is a safe way to "reset" your mode state!

Next : Master VIM navigation and movement commands to efficiently move around your files!