<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Eissa Saber</title>
    <description>The latest articles on DEV Community by Eissa Saber (@eissapk).</description>
    <link>https://dev.to/eissapk</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4086423%2F2619d351-2d01-41c7-ae72-9db94801f1e6.jpeg</url>
      <title>DEV Community: Eissa Saber</title>
      <link>https://dev.to/eissapk</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/eissapk"/>
    <language>en</language>
    <item>
      <title>10 Linux Tools That Upgraded My Terminal Workflow</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Fri, 20 Nov 2026 14:04:28 +0000</pubDate>
      <link>https://dev.to/eissapk/10-linux-tools-that-upgraded-my-terminal-workflow-3g41</link>
      <guid>https://dev.to/eissapk/10-linux-tools-that-upgraded-my-terminal-workflow-3g41</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://www.eissa.top/blog/10-linux-tools-that-upgraded-my-terminal-workflow" rel="noopener noreferrer"&gt;my blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;I was using the same Linux tools for years and never thought to question them. Then I found these 10 alternatives — all faster, cleaner, and smarter than what they replace — and realized how much time I was leaving on the table.&lt;/p&gt;

&lt;h2&gt;
  
  
  I was comfortable. That was the problem.
&lt;/h2&gt;

&lt;p&gt;For years I used the same terminal tools that came with Linux. find, grep, cat, ls, htop. I knew them well enough to get things done, so I never looked for anything else. Comfortable is a tricky place to be. You stop noticing the small annoyances — the long flags you have to look up every time, the messy output you have to squint at, the terminal session you lose and have to rebuild from scratch. I just thought that was part of working in the terminal. Turns out it doesn't have to be. Every tool in this list is faster, easier to read, or smarter than the one it replaces. Some are all three.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. fd vs find — same job, half the typing
&lt;/h2&gt;

&lt;p&gt;find does the job, but the syntax is frustrating. To find all .js files and skip node_modules, you have to write something like find . -name "&lt;em&gt;.js" -not -path "&lt;/em&gt;/node_modules/*". Every time. And if you get the flag order wrong, you get a cryptic error. fd is faster than find and the syntax makes sense. You just type what you're looking for. It respects .gitignore automatically so ignored folders stay out of your results without any extra flags. The output has colors that make it easy to tell files from folders. On a big project, fd also returns results noticeably faster than find because it runs searches in parallel. I still reach for find on remote servers where fd isn't around, but on my own machine I haven't typed find in months.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# find needs this to skip node_modules:&lt;/span&gt;
find . -name &lt;span class="s2"&gt;"*.js"&lt;/span&gt; -not -path &lt;span class="s2"&gt;"*/node_modules/*"&lt;/span&gt;

&lt;span class="c"&gt;# fd just does it automatically:&lt;/span&gt;
fd -e js

&lt;span class="c"&gt;# more examples:&lt;/span&gt;
fd config                     &lt;span class="c"&gt;# find anything with "config" in the name&lt;/span&gt;
fd -e js src/                 &lt;span class="c"&gt;# find .js files only inside src/&lt;/span&gt;
fd -H .env                    &lt;span class="c"&gt;# include hidden files in the search&lt;/span&gt;
fd -e log --older-than 7d     &lt;span class="c"&gt;# find log files older than 7 days&lt;/span&gt;
fd run -x chmod +x            &lt;span class="c"&gt;# find files named run and make them executable&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  2. tmux vs plain terminals — sessions that survive
&lt;/h2&gt;

&lt;p&gt;A regular terminal gives you one session that dies the moment you close the window. If your SSH connection drops or you accidentally close the terminal, everything running inside it is gone. tmux keeps your sessions alive in the background. You can have multiple windows and split panes inside a single session, detach from it, close the terminal completely, and come back later to find everything exactly where you left it. The difference is especially obvious when working on multiple projects at the same time — with plain terminals you're constantly rebuilding your setup, with tmux you just switch sessions.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# plain terminal: close window = lose everything&lt;/span&gt;
&lt;span class="c"&gt;# tmux: detach = session keeps running&lt;/span&gt;

tmux new -s blog              &lt;span class="c"&gt;# start a session called blog&lt;/span&gt;
tmux new -s api               &lt;span class="c"&gt;# start another for your API project&lt;/span&gt;
tmux ls                       &lt;span class="c"&gt;# see all your running sessions&lt;/span&gt;
tmux attach -t blog           &lt;span class="c"&gt;# jump back into the blog session&lt;/span&gt;
Ctrl+b d                      &lt;span class="c"&gt;# detach (session stays alive)&lt;/span&gt;
Ctrl+b %                      &lt;span class="c"&gt;# split screen left and right&lt;/span&gt;
Ctrl+b &lt;span class="s2"&gt;"                      # split screen top and bottom
Ctrl+b arrow                  # move between panes
Ctrl+b c                      # create a new window inside the session
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  3. fzf vs Ctrl+R — fuzzy search that actually works
&lt;/h2&gt;

&lt;p&gt;The built-in Ctrl+R history search is linear. You type and it looks for an exact match from the start of the command. If you can't remember the first word, you're stuck. fzf replaces that with fuzzy search — type a few letters from anywhere in the command and it shows every match instantly as you type. It's faster and it finds things the old search would miss. Beyond history, fzf plugs into everything: file pickers, git branch switching, process killing. It turns any list into an interactive searchable menu. Once you have it wired into your shell you wonder how you worked without it.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# old Ctrl+R: exact match from the start only&lt;/span&gt;
&lt;span class="c"&gt;# fzf Ctrl+R: fuzzy match from anywhere in the command&lt;/span&gt;

