command line

The Echo Command

Jeremy 'Jay' LaCroix — Wed, 13 Jul 2022 16:00:00 +0000

In this article, we're going to look at the echo command, which is useful for showing text on the terminal, as well as the contents of variables. Let's get started!

Basic usage of the echo command

Basic usage of the echo command is very simple. For example:

echo "Hello World"

The output will be what you expect, it will echo Hello World onto the screen. You can also use echo to view the contents of a variable:

msg="Hello World"

echo $msg

This also works for built-in shell variables as well:

echo $HOME

Additional Examples

As with most Linux commands, there's definitely more that we can do with echo;than what we've seen so far.

Audible Alerts

You can also sound an audible alert with echo as well:

echo -e "\aHello World"

The -e option allows you to change the format of the output while using echo.

echo -e "This is a\bLinux server."

The example used \b within the command, which actually lets you call backspace, which gives you the same behavior as actually pressing backspace. In the above example, the letter "a" will not print, because \b backspaces that.

Truncating

The ability to truncate, means you can remove something from the output. For example:

echo -e "This is a Linux\c server."

The output of the above command will actually truncate the word right after \c, which means we'll see the following output:

This is a Linux

Adding a new line

To force a new line to be created:

echo -e "This is a Linux\n server"

The output will end up becoming:

This is a Linux
 server.

Adding a tab character

To add a tab character to the output:

echo -e "This is a\t Linux\t server."

This will produce the following output:

This is a     Linux     server.

Redirecting output to a text file

Rather than showing the output on the terminal, we can instruct echo to instead send its output to a text file.

echo "Logfile started: $(date +'%D %T'$" > log.txt

Closing

The basics of the echo command were covered in this article. Of course, there's more options where that came from - but this should be more than enough to get you started!

You can watch the tutorial here:

Go to Full Article

7 Important Linux Commands for Every Linux User

Suparna Ganguly — Wed, 13 Oct 2021 16:00:00 +0000

by Suparna Ganguly

Linux might sound scary for first-time Linux users, but actually, it isn’t. Linux is a bunch of open-source Unix operating systems based on Linux Kernel. These operating systems are called Linux distributions, such as Fedora, Debian, Ubuntu, and Mint.

Since its inception in 1991, Linux has garnered popularity for being open-source. People can modify and redistribute Linux under their own brand. When using a Linux OS, you need a shell to access the services provided. Also, it’s recommended to run your Linux OS through a CLI or command-line interface. CLI makes time-consuming processes quicker.

This article presents a guide to 7 important Linux commands for every Linux user to know. So, let’s begin.

cat Command

cat is the shortened form of “concatenate”. It’s a frequently used multi-purpose Linux command. This command is used to create, display, and copy a file content on the standard output.

Syntax

cat [OPTION]... [FILE]..

To create a file, type:

cat >   

// Enter file content

To save the file created, press Ctrl+D. And to display the file content, execute:

cat

cd Command

The cd command is used to navigate through the directories and files in Linux. It needs either the entire path or the directory name depending on the current directory.

Syntax

cd [Options] [Directory]

Suppose you’re in /home/username/Documents. You want to navigate to a subdirectory of Documents which is Photos. To do that, execute:

cd Photos

To move to an entirely different directory, type cd and then the directory’s absolute path.

cd /home/username/Movies

The above command will switch to /home/username/Movies. Apart from this, the commands, cd.., cd, and cd- are used to move one directory up, to go to the home folder, and to go to the previous directory respectively.

Reminder: Linux’s shell is case-sensitive. So, make sure you type the name’s directory as it is.

echo Command

The echo command displays a line of text or string passed as an argument. It’s used for the purpose of debugging shell programs in the Linux terminal.

Syntax

echo [Option] [String]

Other examples of the echo command are:

echo "String": This displays the string within the quotes.
echo -e "Learn \nBy \nDoing": Here the ‘-e’ tag allows the echo command to understand the backslash escape sequences in the argument.

Go to Full Article

Develop a Linux command-line Tool to Track and Plot Covid-19 Stats

Nawaz Abbasi — Tue, 13 Apr 2021 16:00:00 +0000

by Nawaz Abbasi

It’s been over a year and we are still fighting with the pandemic at almost every aspect of our life. Thanks to technology, we have various tools and mechanisms to track Covid-19 related metrics which help us make informed decisions. This introductory-level tutorial discusses developing one such tool at just Linux command-line, from scratch.

