Why Every Developer Needs to Use The CLI in 2021

CLI = Command Line Interface

WARNING: This post was all written in nano, past 3am; readers discretion may be advised...

UPDATE: Last time I talked about going GUI-less and to be honest it didn't turn out as
expected.I lasted for 3 months; talk about stamina right?? LOl...

Anyways, what I was saying is; you need to get your hands on the CLI. Now, I know what you
thinking; what the use--right? There is a use, I have a philosphy that I go by: part of good
debugging comes from knowing how to use the CLI very well. By well, I don't mean Mr. Robot type
of good. Frankly I mean being good enough that you can do some damage.

Another reason(s) I think learning the CLI will help:

1. Your productivity will skyrocket (minus the bullsh!t)

Ever since I wiped my daily laptop, I've been so conditioned to use nano (yes I know it's not
as cool as vim) that it's hard to go back when I try to use sublime-text.


When Steve Jobs said: 'We made the buttons on the screen look so good you'll want to lick them',
that's when I knew; gone are the days of no-bullsh!t user interfaces. This is just my opinion; but
hear me out: ever since the turn of 2012 I started noticing every user interfaces adding useless gimicks,
that did nothing for the end user but distract them from actually doing what they intended in the first place.

Part of this we can blame it on the marketing department; that was putting more sense in dollars than more cents
in making a user interface that makes sense; cha-ching!

I know I don't have researched proof for this; but ask yourself: If social media was really designed for people
to connect why is it people feel way more disconnected than before? You could bring up many factors; but the
truth is no matter how good the UX designers get; they keep failing at prioritizing the original purpose of the
system from the start.

If the job is to design a system for an end-user; that system should have nothing but only the essential
elements that aid the user to get their work done effeciently; nothing less, nothing more.

Sorry I had to go on a tangent there; but the point is if you stick to the CLI you will barely come across
a CLI app that praises it's self for adding useless bells and whistles; you know why? IT TaKeS A LOTTT of time
to add all the menu options when your priority is avoiding bugs and getting the product shipped.

Excuse my french; I'm not always profain...

2. Your collueagues will think you're a super-hero

Unlike a hobbyist like me, messing with the CLI is like bringing
a shotgun to a knife fight. Some will think you crazy, beceause
in 20th century everything has a button and a slider...

Here is a secret: you don't have to be from the 60s or 70s
to enjoy the CLI interface. For the most part it's a skill
that if attained can open a whole new doorway of computing
for you.

Did you know you only need 3 commands (ls, cp, mv) to handle almost all
you file managment needs? Even better, for all the repetetive stuff; you
can actually automate it by scripting a BASH script. Mind-blowing right?

The reason why they'd think you're a super-hero is because the CLI
is like a swissknife (don't know if I spelt that right), in the sense
that one skill can be used across many other tools. And when it comes to
back-end web-development you will thank your self that you know a thing
or two about the CLI.

Side note: it will also give you head start on making developer tools that work
straight from the CLI.

Lastly: nothing is more rewarding as a developer when you finally solve that problem
that's been on your mind for the longest time. Now that you're in a position of being ready
to take responsibility when things break: be ready, because trust me, things will break--
and that's where the fun begins.

which brings me to my next point..

3. You'll start to appreciate a KISS dev setup

Since most dev enviroments are highly automated, gone are the days
when you used to have to keep an eye on what's happening under the hood.

The thing with software development it's like driving a car; you
got stick shift lovers and those that prefer the gears to be changed
for them by a machine. As for me I see both people to strike a great
point. My only rule for this is:

'When complexity rises, automation should rise as well...'

For instance, personally it doesn't make sense to create a
single landing webpage using react, that's overkill. And it doesn't make sense
trying to use static site generators for a websites that handles
huge ammounts of data, like a flight boarding website; unless you
got bandwidth for days and patience.

This is where tables turn; were we all want to get the
pitch forks at each other as developers; relax...nobody has to die today...or maybe?

When I first learned programming, I never understood what was the point of
DRY, KISS, TDL and all these acryonyms for writing better software. Now
I know why...

In a CLI: the system is very explicit; when things break they BREAK!
And given that you're only using a text based interface and a keyboard
to navigate the entire machine; it becomes a headache when little things
that where poorly built keep breaking. Sooner or later you get fed up.

And this is the breaking point for a lot of junior developers that try this route.
When you realize your code is sh!t and you need to do something about it;
i.e something I had to be confronted with. Since taking a step back and
learning to appcreciate the elegance and beauty of a keyboard and a black screen

that has green text all over, it's been a humbling process.

'You don't know sh!t until you realize you don't know shit...Talk about a paradox'

Just like Vin Diesel said:

'It's not the car you drive. It's the driver who's driving the car that's doing the driving'

The CLI is no different from this aproach; so is it with software development.
Since CPU's haven't scalled up much recently we have no other choice but to
optimize the systems with what we have. If a system is and usable why throw it away?

4. For a peace of mind

If you're a hardcore minimalist who's ready to do it all by yourself--the command line interface
will feel like a best friend that's been always waiting for you to introduce yourself. Maybe it's just
me; but I can say I've had to focus less on nonesense and more productivity ever since I made the switch.

'Nothing brings fresh-air like a no-bullsh!t dev enviroment'

Keep in mind it's not for the faint heart. The first day trying this, I was frustrated at how things work.
For starters, it feels like you get booted back into the 70's only difference is you actually
have this shiny hardware that you barely know how to utilize it's full power, now that you no longer a GUI
and the shiny bells and whistles that comes with many operating systems.

Aside from that, it is highly rewarding and something many developers I
recomend to try. I can't stress it enough but; it not only will teach you
to appreciate your hardware and become a better problem solver, but get
a deeper understanding of how your system trully works.

TLDR; Use the CLI because that's what 'Cool' developers do! (Maybe I'm being sarcastic...or maybe not...)