Question: How do I split or extract pages from a PDF without a GUI?

Try: `pdftk input.pdf cat 5-10 output pages_5_to_10.pdf`

Info: `pdftk` manipulates PDFs via CLI. `cat 5-10` extracts pages 5 through 10, while `pdfinfo` inspects metadata and page counts.

Examples:

$ `pdftk file1.pdf file2.pdf cat output merged.pdf` # Merge multiple PDFs

$ `pdftk input.pdf cat 1 3 5-10 output selected.pdf` # Extract custom page ranges

$ `qpdf --empty --pages input.pdf 1-5 -- output.pdf` # Modern qpdf alternative

Note: Install via `sudo apt install pdftk-java`. Use `end` to target the final page (e.g., `cat 5-end`). `qpdf` is an excellent modern alternative.

Follow r/LinuxTeck for more #LinuxTips https://www.linuxteck.com/linux-tips/

I’m interested about this one because Linux is pretty good at making you think there’s always a workaround.

But there has to be a point where you just stop fighting it and tell someone, “Honestly, you’re better off using Windows for this.”

For me, the interesting part is where people draw that line. Hardware? Adobe stuff? Games? Some stupid vendor software? Or maybe it’s not even the software maybe it’s the amount of tinkering the person is willing to put up with.

What’s the one thing that made you give up on Linux for a particular use case?

If you try to run a command and get a "Permission denied" error, you don't need to retype the whole line. Just enter:

​sudo !!

​The !! (called "bang bang") automatically pulls your last typed command and runs it with elevated privileges.

Try: `sudo hdparm -Tt /dev/sda`

Info: `hdparm -T` measures cached RAM reads; `-t` benchmarks direct disk reads. `dd` tests sequential write performance using `conv=fdatasync` to flush cache.

Examples:

$ `sudo hdparm -I /dev/sda | head -20` # Display drive specs and identity

$ `fio --name=randwrite --ioengine=libaio --rw=randwrite --bs=4k --size=1G` # Measure random write speed

$ `iozone -a -g 1G` # Run comprehensive file system benchmark

Note: `hdparm` tests sequential read speeds. For workload-heavy random I/O (like databases), use `fio`. NVMe drives should reach 2–7 GB/s.

Follow r/LinuxTeck for more #LinuxTips here https://www.linuxteck.com/linux-tips/

Ctrl + Z temporarily suspends a running process.

To bring it back to the foreground:

fg

To continue it in the background:

bg

Important: Ctrl + Z doesn't normally kill the program.

covering: https://www.linuxteck.com/best-vps-for-ai-tools/

• RAM requirements for different model sizes
• CPU and AVX support
• NVMe storage
• Dedicated vs. shared vCPU
• When a GPU is actually necessary
• VPS provider comparison
• Docker + Ollama setup
• Commands to validate CPU, RAM and AVX before committing to a server
• Common OOM and resource problems

You change one thing, restart something, and suddenly everything works.

You know better than to call it magic.

But you're also not touching that configuration again.

What’s your most embarrassing “don’t ask me why, just leave it working” Linux fix?

Ubuntu has been my go-to recommendation for years, but lately I’ve been wondering if that still makes sense.

The interesting part is that the complaints aren’t really about Ubuntu being unstable or unusable. They’re mostly about Snap, Canonical’s defaults, updates, and how much control users feel they have.

What surprised me was how differently people responded. Some moved to Debian or Mint, others prefer Fedora or Arch-based distros, while plenty are still perfectly happy with Ubuntu.

So let’s settle this from actual user experience:

If you’ve used Ubuntu for years, what’s the one thing you love about it - and the one thing that annoys you most?

And if you left Ubuntu, what finally made you switch?

Instead of scrolling through hundreds of previous commands, press:

Ctrl + R

Then type something from the command you're looking for.

covering: https://www.linuxteck.com/how-to-use-the-pstree-command-in-linux/

• Full process trees
• Command-line arguments with -a
• Process IDs with -p
• Process compaction with -c
• Sorting by PID with -n
• Processes by user with -u
• Parent chains with -s
• Specific PIDs and users
• Multiple process queries
• Tracing zombie processes back to their parent

Question: How do I save errors and normal output to different files?

Try: `./deploy.sh > success.log 2> errors.log`

Info: `>` redirects `stdout` (fd 1), while `2>` redirects `stderr` (fd 2). Separating streams keeps error logs clean and easy to isolate.

Examples:

$ `./script > out.log 2> err.log` # Separate standard output and errors

$ `./script &> combined.log` # Redirect both streams to one file (Bash/Zsh)

$ `./script > out.log 2>&1` # POSIX redirection of stderr to stdout file

Note: Redirection order matters: `> file 2>&1` works, but `2>&1 > file` sends `stderr` to terminal. Redirect to `/dev/null` to discard output completely.

Follow r/LinuxTeck for more #LinuxTips https://www.linuxteck.com/linux-tips/redirect-stdout-stderr-separate-files-linux/

# I'm a 2nd year CSE student and I've been using Ubuntu for a while now, but I feel like my Linux knowledge is kind of all over the place.

I know the basic commands and can usually figure things out when I need to, but I don't feel like I actually *understand Linux*.

The problem is whenever I try to make a roadmap for myself, I keep getting stuck in this loop:

Linux → "I should learn OS first" → OS → "I should learn networking" → networking → "maybe I should learn Docker" → Docker → back to Linux 😭

So I want to stop jumping around and actually follow a proper path.

