Why migrate at all

A few things pushed me toward it. A couple of years into the Computer Programming and Analysis program, I’d seen enough tools and tradeoffs that “run a lighter stack” stopped being an abstract idea and turned into an actual plan. NotionNext is a good project. I’ll get into why it stopped working for me, but it’s more machinery than a personal blog needs.

I’d also run out of excuses not to touch it. One of my rules is: if it works, don’t touch it, and that’s exactly why this sat on my todo list for so long. But “I don’t fully understand web app internals yet” was not true for me anymore, and once that excuse is gone, all that’s left is a task I’m avoiding.

And practically, between graduation and the next job I have more free time than I’ll have again for a while, so it made sense to sit with my notes and actually figure out what I’d learned. Getting back into regular blogging needed a platform I’d actually want to open.

I also looked at Hexo and Astro. The short version of why Hugo won is in Building This Blog: it comes down to how content maps to URLs and how each one handles Org-mode.

The longer version is that this year I went through IDEA, VS Code, Neovim, and Emacs for different kinds of work. IDEA is still my favorite for Java: its indexing and language support make everything else feel like it’s guessing. VS Code is the balanced choice once you’re off Java or working on something large; the ecosystem covers file browsing, Markdown rendering, and even reading a PDF without leaving the editor. And since I live in a terminal (WSL as my main environment, so I get fzf, rg, and the Linux tooling that things like Claude Code supported first) right now, Neovim is hard to pass up: it’s light, fast, and everything stays on the keyboard.

None of that is actually why I picked Hugo, though. I picked Hugo because I fell for Emacs. It’s the first tool that gave me what “one unified environment” actually means. The Org mode is the part I like most: think of it as Markdown crossed with a Jupyter notebook. When I want code output sitting inside my notes instead of copy-pasted from a terminal, Org is about the best format for that. Hugo happens to parse Org natively, so the fit was already there before I went looking for it.

Why not just stay on NotionNext

This is the part with real evidence behind it, not just preference:

1. It’s a React app with a long dependency chain.

2. It’s hard-coupled to the Notion API. A major API update once took the whole blog down in one shot, and there was nothing I could do about it on my end.

3. Forking is the wrong shape for this. Maintaining my own fork meant every upstream change was a potential merge conflict and a version-bump decision I didn’t want to make.

4. Error rates I never got to the bottom of. Vercel’s dashboard would occasionally show something like this:

   

5. The deployments themselves were flaky, on top of everything else. A run of “Updated” deploys failing back to back on production isn’t something you want in your history:

   

6. React’s CVE treadmill. Every so often there was a fresh CVE to patch that had nothing to do with anything I’d written:

   

None of that is exotic. It’s just the cost of running someone else’s React app instead of a static site, and I’d paid it long enough.

How I migrated

Getting oriented

I started at Hugo’s own site, found the themes gallery, and looked for something that fit a personal, bilingual blog. PaperMod stood out: MIT licensed, 13.9k GitHub stars, still getting updates, and the demo already looked close to what I wanted without any customization.

From there it was the usual mix: reading the theme’s own docs, skimming its GitHub repo for how people actually configure it, and asking an AI assistant questions that would’ve otherwise cost an evening of trial and error, mostly which config keys are current versus deprecated, and how Hugo’s page bundles are supposed to be laid out.

Actually doing it

The content move itself was mechanical: 45 posts pulled out of a Notion export, cleaned up, and dropped into content/. The interesting part was everything that broke after the content was in place, and none of it showed up until I actually tried to use the feature.

One Issue: oversized record failed the whole deploy

My Algolia push script truncates each post’s content to stay under Algolia’s 10KB per-record limit, but I’d only truncated content, not summary. Hugo builds an automatic summary by grabbing whole content blocks, and one post that opened with a long block produced an 11KB summary. Algolia rejected the record, the push script exited non-zero, and that failed the entire Vercel build: not a partial deploy with one missing search result, a hard stop.

"summary" (.Summary | plainify | truncate 300 "" | htmlUnescape | htmlUnescape)

Cutting over

The old blog was still live on Vercel, wired to www.parkerchenca.com and parkerchenca.com. First I paused that project.

Then it was straightforward: pull the domain off the old project, import the new repo as its own Vercel project, add the environment variables, and point the domain back at the new one. Vercel won’t let the same domain sit on two projects at once, so the order matters.

Comments were the last piece: giscus needed the repository to be public with GitHub Discussions turned on and its own GitHub App installed before it would actually render anything.

And then, boom, it was done. Simpler than I expected, and the environment variables even came out to about half of what NotionNext needed.

Where that leaves things

The blog is live, search works, comments work (I think the light/dark toggle also flips the comment widget now, but I haven’t actually tested it in a browser myself. If you’ve read this far, give it a try and tell me in the comments below ;D ).

Useful links

Hugo:

• https://github.com/adityatelange/hugo-PaperMod
• https://github.com/adityatelange/hugo-PaperMod/wiki

My Blog:

• https://github.com/BHChen24/MyLittleBlog-Hugo/

🔔 Prelude: With these commands you are able to do most text-related work the same as you are on Windows.

Linux Common Commands

System Management

System Information

# Basic system information
lscpu                                  # Detailed CPU information
uname -a                               # Kernel and architecture info
cat /etc/os-release                    # Distribution information

# Hardware information
lsblk                                  # Block devices
lsusb                                  # USB devices
lspci                                  # PCI devices

Package Management

# dpkg package management
sudo dpkg -i package.deb                           # Install deb package
dpkg -l | grep package_name                        # Search installed packages
dpkg -L package_name                               # List package files
dpkg -S /path/to/file                              # Find which package owns file

Monitoring and Performance

Memory and Disk

# Memory usage
free -h                                # Human readable format
watch -n 1 free -h                     # Real-time monitoring

# Disk usage
df -h                                  # Disk usage
du -sh /path/to/directory              # Directory size
du -h --max-depth=1 | sort -hr         # Sort directories by size
sudo fdisk -l                          # Partition table info

System Monitoring

# Temperature monitoring
vcgencmd measure_temp                   # Raspberry Pi temperature
sensors                                # General temperature sensors
watch -n 1 vcgencmd measure_temp        # Real-time temperature monitoring

# Process monitoring
ps aux                                 # All processes
top                                    # Real-time process monitor
htop                                   # Enhanced top
ps aux --sort=-%mem | head -10         # Sort by memory usage
ps aux --sort=-%cpu | head -10         # Sort by CPU usage

# I/O monitoring
sudo iotop                             # I/O usage
sudo iotop -o                          # Show only processes doing I/O

Network Monitoring

# Connection status
ss -tuln                               # Network connections
ss -a                                  # All connections
ss -tuln | grep :22                    # Specific port

# Traffic monitoring
iftop                                  # Interface traffic (requires installation)
nethogs                               # Traffic by process (requires installation)

Processes and Services

Process Management

# Find processes
pgrep -f "process_name"                # Find process PID
ps aux | grep "process_name"           # Detailed information

# Terminate processes
kill PID                               # Normal termination
kill -9 PID                            # Force termination
pkill "process_name"                   # Terminate by name

Background Jobs

# Background execution
command &                              # Start in background
nohup command &                        # Run without hangup

