Why I'm Learning Rust and Shell Scripting to Better Understand Linux?

Why I'm Learning Rust and Shell Scripting After Years of Working with Python

From Data Science to Linux Systems

For many years, Python was my primary programming language.

It was the tool I used to build applications, automate workflows, analyze data, develop machine learning models, and create football analytics platforms. Coming from a data science background, Python allowed me to move quickly from idea to implementation.

And to be clear: Python remains one of the most productive and useful languages available today.

But recently, my focus has shifted.

Instead of concentrating exclusively on applications, I became increasingly interested in the infrastructure that makes those applications possible.

I started spending more time studying Linux, building a homelab, configuring servers, managing Docker containers, working with Nginx, Prometheus, Grafana, Loki, systemd, SELinux, networking, and the countless technologies that operate beneath the application layer.

That journey led me to two technologies that many people may not immediately connect:

• Shell Scripting
• Rust

I'm not learning them because I think Python is insufficient.

I'm not learning them because they're fashionable.

I'm learning them because they help me understand Linux and computer systems at a deeper level.

The Difference Between Using Linux and Understanding Linux

Many people learn Linux by memorizing commands.

They learn:

systemctl
journalctl
grep
find
ip
ss
awk
sed

And that works.

At least for a while.

But eventually, every Linux professional reaches a point where memorization stops being enough.

The real challenge becomes understanding what is happening underneath those commands.

Why does a service fail to start?

How are processes managed?

How does Linux handle resources?

What happens when memory pressure increases?

How do programs interact with the operating system?

The answers to those questions are what separate command memorization from genuine understanding.

That is where Shell Scripting and Rust become valuable.

Why I'm Learning Shell Scripting

If Linux has a native language, it is the shell.

Shell scripting is more than automation.

It is a way of thinking.

The more I write shell scripts, the more I understand the philosophy that shaped Unix and Linux.

Instead of relying on large frameworks or complex abstractions, Linux encourages small tools that do one thing well and can be combined to solve bigger problems.

Shell scripting places you directly inside that ecosystem.

You begin to understand how commands communicate.

How data flows through pipes.

How processes exchange information.

How logs are analyzed.

How services are controlled.

How systems are automated.

And perhaps most importantly, you learn to think like the operating system.

Shell Scripting Forces You to Learn Linux Fundamentals

One of the biggest benefits of Shell Scripting is that it naturally exposes you to concepts that Linux administrators use every day.

These include:

• Processes
• Standard input and output
• Redirection
• Pipes
• Permissions
• Environment variables
• Exit codes
• Job control
• Scheduling
• Service management

These concepts are not separate from Linux.

They are Linux.

The more comfortable you become with them, the easier it becomes to troubleshoot systems, automate infrastructure, and understand what the operating system is actually doing.

Why I'm Learning Rust

Shell Scripting helps me understand Linux from the outside.

Rust helps me understand Linux from the inside.

Rust is often described as a systems programming language.

That description can sound abstract until you start using it.

Unlike many high-level languages, Rust exposes concepts that are usually hidden behind layers of abstraction.

And that's exactly what makes it interesting.

What Python Abstracts Away

Python is designed for productivity.

That is one of its greatest strengths.

In Python, many difficult problems are intentionally hidden from the developer.

Memory management.

Resource ownership.

Object lifetimes.

Low-level concurrency.

Allocation details.

Most of these concerns are handled automatically.

That allows developers to focus on solving business problems rather than worrying about system internals.

For data science, web development, and automation, this is fantastic.

But it also means that developers can spend years writing software without fully understanding how resources are managed underneath.

Rust Encourages a Different Way of Thinking

One of Rust's most famous concepts is ownership.

At first glance, ownership and borrowing can seem unusual.

However, after spending some time with the language, it becomes clear why these concepts exist.

Rust forces developers to think explicitly about resources.

Who owns this data?

Who can access it?

How long should it exist?

Who is responsible for releasing it?

These questions are not merely language-specific details.

They are fundamental computing concepts.

By learning Rust, I am not simply learning syntax.

I am developing a deeper understanding of how software interacts with memory, processes, and the operating system itself.

Rust Is Teaching Me Systems Thinking

One of the most valuable lessons Rust provides is systems thinking.

Instead of focusing exclusively on application logic, Rust constantly encourages developers to think about:

• Memory allocation
• Resource management
• Concurrency
• Thread safety
• Performance
• Reliability

These topics are directly connected to Linux administration.

Even when I am not writing Rust code, the concepts I learn influence how I think about servers, services, monitoring, and infrastructure.

Rust and Modern Infrastructure

There is also a practical reason for learning Rust.

An increasing number of infrastructure, security, networking, and observability tools are being developed in Rust.

The language has gained significant adoption because it combines performance with memory safety.

As someone who spends a growing amount of time working with Linux systems, understanding Rust provides valuable context for understanding the tools that are shaping modern infrastructure.

Even if I never become a full-time Rust developer, familiarity with the language helps me better understand the ecosystem surrounding Linux and cloud-native technologies.

My Goal Is Not to Become a Rust Developer

This is an important distinction.

My primary goal is not to become a professional Rust developer.

My focus remains Linux, infrastructure, automation, and system administration.

I see Rust as a tool for learning.

A tool that helps me understand how software interacts with hardware and operating systems.

The value comes from the concepts.

The language itself is only part of the journey.

Why Python, Shell, and Rust Complement Each Other

Today, I see these three technologies as complementary rather than competing.

Python remains my preferred language for productivity.

It allows me to build solutions quickly and efficiently.

Shell Scripting allows me to interact directly with Linux and automate administrative tasks.

Rust helps me understand the mechanisms operating beneath the surface.

Together, they create a balanced skill set:

• Python for building.
• Shell for operating.
• Rust for understanding.

Each serves a different purpose.

Each strengthens a different layer of technical knowledge.

Building a Stronger Linux Foundation

One of the biggest lessons I've learned is that mastering Linux is not about collecting commands.

It is about understanding systems.

The deeper your understanding of processes, memory, services, networking, and resource management becomes, the more capable you are of solving problems that documentation alone cannot answer.

Shell Scripting and Rust are helping me build that understanding.

They are forcing me to look beyond interfaces and abstractions and explore the foundations that make Linux work.

Final Thoughts

After years of working primarily with Python and data science, I found myself increasingly curious about what happens beneath the application layer.

I wanted to understand Linux more deeply.

I wanted to better understand processes, memory, services, automation, concurrency, and the relationship between software and operating systems.

Shell Scripting helps me communicate directly with Linux.

Rust helps me understand the mechanisms behind modern software.

Neither replaces Python.

Instead, they complement it.

For anyone interested in Linux, infrastructure, system administration, or simply becoming a stronger engineer, studying both Shell Scripting and Rust can provide valuable insights into how computers actually work beneath the surface.

The goal is not just learning new tools.

The goal is developing a deeper understanding of the systems we rely on every day.