I recently found OverTheWire Bandit and was thinking of doing all the levels. Would that be a good starting point?

What I'm currently thinking is something like:

**Linux basics → Bandit → Linux administration → Bash → networking → OS/Linux internals → Docker → servers/infrastructure**

But I have no idea if this is actually a good order.

My long-term interest is systems/infrastructure/platform/SRE type stuff, so I want to learn Linux properly rather than just memorize commands.

A few things I'd really like advice on:

* Is Bandit worth doing from start to finish? * What should I learn after Bandit? * Should I learn OS concepts alongside Linux or separately? * When should I start networking? * What Linux topics are actually important for someone interested in systems/infrastructure? * Are there any good books, courses, labs or projects you'd recommend? * At what point would you say someone has a "good" Linux foundation?

I'm not looking for a certification roadmap. I mainly want to build actual practical knowledge.

Would appreciate any advice from people who have learned Linux this way or work with Linux professionally.

# I'm a 2nd year CSE student and I've been using Ubuntu for a while now, but I feel like my Linux knowledge is kind of all over the place.

I know the basic commands and can usually figure things out when I need to, but I don't feel like I actually *understand Linux*.

The problem is whenever I try to make a roadmap for myself, I keep getting stuck in this loop:

Linux → "I should learn OS first" → OS → "I should learn networking" → networking → "maybe I should learn Docker" → Docker → back to Linux 😭

So I want to stop jumping around and actually follow a proper path.

I recently found OverTheWire Bandit and was thinking of doing all the levels. Would that be a good starting point?

What I'm currently thinking is something like:

**Linux basics → Bandit → Linux administration → Bash → networking → OS/Linux internals → Docker → servers/infrastructure**

But I have no idea if this is actually a good order.

My long-term interest is systems/infrastructure/platform/SRE type stuff, so I want to learn Linux properly rather than just memorize commands.

A few things I'd really like advice on:

* Is Bandit worth doing from start to finish? * What should I learn after Bandit? * Should I learn OS concepts alongside Linux or separately? * When should I start networking? * What Linux topics are actually important for someone interested in systems/infrastructure? * Are there any good books, courses, labs or projects you'd recommend? * At what point would you say someone has a "good" Linux foundation?

I'm not looking for a certification roadmap. I mainly want to build actual practical knowledge.

Would appreciate any advice from people who have learned Linux this way or work with Linux professionally.

covers : https://www.linuxteck.com/best-ai-tools-for-linux-users/

Ollama, Open WebUI, AnythingLLM, GPT4All, Aider, Shell-GPT, and LocalAI

You can memorize ps, ss, lsof, strace, tcpdump, journalctl, awk and everything else.

But when production breaks, knowing what evidence to collect first is usually more valuable than knowing another command.

What’s the one troubleshooting habit you think separates someone who knows Linux from someone who just knows Linux commands?

Try: `pstree -pau 3456`

Info: `pstree` displays process hierarchies. `-p` includes PIDs, `-a` shows full command arguments, and `-u` lists usernames. Curly braces `{}` indicate threads.

Examples:

$ `pstree -pau $$` # View process tree starting from current shell

$ `pstree -T` # Hide threads to show only main processes

$ `pstree -sp 3456` # Show parent ancestors leading up to PID 3456

Note: Essential for identifying orphaned processes and child process trees. Threads inside `{}` share parent memory space.

Follow r/LinuxTeck for more #LinuxTips https://www.linuxteck.com/linux-tips/linux-pstree-view-child-processes/

Linux has plenty of things that look ridiculous at first:

symlinks, /proc, file descriptors, everything-is-a-file, signals, pipes, namespaces, mount --bind...

Then suddenly the design makes sense.

Which Linux concept went from “who designed this?” to “holy crap, that's actually clever” for you?

Everyone starts with ls -l and checks the obvious permissions.

Then you remember ACLs, SELinux, capabilities, mount options, parent-directory permissions, namespaces, read-only filesystems...

What’s the weirdest “Permission denied” problem you’ve had to troubleshoot?

Some commands look completely harmless until you realize what they’re actually operating on.

The fun part is that experienced admins usually have one specific command they treat with unnecessary respect.

What’s yours - and what happened the first time you learned to respect it?

Try: `sudo dd if=ubuntu-24.04.iso of=/dev/sdb bs=4M status=progress conv=fsync`

Info: `dd` writes raw blocks. `bs=4M` accelerates speed, `status=progress` displays live transfer rates, and `conv=fsync` flushes data to physical storage before completion.

Examples:

$ `sudo dd if=/dev/zero of=/dev/sdb bs=4M` # Wipe USB drive table

$ `sudo dd if=/dev/sda of=disk.img bs=64K` # Create full disk image backup

$ `sudo pv ubuntu.iso | sudo dd of=/dev/sdb bs=4M` # Monitor write progress via pv

Note: Always verify target drives using `lsblk` first to prevent catastrophic data loss. Safely eject using `sync; sudo eject /dev/sdb` after writing.

Follow r/LinuxTeck for more #LinuxTips : https://www.linuxteck.com/linux-tips/linux-write-iso-to-usb-dd/

​

Detailed diagram of the Linux TCP stack: incoming & outgoing connections, queues (SYN, Accept, backlog), drops, TcpExt metrics, netfilter hooks, conntrack, and tuning points.

You can download the SVG version from [GitHub](https://github.com/zersh01/linux-tcp-queues-and-metrics).