# Job control
Ctrl + Z                               # Suspend current process
bg                                     # Continue in background
fg                                     # Bring to foreground
jobs                                   # List background jobs

# tmux sessions
tmux new-session -d -s session_name "command"
tmux attach -t session_name

Service Management

# systemd services
systemctl status service_name          # Check status
systemctl start/stop/restart service_name
systemctl enable/disable service_name  # Auto-start on boot

# Log viewing
journalctl -u service_name             # Service logs
journalctl -f                          # Real-time logs
journalctl --since "2 hours ago"       # Time range

Scheduled Tasks

# cron jobs
crontab -e                             # Edit
crontab -l                             # List

# Syntax: minute hour day month weekday command
# 0 2 * * * /home/user/backup.sh      # Run daily at 2 AM
# */10 * * * * /usr/bin/check.sh      # Run every 10 minutes

Network Management

Network Interfaces

# View network interfaces
ip addr show                           # All interfaces
ip a                                   # Short form
ip link show up                        # Enabled interfaces

# Manage interfaces
sudo ip link set eth0 up/down          # Enable/disable interface

# Routing information
ip route show                          # Routing table
ip route | grep default                # Default gateway

WiFi Management

# NetworkManager
nmcli dev wifi list                    # Scan WiFi
nmcli dev wifi connect "SSID" password "password"
nmcli connection show                  # Saved connections

# Traditional tools
iwconfig                               # WiFi interface status

Network Testing

# Connectivity testing
ping google.com
ping -c 4 google.com                   # Limit count
traceroute google.com                  # Path tracing

# Port testing
nc -zv google.com 80                   # Port connectivity
nmap -p 22,80,443 target_host          # Port scanning

# DNS queries
dig google.com                         # DNS lookup
cat /etc/resolv.conf                   # DNS configuration

# Firewall
sudo ufw status                        # Ubuntu firewall status

Files and Text

File Finding

# Find by name
find /path -name "filename"
find . -name "*.txt"                   # By extension
find . -type f -name "*.log"           # Files only
find . -type d -name "temp*"           # Directories only

# Command location
which python3                          # Command location
whereis python3                        # Binary, source, manual

# Fast search
sudo updatedb                          # Update database
locate filename                        # Quick search

Content Search

# Basic search
grep "pattern" file.txt
grep "pattern" *.txt                   # Multiple files

# Common options
grep -i "pattern" file                 # Ignore case
grep -r "pattern" directory/           # Recursive search
grep -n "pattern" file                 # Show line numbers
grep -v "pattern" file                 # Invert match

# Context search
grep -A 3 "pattern" file               # Show 3 lines after
grep -B 3 "pattern" file               # Show 3 lines before
grep -C 3 "pattern" file               # Show 3 lines around

File Content Operations

# View files
cat file.txt                           # Full content
head -20 file.txt                      # First 20 lines
tail -20 file.txt                      # Last 20 lines
tail -f file.txt                       # Follow changes
less file.txt                          # Paged viewing

# Sort and unique
sort file.txt                          # Sort
sort -n numbers.txt                    # Numeric sort
sort file.txt | uniq                   # Remove duplicates

# File comparison
diff file1.txt file2.txt               # Basic comparison
diff -u file1 file2                    # Unified format
diff -y file1 file2                    # Side-by-side

Text Processing and Pipes

# sed stream editor
sed 's/old/new/g' file.txt             # Global replacement
sed -i 's/old/new/g' file.txt          # In-place modification
sed '/pattern/d' file.txt              # Delete matching lines
sed -n '1,10p' file.txt                # Print specific lines

# awk text processing
awk '{print $1}' file.txt              # Print first column
awk '{print $1, $3}' file.txt          # Print multiple columns
awk '/pattern/ {print $2}' file.txt    # Conditional print
awk -F':' '{print $1}' /etc/passwd     # Specify delimiter
awk '{sum += $1} END {print sum}' numbers.txt  # Calculate sum

# Pipes and redirection
command > file.txt                     # Output redirection
command >> file.txt                    # Append redirection
command 2> error.log                   # Error redirection
command &> all.log                     # All output redirection

# Pipe operations
command1 | command2                    # Basic pipe
cat log | grep "ERROR" | awk '{print $1}' | sort | uniq -c

# tee splitting
command | tee file.txt                 # Output to both file and terminal
command | tee -a file.txt              # Append mode
echo "text" | sudo tee /root/file.txt > /dev/null  # Privilege escalation write

Transfer and Compression

Network Downloads

# wget downloads
wget https://example.com/file.zip
wget -O newname.zip https://example.com/file.zip  # Specify filename
wget -c https://example.com/largefile.iso         # Resume download

# curl downloads
curl -O https://example.com/file.zip               # Keep original filename
curl -o newname.zip https://example.com/file.zip   # Specify filename
curl -C - -O https://example.com/largefile.iso     # Resume download

Remote Transfer

# scp secure copy
scp file.txt user@remote:/path/                    # Upload file
scp -r directory/ user@remote:/path/               # Upload directory
scp user@remote:/path/file.txt ./                  # Download file
scp -P 2222 file.txt user@remote:/path/            # Specify port

# rsync synchronization
rsync -av source/ destination/                     # Basic sync
rsync -av --delete source/ destination/            # Delete extra files
rsync -av source/ user@remote:/path/               # Remote sync
rsync -avz --progress source/ destination/         # Compression + progress

Compression and Extraction

# tar archives
tar -czf archive.tar.gz files/                     # Create compressed archive
tar -xzf archive.tar.gz                            # Extract archive
tar -tzf archive.tar.gz                            # View contents
tar -xzf archive.tar.gz -C /destination/           # Extract to directory

# zip compression
zip -r archive.zip directory/                      # Compress directory
unzip archive.zip                                  # Extract
unzip archive.zip -d /destination/                 # Extract to directory
unzip -l archive.zip                               # View contents

Device Management

USB Devices

# USB device management
lsusb                                  # USB device list
lsusb -v                               # Detailed information
watch -n 1 lsusb                       # Real-time monitoring

# Mount USB
sudo mkdir /mnt/usb
sudo mount /dev/sdb1 /mnt/usb          # Mount
sudo umount /mnt/usb                   # Unmount

Bluetooth Devices

# Bluetooth management
systemctl status bluetooth             # Service status
sudo hciconfig hci0 up                 # Enable adapter
sudo hcitool scan                      # Scan devices

# Bluetooth console
bluetoothctl
# Common commands: power on, scan on, pair <MAC>, connect <MAC>

Audio Devices

# Audio devices
aplay -l                               # Playback devices
arecord -l                             # Recording devices
pactl list sinks short                 # PulseAudio output devices

# Volume control
alsamixer                              # Graphical mixer
amixer sset Master 80%                 # Set volume
pactl set-sink-volume @DEFAULT_SINK@ 50%

Quick Operations

History Operations

# History search
Ctrl + R                               # Reverse search history
Ctrl + S                               # Forward search history
history                                # Show history list
history | grep "pattern"               # Search history commands

# ! operator (history expansion)
!!                                     # Repeat last command
!$                                     # Last argument of previous command
!^                                     # First argument of previous command
!*                                     # All arguments of previous command
!n                                     # Execute nth command in history
!ssh                                   # Execute most recent command starting with ssh
!?config                               # Execute most recent command containing config

