Why All Technologists Need to Stop Being Terrified of Terminals

Joe was an exceptionally gifted technical project manager. He could bend spreadsheets to his will. He could configure JIRA to shapeshift it into any report you wanted. He could QA web apps and translate complex user requirements into detailed user stories with highly granular user stories.

Joe was exceptionally afraid of the terminal. Whenever he stopped by my desk, I could see him cross his arms and lean back when I opened the terminal. His eyes would glaze over into a 1,000-yard stare. While it wasn't in his job description, I showed him how with a simple command, he could trigger a build and no longer be at the mercy of a developer to create one for him so that he could review a feature.

Joe would stare into a terminal with the same trepidation of a person staring into a dark abyss. It was unfamiliar. It was scary.

You could almost read the fears off their faces:

• What if I typed something wrong?
• What if I break something?
• Holy shit! That's a lot of scrolling text!
• How the hell do I write these commands?

Joe is the fictitious name of many real people that I know. Joe is not alone at being incredibly adept at technology while having a very visceral fear of typing commands.

This is disempowering to all the Joe's out there.

Sometimes Joe needs a very simple piece of information that could be obtained by running a command. However, if the only way to obtain that information is to wait until a developer can perform that operation for him, he could lose an hour or a day of time.

Developer Voodoo

I once had a client state that his biggest frustration was he had no idea why asking for feature A might take 1 hour while asking for a slight variation of A might take a day or a week. Without being able or (or unwilling to) look behind the curtain, developer estimates and explanations all felt like some form of voodoo.

To my client, commands written in the terminal were like a foreign language that, when executed, would act like spells conjuring pages upon pages of text whizzing down the screen like a scene from The Matrix.

Unfortunately, most documentation about terminals is written by and for developers. After all, they are the primary users, and so this makes sense. But what is lacking is a Rosetta Stone-like translation of these commands to the point and click user interfaces (UIs) that non-developers are more accustomed too.

In Defense of UIs

User interfaces are powerful and incredibly necessary. Without them, we wouldn't see devices like the iPhone get almost complete worldwide adoption. Without them, we wouldn't have 2-year olds successfully navigating through photo albums. They are beautiful guard rails that allow people to achieve goals without breaking things.

But here is the thing….

Sometimes you need to do something out of the ordinary.

Sometimes you need to run a single process thousands of times.

Sometimes the UI you need isn't yet written, and the only way to get access to that data or that operation is the good ole command line.

Thankfully, it's not as scary as you think. And if you are a technologist who is already pushing the limits of what you can do in Google Sheets or JIRA or a design program or whatever, it should be a relatively easy leap.

Command-line operations are just words, and they almost always translate to a specific function. UIs can make the processes easier for more people, but it's not always worth the time and expense.

Additionally, learning how to use a terminal gives you a leg up on others that are too afraid to try. It can also give you insights into how developers think and work.