DEV Community: Hosni Zaaraoui

Linux sysadmin tips & shortcuts

Hosni Zaaraoui — Tue, 05 May 2026 17:19:30 +0000

Process & Port Management

Find what’s using a port:

ss -tulnp | grep :8080
Kill process by port:

kill -9 $(lsof -t -i:8080)
Top processes (better than top):

btop

Show process tree:

ps auxf

File & Disk Tricks

Human-readable disk usage:

df -h du -sh *

Find large files:

find / -type f -size +500M 2>/dev/null
Quickly clean logs:

truncate -s 0 /var/log/syslog

Search Like a Pro

Grep with line numbers + ignore case:

grep -in "error" file.log
Recursive search:

grep -r "password" /etc
Use less smarter:
/pattern → search
Shift+G → go to end

Networking Essentials

Check open ports:

ss -tuln
Test connectivity:

nc -zv 192.168.1.10 80
Show IPs:

ip a
Live traffic sniff:

tcpdump -i eth0

Services & Systemd

Check service status:

systemctl status nginx
Restart service:

systemctl restart nginx
View logs:

journalctl -u nginx -f

Memory & Performance

Memory usage:

free -h
CPU + memory snapshot:

top
IO stats:

iostat

Terminal Shortcuts (Huge Time Savers)

Ctrl + C → kill command
Ctrl + Z → pause (background it)
fg → bring back
Ctrl + A → start of line
Ctrl + E → end of line
Ctrl + R → search history 🔥

History & Productivity

Show history:

history
Re-run last command:

!!
Re-run command with sudo:

sudo !!

Permissions & Ownership

Change ownership:

chown user:user file
Change permissions:

chmod 755 script.sh

Package Management (Debian/Ubuntu)

Update & upgrade:

apt update && apt upgrade -y
Find package:

apt search nginx
Remove package:

apt remove nginx

Debugging & Logs

Follow logs live:

tail -f /var/log/syslog
Last 100 lines:

tail -n 100 file.log
Watch command output:

watch -n 2 "df -h"

Pro-Level Tricks

Run command in background:

nohup command &
Run multiple commands safely:

command1 && command2
Pipe like a wizard:

cat file | grep error | sort | uniq
Temporary Python web server:

python3 -m http.server 8000

Bonus (Sysadmin Mindset)

Always check logs first (/var/log or journalctl)
If something uses a port → ss + lsof → kill
If service fails → systemctl status + journalctl
If server slow → top + iostat + free

Stdout vs stderr vs stdin

Hosni Zaaraoui — Fri, 24 Apr 2026 14:29:56 +0000

One of the most useful Linux concepts for beginners is understanding the 3 standard streams:
· stdin for input
· stdout for normal output
· stderr for errors
Once this clicks, redirection and pipes make a lot more sense.
I made this one-image cheat sheet to simplify it.

Signals in Linux explained visually

Hosni Zaaraoui — Fri, 24 Apr 2026 14:28:28 +0000

Stopping a process in Linux isn’t just “kill it.”
Signals are how Linux communicates with running processes:
· some ask nicely
· some interrupt
· some pause
· and some force termination
This one-image visual explains the most common Linux signals and when to use them.

Linux Basics That Actually Matter (Files, Editing & Permissions)

Hosni Zaaraoui — Sun, 12 Apr 2026 12:02:24 +0000

Most beginner Linux posts say:
“Use touch, use nano, use chmod…”

But they don’t explain why things work the way they do.

Let’s fix that.

1. File Creation — It’s Not Just “touch”

Yes:

touch file.txt creates a file
mkdir dir/ creates a directory

But here’s what matters:

Linux is a hierarchical filesystem
Everything starts from / (root), and every file has a purpose.

Examples:

/etc/ → configuration files
/var/log/ → logs
/home/user/ → user data

Insight:
Where you create a file matters more than how.

Creating a script in /tmp vs /usr/local/bin changes its lifecycle and usage.

2. Editing Files — Understanding the Workflow

Editors are not just tools, they define how you work.

🔹 nano

Simple, visible shortcuts
Good for quick edits

🔹 vim

Modes (insert / normal / command)
Extremely fast once mastered

But here’s the key point:

In Linux, editing often means modifying system-critical files

Examples:

Editing /etc/ssh/sshd_config affects remote access
Editing /etc/fstab can break boot

Insight:
Always know what file you are editing, not just how.

3. Permissions — The Core of Linux Security

Every file has:

Owner (user)
Group
Others

And 3 permissions:

Read (r)
Write (w)
Execute (x)

Example:
-rwxr-x---

Meaning:

Owner → full access
Group → read & execute
Others → no access

Commands:

chmod → change permissions
chown → change owner

Real insight:
Permissions are not just protection — they define behavior.

Example:

A script without x won’t run
A service without read access won’t start

4. GUI Tools — Useful, But Limited

File managers like:

Thunar
Dolphin
Files (GNOME)

Help you:

Visualize permissions
Move files quickly

But:

They hide complexity.

You won’t see:

Recursive permission changes
Hidden system behavior
Ownership logic clearly

Best approach:
Use GUI to explore
Use CLI to understand and control

Final Thought

Linux becomes easy when you stop memorizing commands and start understanding:

Why files are placed somewhere
What happens when you edit them
How permissions affect execution

That’s the difference between a beginner… and someone who actually knows Linux.

💬 What broke your system the first time?

Next: Real-world mistakes + how I debugged them in my labs.

🐧 “Linux is Hard” — Until You Actually Use It

Hosni Zaaraoui — Wed, 08 Apr 2026 14:35:49 +0000

For a long time, I thought Linux wasn’t for normal people.

It looked complicated.
Terminal everywhere.
Strange commands.
Things breaking for no reason.

So I did what most people do:

I installed Linux… in a VM.

The Illusion of “Trying Linux”

Using Linux in a virtual machine feels like you’re learning it.

But you’re not really living with it.

You don’t customize it
You don’t rely on it
You don’t fix real problems
You just test things… and leave

If something breaks?

You close it. Done.

That’s why Linux feels unusable at this stage.

Why Linux Feels “Not Ready”

From the outside, Linux seems:

Too technical
Not user-friendly
Missing “basic” features
Hard to fix when something goes wrong

And honestly, at the beginning… it does feel that way.

Because you don’t yet know your options.

What Changed When I Switched

Everything changed when I made Linux my main OS.

Not because it suddenly became easier…

But because I started learning how it actually works.

I discovered:

There’s always more than one way to do something
Most problems have simple fixes (once you know where to look)
You can shape the system to fit you

Instead of adapting to the OS…
The OS adapts to you.

The “Aha” Moment

The biggest realization was this:

Linux isn’t hard.

It’s just different.

And once you understand a few core ideas:

reading logs
using the terminal
knowing where things live

It stops feeling broken… and starts feeling powerful.

It’s Not About Being an Expert

You don’t need to know everything.

You just need to:

Google errors
Try small fixes
Learn one thing at a time

That’s it.

And over time, things that looked impossible become simple.

Why I’m Starting This Series

I’m documenting my journey of using Linux as a daily driver.

Not as an expert—but as someone figuring things out step by step.

I’ll share:

Simple tips that actually help
Fixes to real problems I run into
Small tweaks that improve daily usage
Things I wish I knew earlier

If You’re Hesitating

If you think:

“Linux isn’t for me”

You’re probably at the same stage I was.

Using it without really using it.

The real experience starts when you commit to it.

Linux isn’t unusable.

It just doesn’t try to hide how things work.

And once you understand that… everything changes.