# Quick substitution
^old^new                               # Replace old with new in last command
!!:s/old/new                           # Same as above, sed-style replacement
sudo !!                                # Add sudo to previous command

# Argument operations
echo !$                                # Show last argument of previous command
ls !*                                  # Use all arguments from previous command with ls

Quick Editing

# Cursor movement
Ctrl + A                               # Move to beginning of line
Ctrl + E                               # Move to end of line
Ctrl + F                               # Move forward one character
Ctrl + B                               # Move backward one character
Alt + F                                # Move forward one word
Alt + B                                # Move backward one word

# Deletion operations
Ctrl + K                               # Delete from cursor to end of line
Ctrl + U                               # Delete from cursor to beginning of line
Ctrl + W                               # Delete previous word
Alt + D                                # Delete next word
Ctrl + H                               # Delete previous character (same as Backspace)
Ctrl + D                               # Delete current character

# Copy and paste
Ctrl + Y                               # Paste last deleted content
Alt + Y                                # Cycle through deletion history

# Other editing
Ctrl + T                               # Transpose current and previous character
Alt + T                                # Transpose current and previous word
Alt + U                                # Convert current word to uppercase
Alt + L                                # Convert current word to lowercase
Alt + C                                # Capitalize current word
Ctrl + _                               # Undo last edit

# System control
Ctrl + L                               # Clear screen
Ctrl + C                               # Interrupt current command
Ctrl + Z                               # Suspend current process
Ctrl + D                               # End input/exit shell

# Auto-completion
Tab                                    # Auto-complete
Tab Tab                                # Show all possible completions
Alt + .                                # Insert last argument of previous command
Alt + *                                # Expand all possible completions for current word

Directory and File Operations

# Directory operations
cd -                                   # Return to previous directory
pushd/popd                             # Directory stack operations
mkdir -p path/to/deep/directory        # Create nested directories

# {} Brace expansion - generates multiple names
touch file{1,2,3}.txt                  # Creates file1.txt file2.txt file3.txt
mkdir {backup,temp,logs}               # Create multiple directories
cp file.txt{,.bak}                     # Copy to file.txt.bak
echo {A..Z}                           # Expand A B C ... Z
echo {1..10}                          # Expand 1 2 3 ... 10
echo {01..10}                         # Expand 01 02 03 ... 10 (preserve format)

# [] Bracket matching - matches existing files
ls file[123].txt                       # Match file1.txt file2.txt file3.txt
ls file[1-5].txt                       # Match file1.txt to file5.txt
ls [abc]*.txt                          # Match txt files starting with a, b, or c
ls [A-Z]*.log                          # Match log files starting with uppercase
ls file[!123].txt                      # Match files except file1,2,3.txt
rm temp[0-9][0-9].tmp                  # Delete files like temp01.tmp to temp99.tmp

# Wildcard combinations
cp *.{jpg,png,gif} images/             # Copy all image files
ls file[1-3].{txt,log}                 # Match file1.txt, file1.log, etc.
find . -name "*[0-9].txt"              # Find txt files ending with digits

🔔 Prelude: When writing Rust programs, Result and Option are data structures we can hardly avoid. I believe that rather than understanding their underlying mechanisms, we should first quickly figure out how to handle them.

Gift Wrapping

Actually, we don’t need to think of Option<T> and Result<T,E> as too complicated:

• Option contains the data we want, where the data type is T. However, there might be no data inside (None). But regardless, as long as what we care about is wrapped, it will be an Option.
• Result also contains the data we want, but it comes with another “restless” additional item E (Error). In fact, combinations of Result and Option are very common, such as Result<Option<T>, E>. Result provides a powerful and unified specification for Rust’s error handling.

So, how do we open the gift box…

The moment of unwrapping gifts is always exciting.

Whether it’s Option or Result, we can use unwrap() to open this package.

• If the gift box contains a normal value, everything goes smoothly, and everyone’s happy.
• But if it contains something “weird” (None or Err), the program will immediately panic and crash.

Of course, if we insist on using safer unwrapping methods (like unwrap_or, match, etc.), we can control whether the program crashes ourselves, which is very practical.

What functions do these gift boxes provide?

Let’s quickly go through the methods they provide. Detailed explanations won’t be provided here, as I believe you can look up relevant information through https://doc.rust-lang.org/std/option/ and https://doc.rust-lang.org/std/result/.

Option

Notable methods:

• map(f) provides a way to operate on inner data without unpacking, very commonly used
• expect("Hi") can display error messages when panicking, more practical than unwrap()
• ? can greatly improve code cleanliness
• is_some() and is_none() are also very useful for making decisions

Result

Compared to the intuitive and easy-to-understand Option, Result seems more “convoluted” with an additional type, but essentially it’s almost identical to Option: what to do if we didn’t get the value (possibly due to an error).

Result also has: map(f) and ?, as well as useful is_ok() and is_err()

In Result<T, E>:

• T is the type of value returned on success (e.g., file content, calculation result, etc.).
• E is the type of value returned on error (e.g., std::io::Error, custom error enum, etc.).
• Actually:
  • E can be any type, with no restrictions
  • But to use ?, facilitate debugging and printing, E usually needs to implement Debug, Display, Error, and other traits
  • Yes, E can be very complex types (carrying context, providing helper methods), or very simple error structures (like, a string). Err is just the shell that Result uses to mark “this is the error branch”, with E inside

Examples

// ===== Creating Option =====
let some_value: Option<i32> = Some(42);  // Has value
let none_value: Option<i32> = None;      // No value

// Common usage: returning from functions
fn find_number(flag: bool) -> Option<i32> {
    if flag { Some(7) } else { None }
}

// ===== Creating Result =====
let ok_value: Result<i32, String> = Ok(42);                    // Success
let err_value: Result<i32, String> = Err("Oops".to_string()); // Failure

// Common usage: returning from functions
fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

🔔 Prelude: Yes, You can always type :h to see help, for example, :h windows

Vim in not so short

Preliminaries

• When vim is not available, you can temporarily use cat or nano as alternatives
• When using a new IDE, you should first learn or configure:
  • save
  • copy / paste
  • duplicate line
  • delete word / delete line
  • line movement
  • navigate forward / back
  • undo / redo
  • page navigation (page down, page up, center to middle, etc.)
  • indent / unindent
  • multi-cursor
  • search / content search
  • input commands (Ctrl + P in VSCode, double Shift in IntelliJ, : in vim…)
  • completion, suggestion, parameter hint, hover hint
  • go to / peek definition, type, declaration, reference, implementation
  • rename symbol / refactor (if available)
  • AI controlling: toggle chat box, trigger inline chat…
  • tabs / windows management
• Use the :help command to query anything you don’t understand
• :set option? can view current settings

Windows and Tabs

Buffer: Can be understood as a temporary file. Even if this file is edited, it doesn’t mean it’s written to the actual file. We can observe buffers through windows and manage them through tabs.

1. Use commands starting with b in Ex (command line) mode for buffer operations:
   • bd buffer delete; bwipeout clears more thoroughly
   • bn or bnext switch to next buffer
   • bp or bprevious switch to previous buffer
   • ctrl + ^ switch to the last buffer

Ctrl + W window shortcuts and :sp split commands are the basics of window management. :sp can use parameters to specify files to split (open a new window for this file)

