u/Candid_Athlete_8317

I’ve got a Linux host that can reach the gateway, but suddenly can’t talk to another machine on the same subnet.

Nothing obvious changed.

I’d probably start looking at the ARP/neighbour table, but I’m curious how others approach this.

Do you check ip neigh**, run a packet capture, look at the switch MAC table, check for a duplicate IP, or go somewhere else first?**

What’s the first thing you check when you suspect an ARP problem?

I get why people keep trying new distros every week there’s something new that looks better than what you’re running.

But reinstalling, configuring everything again and relearning workflows has a real cost when Linux is also your work machine.

Do you think distro hopping is part of learning Linux, or does it eventually become procrastination disguised as experimentation?

Ubuntu gets plenty of criticism for Snaps, Canonical’s decisions and increasing resource requirements. But at the same time, it remains one of the most widely supported and approachable Linux distros.

Maybe the real issue is that we keep judging Ubuntu against distros designed for completely different goals.

If you had to recommend one Linux distro to someone leaving Windows today, would Ubuntu still make your shortlist? Why or why not?

For years, “I need Microsoft Office” has been one of the strongest reasons people give for staying on Windows. Now projects like Bottles are getting surprisingly close to making that less of a limitation.

But there’s a catch: an unofficial compatibility layer can break after one Microsoft update.

Would you trust Linux + Bottles for your everyday Office work, or would you still keep Windows around just for Microsoft 365?

GNOME 51 is adding a lot of polish, but the comments around it raise another question: should a desktop stay stable for your workflow, or keep evolving even if extensions and habits break?

Where Linux users draw the line. Would you rather have a desktop that rarely changes, or one that keeps improving even if you have to adjust your workflow?

A lot of people want to jump straight into Ansible, automation and cloud.

But if you can’t troubleshoot the Linux system manually, how much can you really automate effectively?

Would you hire someone who is excellent at Ansible but weak at Linux administration, or someone strong in Linux who is still learning automation? Why?

Cloud gives you flexibility and automation, but long-running workloads can become extremely expensive.

For predictable workloads, when does renting infrastructure stop making sense and buying/operating bare metal become the better engineering decision?

Kubernetes gives us containers, networking, service discovery, scaling and orchestration - but troubleshooting can involve namespaces, cgroups, CNI, CoreDNS, iptables/nftables, kube-proxy and more.

Did Kubernetes simplify infrastructure at scale, or just move the complexity somewhere else?

XFS, Btrfs and newer filesystems offer capabilities that ext4 doesn't.

Yet ext4 remains one of the safest defaults for many Linux servers.

Is “boring and proven” actually the best filesystem strategy for production?

Kubernetes gives you a lot of flexibility, but do you actually need all of it?

If ECS can run your containers with less complexity, less maintenance, and lower cost, what’s the real reason to choose EKS?

Is EKS worth the extra complexity - or are teams reaching for Kubernetes when ECS would be the better engineering decision?

Where you stand: ECS or EKS, and why?

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?

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?

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?

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?

Not because it’s dangerous, because explaining why it works would take longer than actually running it.

awk, sed, find, xargs, shell one-liners, some cursed grep pipeline...

What command makes you look like a Linux wizard but you couldn't explain every character in it?

useradd vs adduser

groupadd vs addgroup

su vs sudo…

Some commands feel like they were named just to confuse us.

What Linux command or option made you think, “Who the hell named this?”

Every sysadmin has a few things they always check before running a command or script.

set -euo pipefail, checking rm paths, testing on a non-prod server, verifying permissions...

What’s your one rule that you never break?