vim &lt;span class="nv"&gt;$(&lt;/span&gt;fzf&lt;span class="o"&gt;)&lt;/span&gt;                           &lt;span class="c"&gt;# fuzzy pick a file to open&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; &lt;span class="nv"&gt;$(&lt;/span&gt;fd -t d &lt;span class="o"&gt;|&lt;/span&gt; fzf&lt;span class="o"&gt;)&lt;/span&gt;                  &lt;span class="c"&gt;# fuzzy pick a directory to jump into&lt;/span&gt;
fzf --preview &lt;span class="s1"&gt;'bat {}'&lt;/span&gt;               &lt;span class="c"&gt;# browse files with a live preview&lt;/span&gt;
git checkout &lt;span class="nv"&gt;$(&lt;/span&gt;git branch &lt;span class="o"&gt;|&lt;/span&gt; fzf&lt;span class="o"&gt;)&lt;/span&gt;     &lt;span class="c"&gt;# fuzzy pick a branch to switch to&lt;/span&gt;
&lt;span class="nb"&gt;kill&lt;/span&gt; &lt;span class="nv"&gt;$(&lt;/span&gt;ps aux &lt;span class="o"&gt;|&lt;/span&gt; fzf &lt;span class="o"&gt;|&lt;/span&gt; awk &lt;span class="s1"&gt;'{print $2}'&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# pick a running process to kill&lt;/span&gt;
docker stop &lt;span class="nv"&gt;$(&lt;/span&gt;docker ps &lt;span class="o"&gt;|&lt;/span&gt; fzf &lt;span class="o"&gt;|&lt;/span&gt; awk &lt;span class="s1"&gt;'{print $1}'&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# fuzzy stop a container&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  4. bat vs cat — the same file, but readable
&lt;/h2&gt;

&lt;p&gt;cat dumps raw text to the screen. No colors, no line numbers, no structure. For a short file that's fine, but for a config file or a script it means you have to do all the reading work yourself. bat is a drop-in replacement for cat that adds syntax highlighting, line numbers, and git change indicators on the side. The file is readable the moment it appears on screen. It's not just cosmetic — colors give you structural information before you've read a single word. bat also uses a pager automatically for long files, and steps out of the way when you're piping output so it doesn't break your scripts.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# cat: raw text, no context&lt;/span&gt;
&lt;span class="c"&gt;# bat: same file, syntax highlighted with line numbers&lt;/span&gt;

bat config.js                        &lt;span class="c"&gt;# JavaScript with proper highlighting&lt;/span&gt;
bat src/index.ts                     &lt;span class="c"&gt;# TypeScript, same thing&lt;/span&gt;
bat -n notes.txt                     &lt;span class="c"&gt;# line numbers only, no extra decoration&lt;/span&gt;
bat --diff file.js                   &lt;span class="c"&gt;# highlight only the lines changed in git&lt;/span&gt;
bat /etc/hosts                       &lt;span class="c"&gt;# config files are much easier to read&lt;/span&gt;
fzf --preview &lt;span class="s1"&gt;'bat --color=always {}'&lt;/span&gt; &lt;span class="c"&gt;# use bat as a preview inside fzf&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  5. ripgrep vs grep — faster search with smarter defaults
&lt;/h2&gt;

&lt;p&gt;grep -r works but it searches everything including node_modules, .git, and binary files unless you tell it not to. On a real project that means a lot of noise in the results and a noticeable wait before they appear. ripgrep is significantly faster than grep — it searches in parallel and uses smarter algorithms — and it respects .gitignore by default so you only see results from files that matter. The output format is also cleaner: file name, line number, and the matched text with the match highlighted. No extra flags needed to get readable results.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# grep: slow on large projects, searches node_modules too&lt;/span&gt;
grep -r &lt;span class="s2"&gt;"useState"&lt;/span&gt; . --include=&lt;span class="s2"&gt;"*.js"&lt;/span&gt; --exclude-dir=node_modules

&lt;span class="c"&gt;# rg: fast, skips ignored files automatically&lt;/span&gt;
rg &lt;span class="s2"&gt;"useState"&lt;/span&gt;

&lt;span class="c"&gt;# more examples:&lt;/span&gt;
rg &lt;span class="s2"&gt;"useState"&lt;/span&gt; src/             &lt;span class="c"&gt;# search only inside src/&lt;/span&gt;
rg -t js &lt;span class="s2"&gt;"import"&lt;/span&gt;              &lt;span class="c"&gt;# search only JavaScript files&lt;/span&gt;
rg -i &lt;span class="s2"&gt;"todo"&lt;/span&gt;                   &lt;span class="c"&gt;# case-insensitive&lt;/span&gt;
rg -l &lt;span class="s2"&gt;"API_KEY"&lt;/span&gt;                &lt;span class="c"&gt;# only show file names, not every match&lt;/span&gt;
rg -n &lt;span class="s2"&gt;"useEffect"&lt;/span&gt; --stats      &lt;span class="c"&gt;# show match count and how long it took&lt;/span&gt;
rg &lt;span class="s2"&gt;"function"&lt;/span&gt; -A 3             &lt;span class="c"&gt;# show 3 lines of context after each match&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  6. eza vs ls — a directory listing you can actually use
&lt;/h2&gt;

&lt;p&gt;ls -la gives you information but it's hard to scan. File sizes are in raw bytes, everything is the same color, and there's no git information. eza gives you the same information but in a format you can read at a glance. Folders and files have different colors, sizes are in KB and MB, and you can see which files have uncommitted git changes without running a separate command. There's also a tree view that works well for exploring unfamiliar projects. It sounds like a minor upgrade but ls is one of the most-typed commands in the terminal, so a better version of it adds up quickly.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# ls: hard to scan, sizes in bytes, no colors by default&lt;/span&gt;
ls -la

&lt;span class="c"&gt;# eza: colors, readable sizes, git status&lt;/span&gt;
eza -la

&lt;span class="c"&gt;# more examples:&lt;/span&gt;
eza -la --git                  &lt;span class="c"&gt;# show git status next to each file&lt;/span&gt;
eza --tree                     &lt;span class="c"&gt;# tree view of the directory&lt;/span&gt;
eza --tree --level=2           &lt;span class="c"&gt;# tree view, 2 levels deep&lt;/span&gt;
eza -la --sort=size            &lt;span class="c"&gt;# sort by file size&lt;/span&gt;
eza -la --sort=modified        &lt;span class="c"&gt;# sort by when the file was last changed&lt;/span&gt;
eza -la --icons                &lt;span class="c"&gt;# show file type icons (needs a Nerd Font)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  7. btop vs htop — a monitor you can read at a glance
&lt;/h2&gt;

&lt;p&gt;htop works, but the layout takes a moment to process every time you open it. The numbers are there, but there's no visual shape to them. btop shows the same CPU, memory, disk, and network information but with graphs, so you immediately see trends — memory climbing, CPU spiking during a build, network activity from a background process. It also handles everything in one place where htop often needs you to switch views. I keep btop open in a tmux pane while working so I can glance at it without switching windows.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;btop                           &lt;span class="c"&gt;# open btop&lt;/span&gt;

&lt;span class="c"&gt;# keyboard shortcuts inside btop:&lt;/span&gt;
&lt;span class="c"&gt;# F2 or o   open options and settings&lt;/span&gt;
&lt;span class="c"&gt;# f         filter processes by name&lt;/span&gt;
&lt;span class="c"&gt;# k         kill the selected process&lt;/span&gt;
&lt;span class="c"&gt;# /         search through running processes&lt;/span&gt;
&lt;span class="c"&gt;# m         toggle between memory display modes&lt;/span&gt;
&lt;span class="c"&gt;# 1-4       switch between CPU graph styles&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  8. dust vs du — disk usage that makes sense immediately
&lt;/h2&gt;

&lt;p&gt;du -sh * shows directory sizes but the output is unsorted and flat. You have to pipe it through sort -h just to see the biggest folders first, and even then you can't see what's inside them. dust shows disk usage as a sorted tree with the biggest items at the top. You can immediately see which folder is eating your space and drill into it to find exactly which files are responsible. What used to take me several commands and a minute of hunting now takes one.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# du: unsorted, no nesting, need extra pipe to sort&lt;/span&gt;
du -sh * &lt;span class="o"&gt;|&lt;/span&gt; sort -h

&lt;span class="c"&gt;# dust: sorted tree, biggest items at the top&lt;/span&gt;
dust

&lt;span class="c"&gt;# more examples:&lt;/span&gt;
dust ~/projects                &lt;span class="c"&gt;# check a specific folder&lt;/span&gt;
dust -d 1                      &lt;span class="c"&gt;# only show top-level folders, no nesting&lt;/span&gt;
dust -d 3                      &lt;span class="c"&gt;# go 3 levels deep into the tree&lt;/span&gt;
dust -r                        &lt;span class="c"&gt;# reverse order, smallest at top&lt;/span&gt;
dust -X node_modules           &lt;span class="c"&gt;# exclude node_modules from results&lt;/span&gt;
dust -n 10                     &lt;span class="c"&gt;# show only the top 10 largest items&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  9. greenclip vs the default clipboard — history that doesn't disappear
&lt;/h2&gt;

&lt;p&gt;Linux has no clipboard history by default. When you copy something new, the previous thing is gone forever. You don't notice this until you copy a URL, copy something else for a second, and then realize you need that URL back. greenclip runs quietly in the background and saves everything you copy. When you need something from earlier you open it through rofi and pick from the list. It searches as you type so even a long history is fast to navigate. It's one of those tools that becomes invisible almost immediately because it just quietly stops a frustrating thing from happening.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# default clipboard: copy something new = lose the old one&lt;/span&gt;
&lt;span class="c"&gt;# greenclip: keeps a searchable history of everything you copy&lt;/span&gt;

greenclip daemon &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;                   &lt;span class="c"&gt;# run in background, add to autostart&lt;/span&gt;
rofi -modi &lt;span class="s2"&gt;"clipboard:greenclip print"&lt;/span&gt; -show clipboard  &lt;span class="c"&gt;# open the history&lt;/span&gt;
greenclip print                      &lt;span class="c"&gt;# print history to terminal&lt;/span&gt;
greenclip clear                      &lt;span class="c"&gt;# clear all saved history&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  10. starship vs oh-my-zsh — a fast prompt that works everywhere
&lt;/h2&gt;

&lt;p&gt;A lot of people who want a better prompt install oh-my-zsh. It works, but it's heavy — it loads a lot of things you probably don't need and adds real startup time to every terminal you open. starship gives you everything you actually want from a prompt — git branch, uncommitted changes, active language version, last command duration, exit code color — and does it in a fraction of the time. The startup is nearly instant because it's written in Rust. It also works in bash, zsh, fish, and every other shell without any changes, so you don't have to switch to zsh just to get a better prompt. If you're already on zsh, you don't need oh-my-zsh. starship does more and costs less.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# oh-my-zsh: zsh only, slow to load, lots of overhead
# starship: any shell, starts instantly, shows what you actually need
&lt;/span&gt;
&lt;span class="c1"&gt;# starship.toml — one config file for all shells
&lt;/span&gt;
&lt;span class="k"&gt;[git_branch]&lt;/span&gt;
&lt;span class="na"&gt;format&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"on [$symbol$branch]($style) "&lt;/span&gt;
&lt;span class="na"&gt;symbol&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;" "&lt;/span&gt;

&lt;span class="k"&gt;[git_status]&lt;/span&gt;
&lt;span class="na"&gt;format&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s1"&gt;'([\[$all_status$ahead_behind\]]($style) )'&lt;/span&gt;

&lt;span class="k"&gt;[cmd_duration]&lt;/span&gt;
&lt;span class="na"&gt;min_time&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2_000&lt;/span&gt;
&lt;span class="na"&gt;format&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"took [$duration](yellow) "&lt;/span&gt;

&lt;span class="k"&gt;[nodejs]&lt;/span&gt;
&lt;span class="na"&gt;format&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"via [⬢ $version](green) "&lt;/span&gt;

&lt;span class="k"&gt;[python]&lt;/span&gt;
&lt;span class="na"&gt;format&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"via [🐍 $version](yellow) "&lt;/span&gt;

&lt;span class="k"&gt;[character]&lt;/span&gt;
&lt;span class="na"&gt;success_symbol&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"[❯](green)"&lt;/span&gt;
&lt;span class="na"&gt;error_symbol&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"[❯](red)"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The old tools still work. These ones just work better.
&lt;/h2&gt;

&lt;p&gt;None of the tools I switched from were broken. grep finds text. find finds files. cat shows content. They all do what they say. But faster search, readable output, and sessions that survive closing the terminal are not small things — they're things you interact with dozens of times a day. The time you save on each one doesn't feel like much by itself, but it compounds. If you want to start somewhere, pick ripgrep or bat first. They're the easiest to drop in and the improvement is obvious within the first hour.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I write about web development, Linux and IoT at &lt;a href="https://www.eissa.top" rel="noopener noreferrer"&gt;eissa.top&lt;/a&gt;. This post first appeared &lt;a href="https://www.eissa.top/blog/10-linux-tools-that-upgraded-my-terminal-workflow" rel="noopener noreferrer"&gt;there&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>linux</category>
      <category>terminal</category>
      <category>productivity</category>
      <category>cli</category>
    </item>
    <item>
      <title>20 Linux Commands I Use Daily on Void Linux + DWM</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Fri, 20 Nov 2026 14:03:29 +0000</pubDate>
      <link>https://dev.to/eissapk/20-linux-commands-i-use-daily-on-void-linux-dwm-1no7</link>
      <guid>https://dev.to/eissapk/20-linux-commands-i-use-daily-on-void-linux-dwm-1no7</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://www.eissa.top/blog/20-linux-commands-you-need-to-know" rel="noopener noreferrer"&gt;my blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;I switched to Void Linux with DWM and never looked back — but the terminal was intimidating at first. Here are the 20 commands I actually reach for every single day, with honest context about when they saved me and when they nearly broke things.&lt;/p&gt;

&lt;h2&gt;
  
  
  My first week on Void Linux was humbling
&lt;/h2&gt;

&lt;p&gt;I moved from a standard Ubuntu setup to Void Linux running DWM, and the first thing I noticed was how much I suddenly needed the terminal for everything. No GUI package manager, no file manager open by default — just a clean tiling window manager and a terminal emulator staring back at me. It was uncomfortable at first, then extremely freeing. The thing is, you don't need to memorize hundreds of commands. I've been doing this for a while now and I still lean on the same 20 or so for most of my day. These are the ones that actually stuck.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. pwd — where am I right now?
&lt;/h2&gt;

&lt;p&gt;Sounds almost too basic to mention, but on a fresh Void install with DWM, I lost track of my location in the filesystem constantly during the first week. pwd (print working directory) is the fastest way to reorient yourself. I still run it more than I'd admit.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;pwd&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  2. ls — what's in here?
&lt;/h2&gt;

&lt;p&gt;The bare ls works, but I always use it with flags. -l gives a proper list with permissions and sizes, -a reveals dotfiles (your .bashrc, .config folder, all the hidden stuff). On Void, most of what you care about configuring lives in dotfiles, so -a becomes muscle memory pretty fast.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ls
ls -l
ls -la
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  3. cd — navigate the filesystem
&lt;/h2&gt;

&lt;p&gt;You'll type this more than any other command. Two shortcuts that save time every day: cd .. moves up one level, cd ~ drops you home from anywhere. When you're three directories deep in a project and need to get back fast, these matter.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; projects
&lt;span class="nb"&gt;cd&lt;/span&gt; ..
&lt;span class="nb"&gt;cd&lt;/span&gt; ~
&lt;span class="nb"&gt;cd&lt;/span&gt; /etc
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  4. mkdir — create folders instantly
&lt;/h2&gt;

&lt;p&gt;The -p flag is the one that actually matters. It creates the full nested path in a single command without complaining that intermediate directories don't exist yet. I use this constantly when scaffolding new Next.js projects from the terminal.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;mkdir projects
mkdir -p app/src/components
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  5. touch — create files without opening anything
&lt;/h2&gt;

&lt;p&gt;touch creates empty files instantly. Technically it also updates timestamps on existing files, but in practice I use it purely for scaffolding — getting a project structure laid out before I start writing a single line of code.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;touch notes.txt
touch index.js style.css
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  6. cp — copy files and directories
&lt;/h2&gt;

&lt;p&gt;Simple enough, but don't forget -r when copying a whole directory. I skipped it once, got an error, and spent five minutes confused. The r stands for recursive — it copies everything inside the folder too.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;cp file.txt backup.txt
cp -r folder backup-folder
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  7. mv — move or rename anything
&lt;/h2&gt;

&lt;p&gt;mv does two jobs: it moves files to a new location, and it renames them by 'moving' to a new name in the same place. Renaming a misnamed file mid-project without leaving the terminal is genuinely satisfying.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;mv old.txt new.txt
mv screenshot.png ~/Pictures
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  8. rm — delete permanently (no undo)
&lt;/h2&gt;

&lt;p&gt;This one is serious. There's no Recycle Bin in the terminal. Once it's gone, it's gone. Use -r for directories. The -f flag forces deletion without confirmation — powerful but dangerous. I once ran rm -rf with a slightly wrong path and deleted an entire project folder. Always double-check what you're about to delete, especially with wildcards or -f.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;rm notes.txt
rm -r old-folder
rm -rf cache-folder
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  9. cat — peek at a file without opening an editor
&lt;/h2&gt;

&lt;p&gt;I use cat constantly to check config files, read .env examples, or quickly verify that a script looks right. It just dumps the file contents to the terminal. No frills. On Void Linux where I'm editing configuration files often, this saves a lot of editor round-trips.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;cat .env.example
cat /etc/hosts
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  10. nano — friendly terminal editor for quick edits
&lt;/h2&gt;

&lt;p&gt;I use Vim for real development (more on that in another post), but for quick config edits — changing a systemd unit file, tweaking a cron job — nano is just faster to think in. Ctrl+O to save, Ctrl+X to exit. No mode confusion.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;nano /etc/hosts
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  11. grep — search inside files like a surgeon
&lt;/h2&gt;

&lt;p&gt;This one sneaks up on you. At first it seems fiddly. Then one day you use grep -r to hunt a hardcoded API URL across an entire codebase and find it in two seconds, and something clicks. The -i flag makes it case-insensitive when you're not sure about casing.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;grep &lt;span class="s2"&gt;"error"&lt;/span&gt; server.log
grep -r &lt;span class="s2"&gt;"API_KEY"&lt;/span&gt; .
grep -ri &lt;span class="s2"&gt;"todo"&lt;/span&gt; src/
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  12. find — locate files by name or pattern
&lt;/h2&gt;

&lt;p&gt;When grep searches inside files, find searches for the files themselves. The syntax is a bit verbose but it's worth learning. I use it most to find all JavaScript files in a project or track down a config file I know exists but can't remember where.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;find . -name &lt;span class="s2"&gt;"*.js"&lt;/span&gt;
find /home -name &lt;span class="s2"&gt;"config*"&lt;/span&gt;
find . -name &lt;span class="s2"&gt;"*.env"&lt;/span&gt; -type f
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  13. which — debug PATH issues instantly
&lt;/h2&gt;

&lt;p&gt;Installed Node.js but npm still throws 'command not found'? which tells you exactly where a command lives on your system — or shows nothing if it can't find it, which tells you it's a PATH problem. Saved me hours of confusion on Void where you sometimes install things outside the default PATH.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;which node
which npm
which xbps-install
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  14. history — find that command you ran three days ago
&lt;/h2&gt;

&lt;p&gt;Your shell keeps a log of every command you've run. Piping history through grep to find that long docker run command from last week is something I do at least twice a week. You can also hit Ctrl+R to do a live reverse search through history.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;history&lt;/span&gt;
&lt;span class="nb"&gt;history&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; grep docker
&lt;span class="nb"&gt;history&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; grep git
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  15. ps — see what's actually running
&lt;/h2&gt;

&lt;p&gt;ps aux dumps all running processes. On its own it's a lot of output, but combined with grep it becomes precise. When I'm building an ESP32 dashboard and something is holding onto a port, ps aux | grep node finds it immediately.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ps aux
ps aux &lt;span class="o"&gt;|&lt;/span&gt; grep node
ps aux &lt;span class="o"&gt;|&lt;/span&gt; grep mosquitto
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  16. top — live system monitor
&lt;/h2&gt;

&lt;p&gt;Task Manager for the terminal. Real-time CPU and memory, updated live. Press q to quit. I check it when my system feels sluggish or I want to see which process is eating resources. htop is a friendlier alternative if you install it — colored output, scrollable process list.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;top
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  17. kill — shut down a stuck process
&lt;/h2&gt;

&lt;p&gt;Get the process ID from ps or top, then kill it. The -9 flag (SIGKILL) is a hard stop — no cleanup, immediate termination. I reach for it when a Node.js server refuses to exit gracefully and is still holding the port I need.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;kill&lt;/span&gt; 3421
&lt;span class="nb"&gt;kill&lt;/span&gt; -9 3421
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  18. df — check remaining disk space
&lt;/h2&gt;

&lt;p&gt;The -h flag gives you human-readable output in GB and MB instead of raw block counts. I check this before recording video tutorials or doing large npm installs on my machine. Running out of disk space mid-operation causes cryptic errors that are annoying to diagnose.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;df -h
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  19. du — figure out what's eating your disk
&lt;/h2&gt;

&lt;p&gt;du -sh * is one I run regularly. It shows the size of everything in the current directory sorted by nothing, which is why I often add a pipe to sort. Perfect for finding that node_modules folder you forgot was sitting in your home directory at 800MB.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;du -sh *
du -sh node_modules
du -sh * &lt;span class="o"&gt;|&lt;/span&gt; sort -h
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  20. man — the answer is always in here
&lt;/h2&gt;

&lt;p&gt;Every command ships with a manual page. When you don't know what a flag does, man is faster than a Google search and works offline. I use it most with commands I know well but whose edge cases I've forgotten. Press q to exit, / to search inside the man page.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;man ls
man grep
man find
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The part that actually makes all of this powerful: pipes
&lt;/h2&gt;

&lt;p&gt;Once you start chaining commands with | you stop running individual commands and start building workflows. The output of one command becomes the input of the next. This is where the terminal starts feeling like it was designed for you specifically — because you can compose exactly what you need from small, focused tools.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ps aux &lt;span class="o"&gt;|&lt;/span&gt; grep mosquitto
&lt;span class="nb"&gt;history&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; grep &lt;span class="s2"&gt;"npm run"&lt;/span&gt;
ls -la &lt;span class="o"&gt;|&lt;/span&gt; grep &lt;span class="s2"&gt;".env"&lt;/span&gt;
du -sh * &lt;span class="o"&gt;|&lt;/span&gt; sort -h &lt;span class="o"&gt;|&lt;/span&gt; tail -5
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Closing thoughts
&lt;/h2&gt;

&lt;p&gt;I'm not going to tell you to memorize this list all at once — that's not how it works anyway. Pick three commands you don't know yet, force yourself to use them this week, and let the rest follow naturally. The terminal only feels foreign until it doesn't. After a month on Void Linux with nothing but DWM and a terminal, I genuinely can't imagine going back to clicking through GUIs for things I can do in two keystrokes.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I write about web development, Linux and IoT at &lt;a href="https://www.eissa.top" rel="noopener noreferrer"&gt;eissa.top&lt;/a&gt;. This post first appeared &lt;a href="https://www.eissa.top/blog/20-linux-commands-you-need-to-know" rel="noopener noreferrer"&gt;there&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>linux</category>
      <category>terminal</category>
      <category>beginners</category>
      <category>productivity</category>
    </item>
    <item>
      <title>I Almost Left VS Code for Vim — Then I Found the Vim Extension</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Fri, 20 Nov 2026 14:02:39 +0000</pubDate>
      <link>https://dev.to/eissapk/i-almost-left-vs-code-for-vim-then-i-found-the-vim-extension-7i3</link>
      <guid>https://dev.to/eissapk/i-almost-left-vs-code-for-vim-then-i-found-the-vim-extension-7i3</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://www.eissa.top/blog/top-vim-commands-and-essentials" rel="noopener noreferrer"&gt;my blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;I was convinced I needed to ditch VS Code and go full Vim. Then I discovered the VSCodeVim extension and realized I didn't have to choose. Here are the commands I learned during that obsession — and why you can use all of them without ever leaving VS Code.&lt;/p&gt;

&lt;h2&gt;
  
  
  I spent a week convinced I needed to switch to Vim
&lt;/h2&gt;

&lt;p&gt;It started with a rabbit hole. I was watching a developer on YouTube fly through code with no mouse, no clicking, no fumbling — just pure keyboard. I looked it up: Vim. I went deep. I read about how it makes you faster, how real developers use it, how VS Code is for beginners. I genuinely planned to switch. I even started practicing in the terminal. Then a friend mentioned the VSCodeVim extension, and I installed it half-skeptically. That was it. I got almost everything I was chasing without leaving the editor I already knew. This post covers the commands I learned during that obsession — all of which work perfectly inside VS Code with the extension installed.&lt;/p&gt;

&lt;h2&gt;
  
  
  The one thing you must understand first: modes
&lt;/h2&gt;

&lt;p&gt;Everything confusing about Vim comes from not internalizing this one concept. Vim isn't always in 'typing mode'. It switches between states, and what keys do depends entirely on which mode you're in. Once this clicks, Vim stops being baffling and starts being logical.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Normal Mode  → navigate, run commands, manipulate text
Insert Mode  → type text (like a regular editor)
Visual Mode  → select text with keyboard motions
Command Mode → save, quit, search, replace
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  1. i — enter Insert Mode
&lt;/h2&gt;

&lt;p&gt;Press i to start typing before the cursor. There's also a (after cursor), A (end of line), o (new line below), and O (new line above). I use o constantly — it's the fastest way to add a new line and start typing without reaching for End or Enter first.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;i   → insert before cursor
a   → insert after cursor
o   → new line below, enter insert
O   → new line above, enter insert
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  2. Esc — your escape hatch
&lt;/h2&gt;

&lt;p&gt;Whenever you're confused or things are behaving unexpectedly, press Esc. It drops you back into Normal Mode. One tip that made a real difference: remap Caps Lock to Esc in your OS settings. Esc is too far to reach comfortably for how often you'll press it, and Caps Lock is a key most people never use anyway. Works in VS Code with the extension just as well as in terminal Vim.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;Esc
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  3. :w — save the file
&lt;/h2&gt;

&lt;p&gt;In VS Code with the extension, :w triggers a save just like Ctrl+S. You don't need it since VS Code auto-saves, but the habit of typing :w between changes is something Vim users build naturally. It doesn't hurt to have it.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;:w
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  4. :q and :wq — close the editor tab
&lt;/h2&gt;

&lt;p&gt;In VS Code, :q closes the active tab. :wq saves and closes. These work with the VSCodeVim extension. Worth knowing if you ever use Vim in the terminal too — the commands are the same everywhere.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;:q
:wq
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  5. :q! — close without saving
&lt;/h2&gt;

&lt;p&gt;Discards unsaved changes and closes the tab. In VS Code this still triggers the 'unsaved changes' dialog unless you've enabled auto-save, but in terminal Vim it exits immediately. Good habit to know regardless.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;:q!
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  6. hjkl — move without leaving home row
&lt;/h2&gt;

&lt;p&gt;This felt awkward for my first two weeks. Now reaching for arrow keys feels like the awkward option. h/l move left/right, j/k move down/up. The payoff is that your hands never leave the home row, which matters when you're moving around code all day.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;h  ← left
j  ↓ down
k  ↑ up
l  → right
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  7. w and b — jump by word instead of character
&lt;/h2&gt;

&lt;p&gt;w jumps forward to the start of the next word. b jumps backward. These made navigation actually fast for me — instead of holding a key and waiting, you hop through identifiers instantly. Capital W and B do the same but treat punctuation as part of words.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;w  → jump to next word start
b  → jump to previous word start
e  → jump to end of current word
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  8. gg and G — jump to file start or end
&lt;/h2&gt;

&lt;p&gt;gg takes you to the first line of the file instantly. G jumps to the last line. In a 300-line component, these replace a lot of Ctrl+Home / Ctrl+End muscle memory that used to require a keyboard shortcut.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gg  → top of file
G   → bottom of file
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  9. 0 and $ — move within a line
&lt;/h2&gt;

&lt;p&gt;0 goes to the very start of the line. $ goes to the end. I use $ constantly — jump to end of line, append something, back to Normal Mode. The caret (^) goes to the first non-whitespace character, which is often more useful than 0 for code.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;0  → start of line
^  → first non-whitespace character
$  → end of line
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  10. dd and yy — delete and copy entire lines
&lt;/h2&gt;

&lt;p&gt;dd deletes the current line and puts it in the buffer (it's actually a cut). yy copies the current line. Then p pastes below the cursor. I use dd + p to reorder lines constantly when refactoring — it's faster than any drag-and-drop.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;dd  → cut current line
yy  → copy &lt;span class="o"&gt;(&lt;/span&gt;yank&lt;span class="o"&gt;)&lt;/span&gt; current line
p   → paste below cursor
P   → paste above cursor
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  11. u and Ctrl+r — undo and redo
&lt;/h2&gt;

&lt;p&gt;u undoes the last change. Ctrl+r redoes it. Vim's undo history is persistent in recent versions — it survives closing and reopening the file if you configure it. Knowing you can undo freely makes editing less cautious, which is a good thing.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;u       → undo
Ctrl+r  → redo
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  12. / — search through a file
&lt;/h2&gt;

&lt;p&gt;Type / followed by what you're looking for and press Enter. Then n jumps to the next match, N goes backward. When I'm reading an unfamiliar codebase and want to find where a function is called, / is faster than any editor's Ctrl+F because my hands don't move to a dialog box.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;/handleSubmit
/useState
n   → next match
N   → previous match
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  13. v — Visual Mode for text selection
&lt;/h2&gt;

&lt;p&gt;v enters character-by-character visual selection. V selects whole lines. Once you've selected something, you can yank it (y), delete it (d), indent it (&amp;gt; or &amp;lt;), or run any other operation. This replaced most of my mouse-drag selections.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;v   → character visual mode
V   → line visual mode
Ctrl+v → block visual mode
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  14. :split and :vsplit — work on multiple files
&lt;/h2&gt;

&lt;p&gt;These open a split window inside Vim. In VS Code with the extension, you'll probably use the editor's built-in split instead — but the Ctrl+w hjkl navigation between splits still works and it's worth knowing. It's one of those things that feels clunky until it's automatic.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;:split             → horizontal split
:vsplit            → vertical split
:split utils.ts    → open specific file
Ctrl+w hjkl        → move between splits
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  15. :%s — find and replace across the whole file
&lt;/h2&gt;

&lt;p&gt;This is the command that made me feel like Vim was designed for developers and not just sysadmins. :%s/oldName/newName/g replaces every occurrence in the file. Add c at the end to confirm each one. I use this for renaming variables during refactors constantly.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;:%s/oldName/newName/g
:%s/console.log/logger.debug/gc
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The combinations that feel like a different tool entirely
&lt;/h2&gt;

&lt;p&gt;These are motions that take a few weeks to internalize but then become automatic. They're the reason experienced Vim users look impossibly fast to outsiders — they're not typing faster, they're just composing operations in a language the editor understands.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ciw        → change entire word under cursor
ci"        → change text inside quotes
di(        → delete everything inside parentheses
yip        → copy current paragraph
5dd        → delete next 5 lines
.          → repeat last change (incredibly powerful)
*          → search for word under cursor
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  How I'd actually approach learning this
&lt;/h2&gt;

&lt;p&gt;Install the VSCodeVim extension first — search 'Vim' in the VS Code extensions panel, it's the one by vscodevim with millions of installs. Then don't try to use every command on day one. Spend your first week just on navigation: hjkl, w, b, gg, G. Week two, add dd, yy, p, and u. Week three, start using / for search and :%s for find-and-replace. Let the rest come in naturally when you need it. The extension supports virtually everything in this list.&lt;/p&gt;

&lt;h2&gt;
  
  
  Did I end up switching to full Vim?
&lt;/h2&gt;

&lt;p&gt;No — and I don't think I need to. The VSCodeVim extension gives me the motion model I wanted, and I keep all the things VS Code does well: IntelliSense, the debugger, Git integration, extensions for every framework I use. The week I spent obsessing over Vim wasn't wasted though. Learning the commands properly, even in an extension, changed how I edit code. I reach for the mouse a lot less. Refactoring feels faster. If you've been curious about Vim but don't want to abandon your editor, the extension is genuinely the right starting point.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I write about web development, Linux and IoT at &lt;a href="https://www.eissa.top" rel="noopener noreferrer"&gt;eissa.top&lt;/a&gt;. This post first appeared &lt;a href="https://www.eissa.top/blog/top-vim-commands-and-essentials" rel="noopener noreferrer"&gt;there&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>vim</category>
      <category>vscode</category>
      <category>productivity</category>
    </item>
    <item>
      <title>How a WWE Jump Pushed Me Into Programming</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Fri, 20 Nov 2026 14:01:44 +0000</pubDate>
      <link>https://dev.to/eissapk/how-a-wwe-jump-pushed-me-into-programming-36mi</link>
      <guid>https://dev.to/eissapk/how-a-wwe-jump-pushed-me-into-programming-36mi</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://www.eissa.top/blog/how-a-wwe-jump-pushed-me-into-programming" rel="noopener noreferrer"&gt;my blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;I studied accounting, not computer science, and I had no career plan for tech. I started by watching a wrestler jump from the ring into the crowd and asking my friend how he did it. That one question led to parkour, then HTML, then a career.&lt;/p&gt;

&lt;h2&gt;
  
  
  It started with a wrestler, not a keyboard.
&lt;/h2&gt;

&lt;p&gt;I studied accounting. Tech wasn't part of the plan, and nothing in my studies pointed me toward programming. Then I was watching WWE one night and I liked John Morrison. I saw him jump from the ring into the audience, from a really long distance. I couldn't stop thinking about it. So I asked my friend how anyone performs a jump like that. He told me it comes from parkour. I had no idea what that even was, so I went to YouTube, watched everything I could find, gathered all the info I needed, and showed up to my first session. I didn't know it yet, but that one question about a wrestling move was the start of my programming story.&lt;/p&gt;

&lt;h2&gt;
  
  
  The programmer at the parkour session.
&lt;/h2&gt;

&lt;p&gt;After a while at the sessions I met someone who was a programmer. When I told him I was curious about tech, his advice was simple: just study HTML and CSS. No big roadmap, no long lecture. I trusted him and I did it. That was 2016, as far as I remember. It's funny that the most important advice I ever got about my career came from someone I'd just met at a parkour session, and it was only one sentence long.&lt;/p&gt;

&lt;h2&gt;
  
  
  Then I did nothing for a while.
&lt;/h2&gt;

&lt;p&gt;I found an online course from Shaw Academy that taught HTML, CSS, and JavaScript, and I joined. And then, honestly, I didn't do much with it. I had the course, I had the motivation for a few days, and I had no plan. That went on for some time. If you're reading this and you have a half-finished course sitting in your account, you're not the first one. I stayed stuck there for months.&lt;/p&gt;

&lt;h2&gt;
  
  
  One Million Arab Coders changed the feeling.
&lt;/h2&gt;

&lt;p&gt;At the end of 2017, nearly two years after I first touched HTML, I found the One Million Arab Coders initiative from the UAE. I joined and chose the frontend track. What changed wasn't the content, it was the feeling. I told myself I wouldn't be alone in this, because there were a million of us doing it together. That was enough to make me stop treating it as a hobby I'd get back to later. I learned HTML, CSS, and JavaScript in depth this time, and I learned Git and GitHub too.&lt;/p&gt;

&lt;h2&gt;
  
  
  Learning the rest on my own.
&lt;/h2&gt;

&lt;p&gt;When the course ended I kept going by myself on YouTube. Elzero Web School was a big part of that, then Brad from Traversy Media, then JavaScript30 by Wes Bos. No single teacher taught me everything. I stitched it together from free videos and a lot of typing. Along the way I took some freelance projects. They weren't glamorous, but they were real, and real projects teach you things no tutorial can, like what to do when the client changes their mind.&lt;/p&gt;

&lt;h2&gt;
  
  
  2020: my first real job.
&lt;/h2&gt;

&lt;p&gt;In 2020 I got hired at Vijua, the company behind Kotobee, an ebook reader. That was the moment it stopped being something I studied and became something I did for a living. After that I did an internship at TBG, where I picked up Next.js and Strapi. I didn't know at the time how useful that would be, but I used both later on a client project.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where I am now.
&lt;/h2&gt;

&lt;p&gt;Today I'm a full stack developer. I've built my own JavaScript framework, and I'm working on my own minimal version of an ebook reader, using the three years of experience I got working on Kotobee. I also do IoT projects, because sometimes I get bored of pure coding and I want to build something that blinks, moves, or reads a sensor. Nothing about this path was planned. Every step was just the next thing that seemed interesting.&lt;/p&gt;

&lt;h2&gt;
  
  
  It all began with a jump.
&lt;/h2&gt;

&lt;p&gt;If I hadn't asked my friend that question, I probably wouldn't have gone to a parkour session. If I hadn't gone, I wouldn't have met that programmer. If he hadn't given me one sentence of advice, I wouldn't be writing this. You don't need a perfect plan or the perfect starting point. I came from accounting, and I still ended up here. You need one thing that makes you curious enough to ask how it works, and then the patience to keep going even when you disappear for a couple of years. I did, and I still came back.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I write about web development, Linux and IoT at &lt;a href="https://www.eissa.top" rel="noopener noreferrer"&gt;eissa.top&lt;/a&gt;. This post first appeared &lt;a href="https://www.eissa.top/blog/how-a-wwe-jump-pushed-me-into-programming" rel="noopener noreferrer"&gt;there&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>career</category>
      <category>beginners</category>
      <category>webdev</category>
    </item>
    <item>
      <title>How I Fixed Google and Facebook SSO in a Mobile WebView</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Fri, 20 Nov 2026 14:01:04 +0000</pubDate>
      <link>https://dev.to/eissapk/how-i-fixed-google-and-facebook-sso-in-a-mobile-webview-4863</link>
      <guid>https://dev.to/eissapk/how-i-fixed-google-and-facebook-sso-in-a-mobile-webview-4863</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://www.eissa.top/blog/fixing-google-and-facebook-sign-in-in-a-cordova-webview" rel="noopener noreferrer"&gt;my blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Google and Facebook block sign-in inside WebViews, and our Cordova app had been stuck on it for two years. The fix: sign in in the real browser, then come back to the app through a link.&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem
&lt;/h2&gt;

&lt;p&gt;The mobile apps I worked on were built with Cordova, so each app is a web page running inside a WebView. Google and Facebook sign-in used to work there, until both providers changed their rules and it stopped working. The bug was two years old, several attempts had failed, and one of our biggest clients made fixing it a condition of renewing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why it happens
&lt;/h2&gt;

&lt;p&gt;Sign-in inside the WebView worked fine at first. Then Google and Facebook restricted SSO to the normal browser only, and blocked it inside WebViews. They did it on purpose: the app that hosts a WebView can read everything typed into it, including a password. So the providers refuse to show their login page there, and there's no setting to turn that off.&lt;/p&gt;

&lt;p&gt;The only real fix is to not sign in inside the WebView.&lt;/p&gt;

&lt;h2&gt;
  
  
  The idea: copy Postman
&lt;/h2&gt;

&lt;p&gt;Postman's desktop app already solves this. When you sign in, it opens your normal browser. You sign in there, and the browser sends you back to the app, signed in. I did the same thing on mobile.&lt;/p&gt;

&lt;h2&gt;
  
  
  The flow
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The user taps the same SSO button as before.&lt;/li&gt;
&lt;li&gt;The app opens the phone's real browser, not the WebView, on a small static index.html hosted on the web.&lt;/li&gt;
&lt;li&gt;That page holds the Google and Facebook SSO code and handles the routing: it sends the user straight to Google or Facebook to sign in.&lt;/li&gt;
&lt;li&gt;From there everything is automatic. After login, the redirect URL opens the app, with the credentials in the URL.&lt;/li&gt;
&lt;li&gt;The app reads them from the URL's search params and continues its normal sign-in flow.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The static page is the only new piece on the web side, and it does one job: start the sign-in where Google and Facebook allow it, then send the user back. The app's existing login code didn't change. It just gets the credentials from the URL instead of the WebView.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// The SSO button opens the static SSO page in the real browser.&lt;/span&gt;
&lt;span class="nb"&gt;window&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sb"&gt;`https://example.com/sso/index.html?provider=${provider}`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"_system"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;// That page signs the user in with Google or Facebook,&lt;/span&gt;
&lt;span class="c1"&gt;// then redirects to myapp://auth?token=...&lt;/span&gt;
&lt;span class="c1"&gt;// which opens the app and calls:&lt;/span&gt;
&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;handleOpenURL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;token&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="no"&gt;URL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;searchParams&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"token"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;token&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;completeSignIn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;token&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// the existing flow&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Why mobile is harder than desktop
&lt;/h2&gt;

&lt;p&gt;The idea is simple. Making it reliable on a phone takes more care:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The OS may close the app while the user is in the browser, so the link might start the app from scratch instead of resuming it. Both cases have to work.&lt;/li&gt;
&lt;li&gt;The link back to the app has to be set up separately on Android and iOS.&lt;/li&gt;
&lt;li&gt;The user can give up halfway, so tapping the button again has to be safe.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The result
&lt;/h2&gt;

&lt;p&gt;Google and Facebook sign-in worked again, with the same single tap. A two-year-old blocker was fixed by borrowing an idea from a desktop app.&lt;/p&gt;

&lt;p&gt;If you build this today, pass a short-lived one-time code in the URL instead of real credentials, and have the app exchange it with your server.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I write about web development, Linux and IoT at &lt;a href="https://www.eissa.top" rel="noopener noreferrer"&gt;eissa.top&lt;/a&gt;. This post first appeared &lt;a href="https://www.eissa.top/blog/fixing-google-and-facebook-sign-in-in-a-cordova-webview" rel="noopener noreferrer"&gt;there&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>cordova</category>
      <category>authentication</category>
      <category>mobile</category>
    </item>
    <item>
      <title>IoT Protocols Explained: What I Wish I Knew Before My First ESP32 Project</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Fri, 20 Nov 2026 14:00:11 +0000</pubDate>
      <link>https://dev.to/eissapk/iot-protocols-explained-what-i-wish-i-knew-before-my-first-esp32-project-21m9</link>
      <guid>https://dev.to/eissapk/iot-protocols-explained-what-i-wish-i-knew-before-my-first-esp32-project-21m9</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://www.eissa.top/blog/iot-protocols-explained" rel="noopener noreferrer"&gt;my blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;My first ESP32 project used HTTP for everything. It worked — barely. Here's what I learned about MQTT, BLE, Zigbee, LoRaWAN and the rest after building real IoT dashboards and realizing there's a better way.&lt;/p&gt;

&lt;h2&gt;
  
  
  I used HTTP for my first ESP32 project and it kind of worked
&lt;/h2&gt;

&lt;p&gt;When I first started connecting ESP32 boards to the internet, I just used HTTP. It made sense — I already knew how APIs worked from building web apps with the MERN stack, so firing off a POST request from a microcontroller felt natural. The problem was that my sensor was hitting the server every second, reconnecting over TCP each time, and my battery-powered prototype drained in hours instead of days. That's when I actually sat down and studied IoT protocols properly. This post is what I wish someone had explained to me before I wired up that first circuit.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why protocol choice matters more than most tutorials admit
&lt;/h2&gt;

&lt;p&gt;Most beginner ESP32 tutorials just use HTTP or point you at MQTT without explaining why. But protocol choice affects battery life, reliability over bad connections, how much cloud infrastructure you need, and whether your project scales to 10 devices or 10,000. Getting this wrong early means rebuilding later. I've done that rebuild. It's not fun.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. MQTT — the one you'll probably use most
&lt;/h2&gt;

&lt;p&gt;MQTT (Message Queuing Telemetry Transport) follows a publish-subscribe model. Your ESP32 doesn't talk directly to your dashboard — it publishes a message to a broker (like Mosquitto), and anything subscribed to that topic receives it. The overhead is tiny: a minimal MQTT packet can be as small as 2 bytes. It handles spotty Wi-Fi gracefully with QoS levels that let you choose between fire-and-forget and guaranteed delivery. This is what I switched to after the HTTP disaster and never left.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ESP32 (publisher)
      ↓  publishes to topic: "home/sensor/temp"
MQTT Broker (Mosquitto)
      ↓  forwards to all subscribers
Next.js Dashboard + Mobile App
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  When MQTT makes sense
&lt;/h2&gt;

&lt;p&gt;Use it for: real-time sensor dashboards, home automation, relay control, anything where you want bidirectional communication between devices and a server. I built an ESP32 relay controller connected to a Next.js dashboard using MQTT over WebSockets — the frontend subscribes to state changes and publishes commands back. It's clean and responsive in a way HTTP polling never was.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. HTTP — you know it, but it has real costs on hardware
&lt;/h2&gt;

&lt;p&gt;HTTP is request-response. Every time your device sends data, it opens a TCP connection, sends headers (which are surprisingly large), waits for a response, and closes the connection. That's fine on a server with plenty of resources. On a microcontroller running on two AA batteries, every one of those steps burns energy you don't have. The upside is you probably already know how it works and can integrate with any web service without extra infrastructure.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="n"&gt;POST&lt;/span&gt; &lt;span class="err"&gt;/&lt;/span&gt;&lt;span class="n"&gt;api&lt;/span&gt;&lt;span class="err"&gt;/&lt;/span&gt;&lt;span class="n"&gt;temperature&lt;/span&gt; &lt;span class="n"&gt;HTTP&lt;/span&gt;&lt;span class="err"&gt;/&lt;/span&gt;&lt;span class="mf"&gt;1.1&lt;/span&gt;
&lt;span class="n"&gt;Host&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;my&lt;/span&gt;&lt;span class="err"&gt;-&lt;/span&gt;&lt;span class="n"&gt;server&lt;/span&gt;&lt;span class="err"&gt;.&lt;/span&gt;&lt;span class="n"&gt;com&lt;/span&gt;
&lt;span class="n"&gt;Content&lt;/span&gt;&lt;span class="err"&gt;-&lt;/span&gt;&lt;span class="n"&gt;Type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;application&lt;/span&gt;&lt;span class="err"&gt;/&lt;/span&gt;&lt;span class="n"&gt;json&lt;/span&gt;

&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"value"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mf"&gt;26.4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"humidity"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;61&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  When HTTP still makes sense in IoT
&lt;/h2&gt;

&lt;p&gt;If your device is plugged in (not battery-powered), sends data infrequently (every few minutes), and you want to skip running a broker, HTTP is totally fine. I still use it for ESP32 projects that just need to send occasional readings to a REST API without building extra infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. CoAP — HTTP for tiny devices
&lt;/h2&gt;

&lt;p&gt;CoAP (Constrained Application Protocol) is essentially HTTP redesigned for microcontrollers. It uses UDP instead of TCP, which removes the connection overhead. It has the same GET/POST/PUT/DELETE model you know from REST, but the message format is dramatically smaller. Most hobbyist projects won't need CoAP — but if you're designing something for mass deployment on coin-cell batteries, it's worth knowing exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Bluetooth Low Energy — short range, serious battery life
&lt;/h2&gt;

&lt;p&gt;BLE is remarkable for what it achieves on power. A BLE device can run for months or years on a small battery because it sleeps most of the time and only wakes to transmit tiny bursts of data. The tradeoff is range — typically 10 to 50 meters in practice. BLE is perfect when you need a sensor to talk to a phone or nearby hub without any internet infrastructure.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Temperature Sensor (BLE)
      ↓  15m range
Raspberry Pi / Phone (BLE gateway)
      ↓  Wi-Fi
MQTT Broker or Cloud
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  5. Zigbee — how smart home devices actually talk
&lt;/h2&gt;

&lt;p&gt;Zigbee is the protocol behind most Philips Hue bulbs, IKEA Tradfri, and many commercial smart home devices. What makes it interesting is the mesh topology — devices can relay signals through each other, so adding more nodes actually extends your network range. Each device is a potential repeater. It's low power and works well in dense home environments.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Sensor (Zigbee end device)
      ↓
Smart Plug (Zigbee router — relays signal)
      ↓
Zigbee Coordinator (e.g. Conbee stick on a Pi)
      ↓
Home Assistant / MQTT
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  6. LoRaWAN — send data kilometers away on a tiny battery
&lt;/h2&gt;

&lt;p&gt;LoRaWAN is the most extreme tradeoff in this list: you can send data 5-15 kilometers on a single charge, but the data rate is very low and messages must be short. It's used in agriculture, smart cities, and industrial monitoring where sensors are spread across wide areas with no reliable Wi-Fi infrastructure. I haven't built anything with LoRaWAN yet, but it's on my list for an outdoor environmental monitoring project.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Wi-Fi — the obvious choice, with obvious tradeoffs
&lt;/h2&gt;

&lt;p&gt;The ESP32 has Wi-Fi built in, which is why it's the most popular microcontroller for hobbyists. Wi-Fi gives you direct internet access with decent throughput. The problem is power draw — Wi-Fi consumes 10-100x more energy than BLE or LoRaWAN. For plugged-in projects and prototypes it's perfect. For anything battery-powered that needs to last more than a week, you'll need to either use deep sleep aggressively or rethink the protocol.&lt;/p&gt;

&lt;h2&gt;
  
  
  How the protocols actually compare
&lt;/h2&gt;

&lt;p&gt;No protocol wins at everything. The right choice depends on your constraints: range, power budget, data size, and whether you need a broker or gateway.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Protocol   Range        Power       Best for
─────────────────────────────────────────────────
MQTT       Internet     Low         Cloud dashboards, home automation
HTTP       Internet     Medium      Simple APIs, plugged-in devices
CoAP       Internet     Very Low    Constrained MCUs, mass deployment
BLE        ~50m         Very Low    Phone-connected sensors, wearables
Zigbee     ~100m mesh   Low         Smart home, commercial devices
LoRaWAN    5-15km       Very Low    Remote sensors, agriculture
Wi-Fi      ~100m        High        Prototypes, plugged-in projects
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  What I'd recommend for your first project
&lt;/h2&gt;

&lt;p&gt;Start with MQTT over Wi-Fi on an ESP32. It's the fastest path to a working connected device, the community support is massive, and it integrates cleanly with Node.js, Next.js, Home Assistant, or whatever backend you prefer. Run Mosquitto locally for development. Once that works, you'll understand the constraints well enough to decide if you need something different for your next project.&lt;/p&gt;

&lt;h2&gt;
  
  
  The lesson I wish I'd learned earlier
&lt;/h2&gt;

&lt;p&gt;Protocols aren't just technical details — they shape the entire architecture of your project. Choosing HTTP first cost me a working prototype and a weekend of debugging. Ten minutes studying MQTT before writing a single line of firmware would have saved all of that. If you're just starting with IoT and ESP32, spend that time up front. You'll thank yourself later.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I write about web development, Linux and IoT at &lt;a href="https://www.eissa.top" rel="noopener noreferrer"&gt;eissa.top&lt;/a&gt;. This post first appeared &lt;a href="https://www.eissa.top/blog/iot-protocols-explained" rel="noopener noreferrer"&gt;there&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>iot</category>
      <category>esp32</category>
    </item>
    <item>
      <title>A Quick Guide to OlumJS</title>
      <dc:creator>Eissa Saber</dc:creator>
      <pubDate>Wed, 26 Aug 2026 08:18:44 +0000</pubDate>
      <link>https://dev.to/eissapk/a-quick-guide-to-olumjs-v-3lle</link>
      <guid>https://dev.to/eissapk/a-quick-guide-to-olumjs-v-3lle</guid>
      <description>&lt;p&gt;I just published a quick guide to OlumJS covering the core concepts in 8 simple steps — from reactive state and props to slots, lifecycle, control flow, loops, and shared state.&lt;/p&gt;

&lt;p&gt;OlumJS is built around a simple idea: keep writing HTML and JavaScript, while adding reactivity on top.&lt;/p&gt;

&lt;p&gt;If you're curious about this approach, check out the guide:&lt;/p&gt;

&lt;p&gt;👉 &lt;a href="https://www.olumjs.top/blog/olum-quick-guide" rel="noopener noreferrer"&gt;https://www.olumjs.top/blog/olum-quick-guide&lt;/a&gt;&lt;/p&gt;

</description>
      <category>frontend</category>
      <category>javascript</category>
      <category>tutorial</category>
      <category>webdev</category>
    </item>
  </channel>
</rss>