1. Ctrl + W + w cycle windows, Ctrl + W + hjkl switch focus left/down/up/right (move cursor)
2. Ctrl + W + = (make window panes equal size)
3. Ctrl + W + + Ctrl + W + Ctrl + W + < Ctrl + W + > (fine-tune window size)
4. :vsp performs vertical split, dividing into two sides
5. :resize 20 sets height to 20 lines; :vertical resize 80 sets width to 80 columns

:tabs is the basic tab management command.

1. :tabnew opens a new tab, :tabe (edit) opens a tab for editing. Can be followed by filename.
2. :tabn :tabp switch tabs, or use gt gT to switch
3. Display current buffer in new tab: :tab split
4. :tabmove move tab, for example :tabmove 2
5. Batch execution:
   • :tabdo {cmd} execute on all tabs, e.g., :tabdo set nocursorline
   • :windo {cmd} execute on each window in current tab, e.g., :windo diffthis

:only and :close are universal management methods

1. Type :close :only directly to manage windows
2. Type :tabclose :tabonly to manage tabs

Key Remapping

Here’s the key remapping configuration in VSCode vim extension:

{
"vim.leader": "<space>",
"vim.useSystemClipboard": true, // important
"vim.normalModeKeyBindings": [
    {
      "before" : ["J"],
      "after" : ["5", "j"]
    },
    {
      "before" : ["K"],
      "after" : ["5", "k"]
    },
  ],
"vim.normalModeKeyBindingsNonRecursive": [
    {
      "before" : ["<Backspace>"],
      "after" : ["x"]
    },
  ],
"vim.insertModeKeyBindingsNonRecursive": [

  ],
"vim.visualModeKeyBindingsNonRecursive": [
    {
      "before" : ["<Backspace>"],
      "after" : ["d"]
    },
  ]
}

Common key aliases:

• <Backspace>
• <C-c> -> Ctrl + C
• <A-c> -> Alt + C
• <Shift>
• <CapsLock>
• <Tab>
• <Enter>
• <Esc>
• <Cmd-> Mac specific
• <Up>
• <Down>
• <Left>
• <Right>

vim Configuration File

Use the .vimrc file in the home directory:

" This is vimscript, so use let for assignment and " for comments

nnoremap <SPACE> <Nop>
let mapleader = " "
set number

" Use system clipboard
set clipboard=unnamedplus

" Map `J` to `5j`, `K` to `5k`, `<Backspace>` to `x`
nnoremap J 5j
nnoremap K 5k
nnoremap <Backspace> x
" inoremap
" vnoremap

" nmap
" imap
" vmap
nnoremap <Enter> o<Esc>

Unbound Keys

In VSCode and other IDEs, you can return Vim-controlled keys to the IDE, since they have no use in GUI interfaces.

• Ctrl + D scroll down
• Ctrl + Z suspend Vim
• Ctrl + X decrease number at cursor by 1, in insert mode it’s completion, decrease by 1 is quite useful
• Ctrl + C can be considered
• Ctrl + F scroll forward, in insert mode used to view command history
• Ctrl + W window command, delete one word before cursor
• Ctrl + P completion
• Ctrl + S pause output
• Ctrl + Q same as Ctrl + V, only q alone is for recording macros, VSCode defaults to Add cursor below, multi-cursor editing tool
• Ctrl + Y / E scroll window up/down by 1 line
• Ctrl + T depends on situation

Quick Reference

(jut for memory, may not be accurate)

1. w -> word
2. b -> back
3. e -> end
4. H -> page head; L -> low; M -> middle
5. zz move current line to the middle position
6. Ctrl + U & Ctrl + D half screen move up & down
   • Ctrl + F & Ctrl + B full screen move forward & back
7. g -> go (sometimes obviously more than that)
   • gn go to next (matched), commonly used
   • gi go to (last) insert
   • gd go to definition
   • gf go to file
8. d -> delete (actually puts deleted content into register); sometimes means down
   • dd delete one line
9. x -> dl; X -> dh
   • s -> (x + i)
   • c -> change (d + i)
10. y -> yank
11. p -> do paste | as paragraph
12. { } -> paragraph
13. f -> find occurrence (char)
    • ; -> next occurrence
    • , -> last occurrence
    • t -> till next occurrence
    • F -> backward to occurrence
14. / -> search item with pattern
    • n -> next item
    • ? -> back search
15. u -> undo; Ctrl + R redo
16. 123… -> as line number / do multiple times
17. i -> do insert | as inner (inside); o -> open a line below; a -> append | around
18. s -> as sentence | do substitute
19. q -> record macro
20. v -> visual
21. s -> surrounding. cs{old}{new}. plugin command
    • v S{desire pair} -> surrounding by.
22. J join
23. r replace

Special Characters

