The Best Programming Language Is the One That Solves Your Annoyance

Ishe Chinyoka

- 6 minutes read

Table of Contents

When people ask me how I learned programming, they sometimes expect a dramatic story.

Perhaps I wrote my first program at twelve.

Perhaps I studied computer science.

Perhaps I fell in love with algorithms.

The truth is much less exciting.

I became a programmer because I became tired.

Not tired of programming.

Tired of repetitive work.

I am going to share with you my own experience of how I was slowly sucked into this exciting world as a way to kickstart a discussion on shell scripting this week. Considering that this Sunday’s book review was on Shell Scripting by Steve parker, it is only appropriate that I demonstrate how my need drove me to the edge until I found a solution in shell scripting.

Programming looked intimidating

Like many people, I first encountered programming through languages such as JavaScript. It was fascinating, but it also felt like entering another world. There were variables, functions, loops, objects, and enough unfamiliar terminology to convince me that programming belonged to “real programmers.”

I admired people who could write software, but I did not yet think of myself as one of them.

Then a very ordinary problem appeared.

My Downloads folder became a mess.

Every PDF, ZIP archive, document, image, and installer landed in the same place. Finding anything meant scrolling through an ever-growing list of files.

Naturally, I searched for a program that could organize everything for me.

The search for the perfect application

Back then I was still using Windows.

There seemed to be an application for everything—provided someone else had already decided that your problem was worth solving.

Many of the better utilities were commercial. Others almost solved the problem but not quite. Some were abandoned. Others were filled with features I neither wanted nor needed.

It slowly dawned on me that software developers build tools for large audiences.

If your problem is too niche, there may never be a polished application waiting for you.

For years I assumed that was simply the way computers worked.

Unix suggested a different answer

Then I moved to Linux.

One of the first surprises was the Unix philosophy.

Instead of encouraging me to search endlessly for one perfect application, Unix quietly suggested something different:

“Why not build exactly the tool you need?”

At first, that sounded absurd.

I wasn’t a programmer.

Or so I thought.

Then I discovered shell scripting.

My first useful program

The script was wonderfully simple.

It looked at newly downloaded files, identified their type—sometimes by extension, sometimes using the file command—and moved them into appropriate directories.

Documents went one way.

Archives another.

Images somewhere else.

Installers to their own folder.

It wasn’t sophisticated.

It didn’t have a graphical interface.

No one else would probably have downloaded it.

But it solved my problem.

For the first time, I experienced something remarkable.

Instead of adapting my habits to suit a piece of software, I had adapted the software to suit my habits.

That changed everything.

The shell doesn’t feel like programming

One reason shell scripting is such a wonderful introduction to programming is that it rarely feels like programming.

You begin by typing commands.

find .
grep
mv
cp
file
sort

Then you connect them together.

Then you save those commands into a file.

Without quite noticing, you’ve written a program.

The shell lowers the barrier between using the computer and extending the computer.

That is one of Unix’s greatest gifts.

Small annoyances become small tools

Once I solved my Downloads problem, I started noticing other little annoyances.

Typing the same backup commands every evening.

Creating new blog posts.

Preparing project directories.

Publishing websites.

Checking configuration files.

One by one, each annoyance became another tiny script.

Before long, I had accumulated a growing collection of personal utilities.

Some lived in ~/.local/bin.

Others belonged in ~/.config/bash/scripts.

Both directories sit comfortably in my $PATH, quietly waiting whenever I need them.

None of these programs would interest thousands of users.

But they save me time every single day.

That is enough.

Your computer becomes your workshop

There is something deeply satisfying about reaching for a command you wrote yourself.

It reflects your habits.

It uses your terminology.

It follows your workflow.

No software company held a meeting to decide whether your feature request was commercially viable.

You simply built it.

That is a profoundly different relationship with a computer.

Instead of consuming software, you begin crafting your own tools.

The workshop grows one script at a time.

AI makes this even more valuable

Today, AI can generate shell scripts in seconds.

That is wonderful.

It means the barrier to creating personal tools is even lower than before.

But AI has not removed the need to understand shell scripting.

Quite the opposite.

Someone still needs to decide what should happen.

Someone still needs to recognize whether a generated command is safe.

Someone still needs to adapt it to their own workflow.

AI may accelerate the construction of your workshop.

You are still the architect.

Programming begins with ownership

Looking back, I no longer think my first shell script was really about organizing downloads.

It was about ownership.

It taught me that I did not have to wait for someone else to solve my problems.

If a repetitive task bothered me, I could teach the computer to do it instead.

That lesson has stayed with me ever since.

The language itself almost became secondary.

The real discovery was that programming is not reserved for professional software developers.

It is simply another way of shaping your tools to fit your work.

The Textsmith’s Take

People often ask which programming language they should learn first.

Python is an excellent answer.

Rust is a wonderful answer.

JavaScript is a practical answer.

But there is another answer that is often overlooked.

Learn the language that solves the problem currently sitting in front of you.

For me, that language was Bash.

Not because it is the most elegant language ever designed.

Not because it is the most modern.

But because it transformed me from someone who searched endlessly for software into someone who quietly built it.

The best programming language is not always the fastest, the most fashionable, or the most powerful.

Sometimes it is simply the one that solves your annoyance.

And once you discover that, you stop seeing programming as something other people do.

You begin seeing it as another form of writing—one that teaches your computer to work the way you do.