We will start with introducing the most important parts of the tool – the APIs and the commands. We will be using 2 APIs for our tool - COVID19 API and Quickchart API and 2 key commands – curl and jq. In simple terms, curl command is used for data transfer and jq command to process JSON data.

The complete tool can be broken down into 2 keys steps:

1. Fetching (GET request) data from the COVID19 API and piping the JSON output to jq so as to process out only global data (or similarly, country specific data).

$ curl -s --location --request GET 'https://api.covid19api.com/summary' | jq -r '.Global'

{

  "NewConfirmed": 561661,

  "TotalConfirmed": 136069313,

  "NewDeaths": 8077,

  "TotalDeaths": 2937292,

  "NewRecovered": 487901,

  "TotalRecovered": 77585186,

  "Date": "2021-04-13T02:28:22.158Z"

}

2. Storing the output of step 1 in variables and calling the Quickchart API using those variables, to plot a chart. Subsequently piping the JSON output to jq so as to filter only the link to our chart.

$ curl -s -X POST \

       -H 'Content-Type: application/json' \

       -d '{"chart": {"type": "bar", "data": {"labels": ["NewConfirmed ('''${newConf}''')", "TotalConfirmed ('''${totConf}''')", "NewDeaths ('''${newDeath}''')", "TotalDeaths ('''${totDeath}''')", "NewRecovered ('''${newRecover}''')", "TotalRecovered ('''${totRecover}''')"], "datasets": [{"label": "Global Covid-19 Stats ('''${datetime}''')", "data": ['''${newConf}''', '''${totConf}''', '''${newDeath}''', '''${totDeath}''', '''${newRecover}''', '''${totRecover}''']}]}}}' \

       https://quickchart.io/chart/create | jq -r '.url'

https://quickchart.io/chart/render/zf-be27ef29-4495-4e9a-9180-dbf76f485eaf

That’s it! Now we have our data plotted out in a chart:

Go to Full Article

Linux Command Line Interface Introduction: A Guide to the Linux CLI

Antonio Riso — Tue, 06 Oct 2020 21:07:28 +0000

by Antonio Riso

Let’s get to know the Linux Command Line Interface (CLI).

Introduction
A bit of history
First look at the command line
Command syntax
Notes
Basic commands
- pwd
- ls
- file
- cat
- cd
- clear
- history
- cp
- mv
- rm

Introduction

The Linux command line is a text interface to your computer.

Also known as shell, terminal, console, command prompts and many others, is a computer program intended to interpret commands.

Allows users to execute commands by manually typing at the terminal, or has the ability to automatically execute commands which were programmed in “Shell Scripts”.

A bit of history

The Bourne Shell (sh) was originally developed by Stephen Bourne while working at Bell Labs.

Released in 1979 in the Version 7 Unix release distributed to colleges and universities.

The Bourne Again Shell (bash) was written as a free and open source replacement for the Bourne Shell.

Given the open nature of Bash, over time it has been adopted as the default shell on most Linux systems.

First look at the command line

Now that we have covered some basics, let’s open a terminal window and see how it looks!

When a terminal is open, it presents you with a prompt.

Let's analyze the screenshot above:

Line 1: The shell prompt, it is composed by username@hostname:location$

Username: our username is called “john”
Hostname: The name of the system we are logged on
Location: the working directory we are in
$: Delimits the end of prompt

After the $ sign, we can type a command and press Enter for this command to be executed.

Line 2: After the prompt, we have typed the command whoami which stands for “who am i“ and pressed [Enter] on the keyboard.

Go to Full Article

The Best Command-Line-Only Video Games

Bryan Lunduke — Wed, 07 Aug 2019 17:00:00 +0000

by Bryan Lunduke

A rundown of the biggest, most expansive and impressive games that you can run entirely in your Linux shell.

The original UNIX operating system was created, in large part, to facilitate porting a video game to a different computer. And, without UNIX, we wouldn't have Linux, which means we owe the very existence of Linux to...video games.

It's crazy, but it's true.

With that in mind, and in celebration of all things shell/terminal/command line, I want to introduce some of the best video games that run entirely in a shell—no graphics, just ASCII jumping around the screen.

And, when I say "best", I mean the very best—the terminal games that really stand out above the rest.

Although these games may not be considered to have "modern fancy-pants graphics" (also known as MFPG—it's a technical term), they are fantastically fun. Some are big, sprawling adventures, and others are smaller time-wasters. Either way, none of them are terribly large (in terms of drive storage space), and they deserve a place on any Linux rig.

AsciiPatrol

AsciiPatrol is, in my opinion, one of the most impressive terminal games out there. A clone of the classic Moon Patrol, which is a ton of fun already, this terminal-based game provides surprisingly good visuals for a game using only ASCII characters for artwork.

It has color, parallax scrolling backgrounds, animated enemies, sound effects—I mean, even the opening screen is impressive looking in a terminal.

Figure 1. Shooting Aliens and Dodging Potholes in AsciiPatrol

For a quick round of arcade-style fun, this one really can't be beat.

Cataclysm: Dark Days Ahead

Cataclysm: Dark Days Ahead is absolutely huge in scale. Think of it as a top-down, rogue-like, survival game with zombies, monsters and real end-of-the-world-type stuff.

The game features a crafting system, bodily injuries (such as a broken arm), bionic implants, farming, building of structures and vehicles, a huge map (with destructible terrain)—this game is massive. The visuals may be incredibly simple, but the gameplay is deep and open-ended.

Figure 2. Running from zombies in Cataclysm

Go to Full Article

Arduino from the Command Line: Break Free from the GUI with Git and Vim!

Matthew Hoskins — Tue, 16 Jul 2019 11:30:00 +0000

by Matthew Hoskins

Love Arduino but hate the GUI? Try arduino-cli.

In this article, I explore a new tool released by the Arduino team that can free you from the existing Java-based Arduino graphical user interface. This allows developers to use their preferred tools and workflow. And perhaps more important, it'll enable easier and deeper innovation into the Arduino toolchain itself.

The Good-Old Days

When I started building hobby electronics projects with microprocessors in the 1990s, the process entailed a discrete processor, RAM, ROM and masses of glue logic chips connected together using a point-to-point or "wire wrapping" technique. (Look it up kids!) Programs were stored on glass-windowed EPROM chips that needed to be erased under UV light. All the tools were expensive and difficult to use, and development cycles were very slow. Figures 1–3 show some examples of my mid-1990s microprocessor projects with discrete CPU, RAM and ROM. Note: no Flash, no I/O, no DACs, no ADCs, no timers—all that means more chips!

Figure 1. Example Mid-1990s Microprocessor

Figure 2. Example Mid-1990s Microprocessor

Figure 3. Example Mid-1990s Microprocessor

It all changed in 2003 with Arduino.

The word "Arduino" often invokes a wide range of opinions and sometimes emotion. For many, it represents a very low bar to entry into the world of microcontrollers. This world before 2003 often required costly, obscure and closed-source development tools. Arduino has been a great equalizer, blowing the doors off the walled garden. Arduino now represents a huge ecosystem of hardware that speaks a (mostly) common language and eases transition from one hardware platform to another. Today, if you are a company that sells microcontrollers, it's in your best interest to get your dev boards working with Arduino. It offers a low-friction path to getting your products into lots of hands quickly.

It's also important to note that Arduino's simplicity does not inhibit digging deep into the microcontroller. Nothing stops you from directly twiddling registers and using advanced features. It does, however, decrease your portability between boards.

Go to Full Article

In the End Is the Command Line

Doc Searls — Wed, 03 Jul 2019 11:30:00 +0000

by Doc Searls

Times have changed every character but one in Neal Stephenson's classic. That one is Linux.

I was wandering through Kepler's, the legendary bookstore, sometime late in 1999, when I spotted a thin volume with a hard-to-read title on the new book table. In the Beginning...Was the Command Line, the cover said.

The command line was new to me when I started writing for Linux Journal in 1996. I hadn't come from UNIX or from programming. My tech background was in ham radio and broadcast engineering, and nearly all my hacking was on RF hardware. It wasn't a joke when I said the only code I knew was Morse. But I was amazed at how useful and necessary the command line was, and I was thrilled to see Neal Stephenson was the author of that book. (Pro tip: you can tell the commercial worth of an author by the size of his or her name on the cover. If it's bigger than the title of the book, the writer's a big deal. Literally.)

So I bought it, and then I read it in one sitting. You can do the same. In fact, I command that you do, if you haven't already, because (IMHO) it's the most classic book ever written about both the command line and Linux itself—a two-fer of the first order.

And I say this in full knowledge (having re-read the whole thing many times, which is easy, because it's short) that much of what it brings up and dwells on is stale in the extreme. The MacOS and the Be operating systems are long gone (and the Be computer was kind of dead on arrival), along with the Windows of that time. Today Apple's OS X is BSD at its core, while Microsoft produces lots of open-source code and contributes mightily to The Linux Foundation. Some of Neal's observations and complaints about computing and the culture of the time also have faded in relevance, although some remain enduringly right-on. (If you want to read a section-by-section critique of the thing, Garrett Birkel produced one in the mid-2000s with Neal's permission. But do read the book first.)

What's great about Command Line is how well it explains the original virtues of UNIX, and of Linux as the operating system making the most of it:

The file systems of Unix machines all have the same general structure. On your flimsy operating systems, you can create directories (folders) and give them names like Frodo or My Stuff and put them pretty much anywhere you like. But under Unix the highest level—the root—of the filesystem is always designated with the single character "/" and it always contains the same set of top-level directories:

Go to Full Article

The Command-Line Issue

Bryan Lunduke — Mon, 01 Jul 2019 15:00:00 +0000

by Bryan Lunduke

Summer. 1980-something. An elementary-school-attending, Knight Rider-T-Shirt-wearing version of myself slowly rolls out of bed and shuffles to the living room. There, nestled between an imposingly large potted plant and an over-stocked knick-knack shelf, rested a beautifully gray, metallic case powered by an Intel 80286 processor—with a glorious, 16-color EGA monitor resting atop.

This was to be my primary resting place for the remainder of the day: in front of the family computer.

That PC had no graphical user interface to speak of—no X Window System, no Microsoft Windows, no Macintosh Finder. There was just a simple command line—in this case, MS-DOS. (This was long before Linux became a thing.) Every task I wished to perform—executing a game, moving files—required me to type the commands in via a satisfyingly loud, clicky keyboard. No, "required" isn't the right word here. Using the computer was a joy. "Allowed" is the right word. I was allowed to enjoy typing those commands in. I never once resented that my computer needed to be interacted with via a keyboard. That is, after all, what computers do. That's what they're for—you type in commands, and the computer executes them for you, often with a "beep".

For a kid, this was empowering—taking my rudimentary understanding of language (aided, at first, by a handy DOS command cheat sheet) and weaving together strings of words that commanded the computer to do my bidding. It was like organizing runes to enact an ancient spell. It was magic. And I was a wizard. Did I miss not being able to "double click" or "drag and drop"? Of course not. I'd seen some such, mouse-driven user interfaces (like the early Macintoshes) but—from my vantage—that wasn't how computers really worked. I viewed such things as cool-looking, but not necessary. Computers use words. Powerful, magical words.

But this isn't 1980-something. In fact, it's barely 2010-something. (Did anyone else just realize that it's almost 2020?) For better or worse, how people use—and view—computers has changed dramatically since the days of Knight Rider. Modern operating systems are, often, belittled if they require users to interact with the machine via a command line. The graphical user interface is king. Which is, perhaps, the inevitable evolution of how we all interact with our computers.

Yet the value of the command line (or terminal, shell and so on) is still there. For many, it makes using computers more accessible. For others, it provides streamlined workflows that a mouse or touch-driven interface simply can't compete with. And, for others still, the blinking cursor provides a bit of nostalgic joy—or an aesthetically simple, and distraction free, environment.

This issue of Linux Journal celebrates the cursor—that wonderful blinking underscore and all the potential that it holds.

Go to Full Article

Without a GUI--How to Live Entirely in a Terminal

Bryan Lunduke — Fri, 28 Jun 2019 11:00:00 +0000

by Bryan Lunduke

Sure, it may be hard, but it is possible to give up graphical interfaces entirely—even in 2019.

About three years back, I attempted to live entirely on the command line for 30 days—no graphical interface, no X Server, just a big-old terminal and me, for a month.

I lasted all of ten days.

Why did I attempt this? What on Earth would compel a man to give up all the trappings and features of modern graphical desktops and, instead, artificially restrict himself to using nothing but text-based, command-line software, as if he were stuck in the early 1980s?

Who knows. Clearly, I make questionable decisions.

But you know, if I'm being honest, the experience was not entirely unpleasant. Sure, I missed certain niceties from the graphical side of things, but there were some distinct benefits to living in a shell. My computers, even the low-powered ones, felt faster (command-line software tends to be a whole lot lighter and leaner than those with a graphical user interface). Plus, I was able to focus and get more work done without all the distractions of a graphical desktop, which wasn't bad.

What follows are the applications I found myself relying upon the most during those fateful ten days, separated into categories. In some cases, these are applications I currently use over (or in addition to) their graphical equivalents.

Quite honestly, it is entirely possible to live completely without a GUI (more or less)—even today, in 2019. And, these applications make it possible—challenging, but possible.

Web Browsing

Plenty of command-line web browsers exist. The classic Lynx typically comes to mind, as does ELinks. Both are capable of browsing basic HTML websites just fine. In fact, the experience of doing so is rather enjoyable. Sure, most websites don't load properly in the "everything is a dynamically loading, JavaScript thingamadoodle" future we live in, but the ones that do load, load fast, and free of distractions, which makes reading them downright enjoyable.

But for me, personally, I recommend w3m.

Figure 1. Browsing Wikipedia with Inline Images Using w3m

w3m supports inline images (via installing the w3m-img package)—seriously, a web browser with image support, inside the terminal. The future is now.

It also makes filling out web forms easy—well, maybe not easy, but at least doable—by opening a configured text editor (such as nano or vim) for entering form text. It feels a little weird the first time you do it, but it's surprisingly intuitive.

Go to Full Article

FreeDOS's Linux Roots

Jim Hall — Thu, 27 Jun 2019 11:30:00 +0000

by Jim Hall

On June 29, 2019, the FreeDOS Project turns 25 years old. That's a major milestone for any open-source software project! In honor of this anniversary, Jim Hall shares this look at how FreeDOS got started and describes its Linux roots.

The Origins of FreeDOS

I've been involved with computers from an early age. In the late 1970s, my family bought an Apple II computer. It was here that I taught myself how to write programs in AppleSoft BASIC. These were not always simple programs. I quickly advanced from writing trivial "math quiz" programs to more complex "Dungeons and Dragons"-style adventure games, complete with graphics.

In the early 1980s, my parents replaced the Apple with an IBM Personal Computer running MS-DOS. Compared to the Apple, the PC had a much more powerful command line. You could connect simple utilities and commands to do more complex functions. I fell in love with DOS.

Throughout the 1980s and into the early 1990s, I considered myself a DOS "power user". I taught myself how to write programs in C and created new DOS command-line utilities that enhanced my MS-DOS experience. Some of my custom utilities merely reproduced the MS-DOS command line with a few extra features. Other programs added new functionality to my command-line experience.

I discovered Linux in 1993 and instantly recognized it as a Big Deal. Linux had a command line that was much more powerful than MS-DOS, and you could view the source code to study the Linux commands, fix bugs and add new features. I installed Linux on my computer, in a dual-boot configuration with MS-DOS. Since Linux didn't have the applications I needed as a working college student (a word processor to write class papers or a spreadsheet program to do physics lab analysis), I booted into MS-DOS to do much of my classwork and into Linux to do other things. I was moving to Linux, but I still relied on MS-DOS.

In 1994, I read articles in technology magazines saying that Microsoft planned to do away with MS-DOS soon. The next version of Windows would not use DOS. MS-DOS was on the way out. I'd already tried Windows 3, and I wasn't impressed. Windows was not great. And, running Windows would mean replacing the DOS applications that I used every day. I wanted to keep using DOS. I decided that the only way to keep DOS was to write my own. On June 29, 1994, I announced my plans on the Usenet discussion group comp.os.msdos.apps, and things took off from there:

ANNOUNCEMENT OF PD-DOS PROJECT:

A few months ago, I posted articles relating to starting a public domain version of DOS. The general support for this at the time was strong, and many people agreed with the statement, "start writing!" So, I have...

Go to Full Article

command line

The Echo Command

Basic usage of the echo command

Additional Examples

Closing

7 Important Linux Commands for Every Linux User

cat Command

Syntax
cat [OPTION]... [FILE]..

cd Command

Syntax
cd [Options] [Directory]

echo Command

Syntax
echo [Option] [String]

Develop a Linux command-line Tool to Track and Plot Covid-19 Stats

Linux Command Line Interface Introduction: A Guide to the Linux CLI

Let’s get to know the Linux Command Line Interface (CLI).

The Best Command-Line-Only Video Games

Arduino from the Command Line: Break Free from the GUI with Git and Vim!

In the End Is the Command Line

The Command-Line Issue

Without a GUI--How to Live Entirely in a Terminal

FreeDOS's Linux Roots