1. @ -> execute register content
2. . > as current line | do repeat last change, very commonly used, for repeating edit operations
3. % -> as all lines(all contents); in normal mode represents matching symbols like {[(
4. 0 -> beginning of line
   • $ -> end of line
   • ^ first meaningful character
   • _ first meaningful character (can be operated by g etc.)
   • g_ last meaningful character
5. ; repeat last f, F, t, T command. For example, if you used f to find a character, pressing ; will continue to find the next matching character.
   • , reverse repeat
6. ' for mark navigation. For example, pressing 'a jumps to the beginning of line of mark ‘a’.
7. ``` (backtick) for mark navigation. For example, pressing ``a` jumps to the exact position of mark ‘a’.
8. ~ change char case.
9. & repeat last substitution command

Modes

1. Normal mode: Enter normal mode when first starting, press i (insert) to enter insert mode, press : to enter command input mode
2. Insert mode: Edit file, press Esc to exit.
3. Command input mode: Input commands, press Esc to exit.
4. Press v to enter visual mode, generally used for selecting paragraphs

Command Structure

1. Normal mode commands are almost based on the verb + adj(count) + obj(motion, text-object) pattern, e.g.: d3j, ca(
   • Omitting verb means cursor movement, which can actually be understood as a type of verb.
     • Example: 3j, move down 3 lines
     • Example: 0, $, these are special characters
     • Example: v3w, v only switches mode, doesn’t count as verb, but subsequent behavior without verb is treated as cursor movement
   • Special case: Omitting adj. means based on current position, or only operating on one object.
     • Example: cw, f{
   • Special case: Omitting both adj. and obj. generally means some single character/line shortcuts
     • Example: dd, yy, gg
     • Example: s, x, ~, u
2. Command line mode has almost no pattern. If anything, they can almost all be categorized as command-like modes.
   • verb + obj pattern: :set number, :r file (read file)
   • adj + verb pattern: :3,5 d
     • adj + verb + obj: :3,5 d0
   • obj pattern: :map
   • verb pattern: :w, :q
   • Special pattern (can be viewed as mode switching): :!command (execute external command)
   • Command-like pattern: :s/foo/bar/gc

Repeat Operations

• . for modifications.
• ; for f, etc.
• r means replace
• f sth -> r -> ; -> . -> ; -> . -> … : guess what will happen?
• gn for / etc. Need to operate on current search content once first, then use . to repeat.

Tips

• verb is almost never absent, omitting verb generally means movement (v provides selection function, but still needs to move to some position to trigger)
• At the same time, obj is also almost never absent, omitting obj generally means current position

When inputting commands, if you’re unclear what else to input, consider these questions:

1. Does the command have an object? E.g., w, p, s. (Specifically, line operations generally omit objects). Selection in v mode actually provides objects. Similarly, movement actions actually also provide objects. So, this part should be considered first, but input last.

2. Does the command have modifiers? If there’s a clear area to operate on, you must pay attention to modifier input. Because if not provided, it will immediately operate based on current position, very easy to cause misoperations.

3. What does the command need to do? Please treat this as the last part to think about, to control vim behavior more precisely. But when inputting commands, generally need to input first. So, input this first.

Seqs: 3 → 2 → 1

Commonly used Commands

• :w save
• :q quit
• :q! force quit without saving
• :w filename save file as filename
• :w! filename force save to filename
• :set nu :set number display line numbers, commonly used
• /word search downward (note, no :, when pressing /, command line becomes / mode)
  • Press n, N to search next/previous
  • ?word search upward
• u and :u undo
• Ctrl + R redo
• x = dl, X = dh
• s = ch

Compound Commands

• :5 d delete line 5, commonly used
• :3,5 d delete lines 3 to 5
• :$ d delete last line of document
• :% d delete all content in document
• :n move m move line n to after line m, commonly used
• :n,n+3 t m copy lines n to n+3 to after line m, commonly used
  • Summary: :n,m generally means from line n to line m
• :%s/hello/nihao/g replace all hello with nihao, similar to sed operation
  • :s/hello/nihao/g only replace in current line
• :5,8s/hello/nihao/g replace hello with nihao in lines 5-8

Common Shortcuts

Movement

1. Ctrl + O previous position, Ctrl + I next position
2. If you have Home End PageUp and PageDown keys, you can use them directly, adding Ctrl is more convenient
   1. PgUp PgDown behavior varies, specifically use with Ctrl and Shift
3. Ctrl + U and Ctrl + D half screen scroll; Ctrl + F and Ctrl + B full screen scroll
4. Ctrl + Up to beginning of line, vice versa

Normal Mode

Cursor Movement

Character-based Movement

• h l move left/right, k j move up/down, arrow keys also work
• Use f to find next character, uppercase for reverse search; using t stops before that character
  • Use ; and , to repeat forward/backward search
• ^ move to first non-whitespace position
• g_ find first non-whitespace position from end of line
• Use $ to move to end of line
• Use % to match brackets like ( { [

Word-based Movement

• w move to next word, commonly used, remember as word
• b move to beginning of current/previous word, commonly used, remember as back
• e move to end of current/next word, commonly used, remember as end
  • Uppercase W, B, E, gE for including characters after words
  • ge move to end of previous word
  • 3w can move 3 times
• Use / and ? to search for pattern, use n and N to jump to next/previous

Line-based Movement

• g is the most basic line movement command
• 0 move cursor to beginning of line, $ move cursor to end of line
• Home key to beginning of line, End key to end of line
• G (Shift+G)/gg move cursor to end/beginning of file
• Actually G is go, so you can input 500G or 500gg to locate to line 500, commonly used
  • Or directly use :line_number to locate
  • gi return to last insert location, commonly used

Block or Screen-based Movement

• { } move by paragraph
• H move to top line of screen; L move to bottom line of screen; M move to middle of screen

Mark-based Movement

• ma set mark a
• 'a jump to beginning of line of mark a
• ``a` jump to exact position of mark a
• '' jump to beginning of line of previous position, commonly used

Operation Commands

Follow {operator}{count}{motion} pattern, e.g.: d2w

• c change, d delete, y yank (copy), p paste
  • change means delete corresponding content and directly enter insert mode
• gu gU or directly press ~ to change char’s case (commonly used)
• = format, for formatting, need to set code standards in advance, e.g.:

set autoindent        " Inherit indentation from previous line
set smartindent       " Smart indentation based on syntax
set cindent           " C/C++ style indentation
set shiftwidth=4      " Move 4 spaces for each indentation operation
set tabstop=4         " Display one Tab as 4 spaces
set expandtab         " Use spaces instead of Tab

Common formatting commands:

• ==: Format current line.

• =motion: Format range specified by motion.

• =ap: Format current paragraph (ap means “a paragraph”).

• =%: Format content within brackets matching current cursor position.

• gg=G: Format entire file.

• Use >> for indentation, use > when target is provided

Text Objects (delete content of specific patterns)

Follow {operator}{a/i}{text object} pattern, e.g.: di' (delete inside ’)

• Generally used with c, d
• a -> around, i -> inside
• text-object identifiers:
  • w word
  • s sentence
  • p paragraph
  • '"[{< ` corresponding to respective special blocks
  • t tag, commonly used in html language, between ><

Copy and Delete

• yy copy current line, commonly used
• dd cut current line, commonly used
• 3dd delete 3 lines, commonly used
• p/P paste content after/before cursor, commonly used
• x delete character at cursor, X delete previous character
• r modify character at cursor
• R enter replace mode

Undo

• u undo, commonly used
• Ctrl + R redo, commonly used

Enter Insert Mode

• i enter insert mode at current position
• a enter insert mode at next character
• A enter insert mode at end of line
• o enter insert mode on next line, often used with G and End, commonly used
• s delete current character and enter insert mode
• S delete current line and enter insert mode
• cw delete next word and enter insert mode
• cb delete previous word and enter insert mode

Insert Mode

Generally use shortcuts for operations

Cursor Movement

1. Ctrl + A move cursor to beginning of line, uppercase moves to beginning of document
2. Ctrl + E move cursor to end of line

Text Operations

1. Ctrl + W: Delete one word before cursor.
2. Ctrl + U: Delete all content from current cursor position to beginning of line.
3. Ctrl + T increase indentation to the right
4. Ctrl + D decrease indentation to the left
5. Ctrl + R: Insert register content. After pressing, need to input register identifier, e.g., Ctrl + R, 0 inserts content of register 0.

Completion Features

1. Ctrl + N: Auto-complete next matching word. commonly used
2. Ctrl + P: Auto-complete previous matching word.
3. Ctrl + X, Ctrl + L: Full line completion, shows dropdown menu
4. Ctrl + X, Ctrl + N/P: Word completion based on current file.
5. Ctrl + X, Ctrl + F: Filename completion.
6. Ctrl + X, Ctrl + K: Dictionary lookup completion.

Others

1. Ctrl + C: Exit input mode. Replace Esc, commonly used
2. Ctrl + O: Temporarily switch to normal mode to execute one command, then return to input mode. commonly used
3. What if you press wrong key? In normal mode use Ctrl + O to return to previous position, meaning in input mode press Ctrl + O x2

Visual Mode

Follow {trigger v}{motion}{operator} pattern, e.g.: v2wd (select two words then delete)

• Press v for character selection, V for line selection, Ctrl + V for block selection
• Generally only used for copy-paste, operation speed is slow

: Command Mode

Batch Processing (delete, move, copy, paste)

1. :2,5d a: Delete lines 2 to 5 and save in register a
2. 0 line 0; `# Vim in a Nutshell
3. :.,+3d delete current lint & plus 3 lines
4. In visual mode，:'<,'>d means “delete selected content”
5. @: repeat last : command
   • After using q for macro recording we can use @@ repeat it
   • After @: , @@ is still available
6. :'<,'>move .
   • :m 10 move (current line) to 10 line after
7. :/ looking for last found pattern

Quick Reference

Find and Replace

• :%s/old/new/g: In entire file range, replace all strings matching old with new. Add c to ask before each replacement.
• :s/old/new/g: Replace all old with new in current line.
• :g/pattern/d: Delete all lines matching pattern.
• :'<,'>s/old/new/g: In visual mode selected range, replace all old with new.
• :'<,'>normal command: Execute normal mode command on each line selected in visual mode.

Line Operations

• :d: Delete current line (similar to dd).
• :t .+1: Copy current line and paste to next line.
• :m .+1: Move current line down one line.
• :m .-2: Move current line up two lines.
• :-3,. m .+1: Move 3 lines above current line to below current line
• :-3,.y | :.+1put: Copy above three lines, paste to next line. put creates new line, p pastes at cursor position

sed-like Command Usage

1. Replace all matching patterns at once: :%s/pattern/replacement/gc for entire file range (%), substitute (s) pattern with replacement
2. gc are flags, common flags include:
   • g: Global replacement (apply command to all lines)
   • c: Ask before each command execution.
   • i: Ignore case
   • n: Maximum number of replacements
   • p: Print results
   • v: Invert results
   • !: Pass to external tool -> %!sort will sort entire text
3. Explicitly use normal commands in Ex mode. Use norm
   • Very useful with v mode
   • Example: :'<,'>norm A!, will for content selected in v mode (‘<,’>), uniformly add a “!” at the end of lines (A)

% itself is shorthand for **`1,# Vim in a Nutshell

Tips

• Accidentally pressed Ctrl + S? Use Ctrl + Q to release
• It’s best not to use the right numeric keypad for editing, there might be key conflicts

Copy-Paste Issues

Vim editor has its own clipboard system called registers. Vim uses registers to store text, which are different from X11 clipboards. If Vim is compiled with X11 clipboard support (through +clipboard option), then you can use special registers "* and "+ to access X11’s PRIMARY and CLIPBOARD.

Paste Mode

To prevent auto-formatting from corrupting pasted content, Vim provides paste mode. Before pasting, execute :set paste command to enter paste mode, which will temporarily disable auto-indent, auto-wrap and other functions. After pasting, execute :set nopaste to return to normal mode.

You can also install some programs to access X11 clipboard, such as xclip or xsel.

Right mouse button enters visual mode?

• :set mouse-=a

Register Overview

Vim uses a set of registers as its “clipboard”. These registers can be used to save text and paste later. Each register has an identifier, which can be a single letter or special character. Here are some basics about Vim registers:

Note, to use registers, first press ", then switch to the desired register, then perform operations

To view register status, type :reg in command line mode

Basic Registers

• "" - Default register, if you don’t know where copied content went, look here
• "0 - Number 0 register. Stores content of your last yank (copy).
• "- - Small delete register. Stores content of your last delete or change that’s less than one line.
• "1 to "9 - Number registers. Store your recent delete or change history ("1 is most recent, "9 is oldest).
• "a to "z or "A to "Z - Named registers. You can use lowercase letters to store text, uppercase letters to append text to corresponding lowercase register.

Special Registers

• "* and "+ - Clipboard registers. In Vim with clipboard support (usually GUI version Vim or Vim with +clipboard feature), these two registers communicate with system clipboard:
  • "* register corresponds to X11’s PRIMARY clipboard (usually the select-to-copy one).
  • "+ register corresponds to CLIPBOARD clipboard (usually used with Ctrl+C/Ctrl+V key combinations). Most commonly used.

Using Registers

• Copy to register: You can use "ay to copy to register a, where a is the register name, y is the yank command.
  • Almost the same in visual mode
• Paste from register: To paste from register, you can use "ap to paste content of register a, where a is the register name, p is the paste command.
• In insert mode: Use Ctrl + R to call up " symbol

Using Registers in Insert Mode

Press

Ctrl + R + register name

For example

Ctrl + R + " uses default register, Ctrl + R + + uses system register.

Using Registers in Terminal

When you use Vim in terminal instead of GUI version, accessing system clipboard becomes more complex, because Vim needs to include clipboard support at compile time. You can run vim --version to see if your Vim supports clipboard (look for +clipboard or +xterm_clipboard).

If your Vim supports clipboard, you can interact with system clipboard in the following ways:

• Use "*y to copy to system’s PRIMARY clipboard.
• Use "+y to copy to system’s CLIPBOARD clipboard.
• Use "*p or "+p to paste from corresponding system clipboard to Vim.

If your Vim doesn’t have clipboard support, you won’t be able to directly access system clipboard from Vim. In this case, you need to use external programs (like xclip or xsel) to help you copy Vim register content to system clipboard, or paste from system clipboard to Vim.

External Commands

Using :! to Execute External Commands

You can use :! followed by command to execute any external command. For example, if you want to see current directory contents, you can type in Vim’s command mode:

:!ls

Using :r to Read External Command Output

If you want to insert output of sed, awk or other commands into current Vim editor text, you can use :r ! command. For example, if you want to insert ls command output at current position, you can type:

:r !ls

Using :%! to Process Entire File Content Through External Command

If you want to apply sed or awk command to entire file content and replace current file content, you can use :%! followed by corresponding command. For example, use sed command to replace all “foo” with “bar” in document:

:%!sed 's/foo/bar/g'

Partial Usage

You can also specify a range to use external command only on certain parts of the file. For example, only process lines 5 to 10 through awk command:

:5,10!awk '{print $1}'

Macro Recording

1. Use q for macro recording in normal mode
   • Give register a name, say a, the full name of this register is @a
   • Press q again to end recording after recording is complete
   • Type @a to execute macro, @@ to execute last macro, 9@a to execute macro 9 times
2. +1 operation on numbers. <C-a>, can be used with macro recording to write ordered lists:
   • 1. sth, then yyp, perform <C-a> on 1, repeat

Other Features

1. Spell check. :set spell! spelllang=en_us
2. :set rnu set relative line numbers. Convenient for jumping

🔔 Prelude: No need for digging a big hole, just use it.

Golang in short

Go is

1. A modern high-level programming language that resembles C
2. Open-source, compiled, statically typed, and memory-safe

Go has

1. Simple yet powerful package management (pulls directly from GitHub)
2. Built-in concurrency primitives
3. Garbage collection (GC)
4. Lightning-fast compilation
5. Minimal syntax
6. Cross-platform compilation

Go doesn’t have

1. Classes and inheritance
2. Function overloading
3. Implicit type conversions

I use Go to

1. Say goodbye to Java’s verbose syntax
2. Build web services and microservices
3. Handle high-concurrency scenarios

Go is perfect for

1. Web services and RESTful APIs
2. Microservices architecture
3. Network programming and distributed systems

Go might not be ideal for

1. GUI desktop applications
2. Kernel development
3. Machine learning (Python has a stronger ecosystem)

Installing Go

1. Using OS package managers
   • Linux: apt, yum, snap
   • macOS: brew
   • Windows: choco, scoop, etc.
2. Download official precompiled binaries
   • Already compiled, ready to use
   • Set up path and links manually
3. Verify with go version

Hello World

// This is a comment
/* This is
   a multiline
   comment */
package main // This is the main package

// No semicolons at line endings

import (
    "fmt"
    "math"
) // Importing other packages

const myConstant int = 0 // Constants need explicit initialization

func main() {
    fmt.Println("helloworld")
    // Package names -> lowercase
    // Lowercase in package -> myConstant -> package-private
    // Capitalized -> Println() -> exported (public)
}

Types

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr // Has pointers but no pointer arithmetic

byte // alias for uint8

rune // alias for int32
     // Represents a Unicode code point
     // From ancient Nordic "rune"

float32 float64

complex64 complex128

// Zero value for reference types is nil

// Type assertion
t, ok := variable.(int) // Returns two values, ok indicates success
                        // Panics if ok is not captured and type is wrong

// Type conversion
var myInt int32 = 42
myAnotherInt := int64(myInt) // Type conversion
                             // No direct conversion between bool and int
                             // Generally, single characters and numbers can convert
                             // Otherwise, only conversions within same type family

Variables and Functions

var hi bool = true // Variables outside functions must have explicit types

func myFunc(x, y int) (int, int) {
    innerHi := "hi" // Inside functions, use := for type inference
    const hiConst = "hi again" // Constants cannot use :=
    return x + 1, y + 1
}

func MapFilter[T any, R comparable](
    slice []T,
    mapper func(T) R,
    predicate func(R) bool,
) func(options ...int) (filtered []R, count int, err error) {
    // Returns a function
    return func(options ...int) (filtered []R, count int, err error) {
        // Implementation
        return
    }
}
// A complete function signature example
// Note the second func starts parameters
// The last func starts return type -> returns a function
// T is generic, R is constraint, but they're essentially the same thing

func(x int) int { return x * 2 } // Anonymous function definition

Arrays, Slices, and Maps

// Arrays - fixed length
var arr [5]int = [5]int{1, 2, 3, 4, 5}
arr2 := [...]int{1, 2, 3} // Compiler infers length

// Slices - dynamic length
var slice []int = []int{1, 2, 3}
slice2 := make([]int, 5)     // Length 5
slice3 := make([]int, 5, 10) // Length 5, capacity 10

// Maps
var m map[string]int = map[string]int{"one": 1, "two": 2}
m2 := make(map[string]int)
m2["key"] = 42

// Check if key exists
value, exists := m["key"]
if exists {
    fmt.Println(value)
}

Control Flow

// Only for loops exist
// All parts of for loop are optional
for i := 0; i < 10; i++ {
    // Loop body
}

// Infinite loop
for {
    // Equivalent to while(true)
}

// Condition loop
i := 0
for i < 10 {
    i++
}

for i, v := range expression {} // Iterate over iterables
                                // Similar to Python's for..in
                                // Directly provides index and value
                                // No enumerate function needed
                                // Use _, v to ignore index

// if statement
if v := 5; v < 6 { // Can assign in condition
    // Condition body
}

// switch statement
switch x := 5; x { // x is optional
    case 1:
        fmt.Println("one")
    case 2, 3, 4:      // Multiple values
        fmt.Println("two, three or four")
    default:
        fmt.Println("other")
}

// Type switch
switch v := x.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    default:
        fmt.Printf("unknown type\n")
}

Defer and Channels

// defer - deferred execution (stack structure, LIFO)
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
panic("!")

// Output order: 3 2 1 panic
// defer provides stack-based deferred execution
// panic triggers deferred functions

// channel - channels (queue structure, FIFO)
func channelExample() {
    myChan := make(chan int, 2) // Buffer size 2
    myChan <- 10 // 10 goes in
    myChan <- 20 // then 20 goes in
    took := <-myChan      // took is 10
    fmt.Println(<-myChan) // 20
}

func blockingChannel() {
    ch := make(chan int) // Unbuffered channel
    // ch <- 1           // Will block! Need another goroutine to receive

    // Correct approach
    go func() {
        ch <- 1
    }()
    fmt.Println(<-ch)
}

// Channels provide a queue-like or pipe-like structure
// FIFO

Pointers

// Go has pointers
// Useful when referencing large data
// Go's design philosophy is very close to C-family languages
// Fun fact: When passing pointers to functions, both C and Go copy the pointer
// All parameters are pass-by-value in both languages
// But C++ has completely different reference passing mechanism

func main() {
    var myPtr *int
    // var anotherPtr uintptr  // uintptr is integer type, not pointer

    i := 42
    myPtr = &i // Take address

    fmt.Println(*myPtr) // Dereference, outputs 42
    *myPtr = 43         // Modify through pointer
    fmt.Println(i)      // Outputs 43

    // No pointer arithmetic
}

Format Verbs

Reference:

String Formatting

// %[flags][width][.precision]verb

// Width and alignment
fmt.Printf("%5d\n", 42)      // "   42" right-aligned, width 5
fmt.Printf("%-5d\n", 42)     // "42   " left-aligned, width 5
fmt.Printf("%05d\n", 42)     // "00042" zero-padded

// String alignment
fmt.Printf("|%10s|\n", "hello")   // "|     hello|" right-aligned
fmt.Printf("|%-10s|\n", "hello")  // "|hello     |" left-aligned
fmt.Printf("|%10s|\n", "你好")     // "|        你好|" handles Chinese

pi := 3.14159265359

// Decimal precision
fmt.Printf("%.2f\n", pi)     // "3.14" 2 decimal places
fmt.Printf("%.4f\n", pi)     // "3.1416" 4 decimal places (rounded)
fmt.Printf("%8.2f\n", pi)    // "    3.14" width 8, 2 decimals
fmt.Printf("%08.2f\n", pi)   // "00003.14" zero-padded

// Scientific notation precision
fmt.Printf("%.3e\n", pi)     // "3.142e+00"
fmt.Printf("%.3g\n", 0.00012345)  // "0.000123" auto format

// + flag: show sign
fmt.Printf("%+d\n", 42)      // "+42"
fmt.Printf("%+f\n", -3.14)   // "-3.140000"

// # flag: show base prefix
fmt.Printf("%#x\n", 255)     // "0xff"
fmt.Printf("%#o\n", 8)       // "010"
fmt.Printf("%#b\n", 5)       // "0b101"

// Space: add space for positive numbers
fmt.Printf("% d\n", 42)      // " 42"
fmt.Printf("% d\n", -42)     // "-42"

// Making tables
fmt.Printf("%-10s %8.2f %5d\n", "Apple", 3.99, 10)
fmt.Printf("%-10s %8.2f %5d\n", "Banana", 12.5, 5)
// Output:
// Apple          3.99    10
// Banana        12.50     5

// Dynamic width and precision
width := 10
precision := 2
fmt.Printf("%*.*f\n", width, precision, pi)  // Width and precision from variables

Structs

type MyStruct struct {
    x int  // Private field (package-visible)
    Y int  // Public field (exported)
}

// No need for "->" with struct pointers, Go handles it

// Value receiver method
func (s MyStruct) myFunc(x, y int) (int, int) {
    return s.x + x, s.Y + y
}

// Pointer receiver method
func (s *MyStruct) modify(x int) {
    s.x = x  // Can modify original struct
}

// Pointer receivers can accept values and pointers
// Value receivers can also accept both, Go handles it automatically
// In a sense, pointer parameters have "broader" acceptance

// Struct tags
type User struct {
    Name string `json:"name" xml:"user-name"`
    Age  int    `json:"age,omitempty"`
    Pass string `json:"-"` // Ignore this field
}

// Reading tags with reflection
import "reflect"
field, _ := reflect.TypeOf(User{}).FieldByName("Name")
fmt.Println(field.Tag.Get("json"))  // "name"

Interfaces

// Interfaces define method signatures
// No explicit implementation needed - types automatically implement interfaces
// Interfaces can embed other interfaces

type MyInterface interface {
    myAdd(x, y int) int
}

type MyStruct struct{
    x int
    y int
}

func (s MyStruct) myAdd(x, y int) int { // Implements myAdd
    return x + y
}

// Now MyStruct implements MyInterface

// Empty interface
interface{} // or any (Go 1.18+)
// Can store any type
var x interface{} = 42
x = "hello"
x = []int{1, 2, 3}

// Empty struct
var y struct{} = struct{}{}
// Takes no memory, often used as signal

Error Handling

// error is a built-in interface
type error interface {
    Error() string
}

// Functions typically return result and error
result, err := doSomething()
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}

// Custom error
type MyError struct {
    msg string
}

func (e MyError) Error() string {
    return e.msg
}

// Create errors with errors package
import "errors"
err := errors.New("something went wrong")

// Format errors with fmt.Errorf
err := fmt.Errorf("invalid value: %d", value)

Concurrency

// Use go keyword to start goroutines
func main() {
    go say("world")
    say("hello")

    // Need to wait for goroutines to finish
    time.Sleep(time.Second)
}

// See Defer and Channels section for channel creation

// Sending to full channel blocks
// Receiving from empty channel blocks

// Close channel
close(myChan)
// Note: Only senders should close channels

// Use select to handle multiple channels
// Like concurrent switch
// select blocks until one case can proceed
// When multiple cases ready, randomly picks one
select {
    case v := <-ch1:
        fmt.Println("received from ch1:", v)
    case ch2 <- x:
        fmt.Println("sent to ch2")
    case <-quit:
        fmt.Println("quit")
        return
    default:
        fmt.Println("no communication")
}

// Mutex
import "sync"
var mu sync.Mutex

mu.Lock()
// Critical section
mu.Unlock()

// Use defer to ensure unlock
mu.Lock()
defer mu.Unlock()
// Critical section

// Directional channels
func send(ch chan<- int) { ch <- 42 }      // Send-only
func recv(ch <-chan int) { val := <-ch }   // Receive-only

// Check if channel is closed
v, ok := <-ch  // ok is false if channel closed and empty

Various Magic 🪄

...

// 1. Variadic functions
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// Calling
sum(1, 2, 3)      // Can pass multiple
sum(1)            // Can pass one
sum()             // Can pass none

// 2. Expanding slices
numbers := []int{1, 2, 3, 4}
result := sum(numbers...)  // Expand to multiple arguments

// Common usage
slice1 := []int{1, 2}
slice2 := []int{3, 4}
combined := append(slice1, slice2...)  // Expand slice2

// 3. Array literals
arr := [...]int{1, 2, 3, 4, 5}  // Compiler calculates length, result is [5]int

// Useful with indices
arr := [...]string{
    0: "zero",
    5: "five",   // Array length is 6
}

Notes:

1. Variadic parameter must be last
2. Inside function, variadic parameter is slice type
3. Types must match when expanding

Initialization Tricks

// Initialize array with indices
arr := [10]int{0: 1, 9: 10}  // 0th is 1, 9th is 10, rest are 0

// Initialize map with keys
m := map[string]int{
    "a": 1,
    "b": 2,
}

// Partial struct initialization
type Point struct{ X, Y int }
p := Point{Y: 10}  // X is 0, Y is 10

iota Enumerations

// iota starts at 0 in each const declaration
const (
    A = iota  // 0
    B         // 1
    C         // 2
)

// Skip values
const (
    _  = iota  // 0 (skip)
    KB = 1 << (10 * iota)  // 1 << 10 = 1024
    MB         // 1 << 20 = 1048576
    GB         // 1 << 30 = 1073741824
)

// Bit flag enums
type Permission int

const (
    Read Permission = 1 << iota  // 1
    Write                        // 2
    Execute                      // 4
)

// Usage
var perm Permission = Read | Write  // Combine permissions

// Check permission
if perm&Read != 0 {
    fmt.Println("Has read permission")
}

// Add permission
perm |= Execute

// Remove permission
perm &^= Write

Type Aliases vs Type Definitions

// Type alias (Go 1.9+) - completely equivalent
type MyInt = int  // MyInt is int, interchangeable

// Type definition - creates new type
type MyInt int    // MyInt is new type, cannot assign directly

// Example
type Celsius float64
type Fahrenheit float64

var c Celsius = 100
var f Fahrenheit = 212
// f = c  // Error! Type mismatch
f = Fahrenheit(c * 9/5 + 32)  // Need explicit conversion

make vs new

new(T)      // Returns *T, zero value allocation; commonly for simple structs
make(...)   // Only for slice/map/chan, returns initialized value (not pointer)

// Examples
p := new(int)           // *int, value is 0
s := make([]int, 5)     // []int, length 5, initialized
m := make(map[string]int) // map[string]int, initialized

Go Gotchas and Important Notes

Slice Underlying Array Sharing

// Passing slice copies slice header (pointer, len, cap), shares underlying array
s := []int{1, 2, 3}
t := s[:2]         // Shares underlying array with s
s = append(s, 4)   // May trigger reallocation, t no longer shares

// Modifying shared underlying array
s := []int{1, 2, 3, 4, 5}
t := s[1:3]  // [2, 3]
t[0] = 99    // s becomes [1, 99, 3, 4, 5]

Map Randomness

// Map iteration order is random, don't rely on order
m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
    fmt.Println(k, v)  // Order may differ each run
}

// Cannot take address of map elements
// &m["key"]  // Compile error: map values not addressable

String Bytes vs Characters

// len(string) returns byte count, not character count
s := "你好"
fmt.Println(len(s))  // 6 (3 bytes per Chinese character)

// for range string iterates by rune (UTF-8 decoded)
for i, r := range "你好" {
    fmt.Printf("%d: %c\n", i, r)  // 0: 你, 3: 好
}

// s[i] gives byte
fmt.Printf("%x\n", "你"[0])  // e4 (first byte)

// Strings are immutable, convert to []byte or []rune to modify
s := "hello"
// s[0] = 'H'  // Error!
bs := []byte(s)
bs[0] = 'H'
s = string(bs)  // "Hello"

Interface nil Pitfall

// Interface value is (type, data) pair
// When type != nil, even if data == nil, interface is not nil

type MyErr struct{}
func (e *MyErr) Error() string { return "error" }

var e error
fmt.Println(e == nil)  // true

var pe *MyErr = nil
e = pe
fmt.Println(e == nil)  // false! type=*MyErr, data=nil

Loop Variable Pitfall

// Loop variables reuse same memory location
// Be careful in goroutines/closures

// Wrong
for i, v := range []int{1, 2, 3} {
    go func() {
        fmt.Println(i, v)  // May all print 2, 3
    }()
}

// Correct: rebind
for i, v := range []int{1, 2, 3} {
    i, v := i, v  // Create new local variables
    go func() {
        fmt.Println(i, v)
    }()
}