BeagleBone For Dummies (2015)

---

Removing files and directories

To remove files, you can use the rm command:

debian@beaglebone:~/project$ ls
bye2.txt Code_for_the_project helloAndBye.txt list.txt
bye.txt hello2.txt hello.txt stuff
CircuitSchematic hello3.txt ListOfMaterials TheoreticalStuff
debian@beaglebone:~/project$ rm hello.txt
debian@beaglebone:~/project$ ls
bye2.txt hello3.txt stuff
bye.txt helloAndBye.txt teste2.txt
circuitSchematic hello.txt teste.txt
Code_for_the_project ListOfMaterials theoretical_stuff
hello2.txt list.txt

There’s no way to undelete files and directories when you delete them this way, so be cautious! The rm command also works for directories, but special care is required when you use it for that purpose; directories are special files, after all. If you attempt to remove a directory through the normal use of rm, this message would be the result:

debian@beaglebone:~/project$ rm ListOfMaterials
rm: cannot remove ‛ListOfMaterials': Is a directory

This message means that you need to use rm with some of the available options to remove directories. You can use three options with the rm command:

· -r, which recursively (hence the name) removes the contents of directories from bottom to top to ensure that no files are left without a directory to reside in

· -i, which prompts the user to confirm each deletion

· -f, which forces its way down, overriding any confirmation prompts that may occur for some specific files

Use the following command remove the stuff folder created in earlier examples in this chapter:

debian@beaglebone:~/project$ rm -rfi stuff
rm: descend into directory ‛stuff'? y
rm: descend into directory ‛stuff/schematics'? y
rm: remove directory ‛stuff/schematics/datasheets'? y
rm: remove directory ‛stuff/schematics'? y
rm: remove directory ‛stuff'? y

The -i and -f options are sort of contradictory, and the one that comes last is the one that’s dominant. In other words, rm -rif would be quite different from rm -rfi, which is used in the preceding example. The-i option would be ignored, and everything would be removed right away. Most of the time, using either rm -rf or -ri makes more sense.

Naturally, you can use each of these options independently. If you don’t use -i, everything is deleted without asking for permission; if you don’t use -f, you’d probably see no difference, because there are no files in that folder you need to force to be deleted; and if you don’t use -r, you get the error message shown earlier in this section.

Another way to remove a directory safely is to use the rmdir command, which forbids you from deleting folders that still have content. The following example illustrate how this command works in a new folder:

debian@beaglebone:~/project$ mkdir toBeDeleted
debian@beaglebone:~/project$ cd toBeDeleted
debian@beaglebone:~/project/toBeDeleted$ touch file1 file2 file3
debian@beaglebone:~/project/toBeDeleted$ ls
file1 file2 file3
debian@beaglebone:~/project/toBeDeleted$ cd ..
debian@beaglebone:~/project$ rmdir toBeDeleted
rmdir: failed to remove ‛toBeDeleted': Directory not empty
debian@beaglebone:~/project$ cd toBeDeleted
debian@beaglebone:~/project/toBeDeleted$ rm file1 file2 file3
debian@beaglebone:~/project/toBeDeleted$ ls
debian@beaglebone:~/project/toBeDeleted$ cd ..
debian@beaglebone:~/project$ rmdir toBeDeleted
debian@beaglebone:~/project$ ls
bye2.txt hello3.txt teste2.txt
bye.txt helloAndBye.txt teste.txt
circuitSchematic hello.txt theoretical_stuff
Code_for_the_project ListOfMaterials
hello2.txt list.txt

Note that we didn’t specify a file type, such as .txt, with touch. The truth is, for simple text files, specifying a file type doesn’t matter. By definition, an empty file or blank file is a file with the size of 0 bytes, which is what an empty .txt file is.

You can delete a directory while you’re still inside it. When you do that, the prompt still tells you that you’re inside that directory, but when you leave it, you realize that the directory has ceased to exist:

debian@beaglebone:~/project$ mkdir toBeDeleted
debian@beaglebone:~/project$ cd toBeDeleted
debian@beaglebone:~/project/toBeDeleted$ rmdir ../toBeDeleted
debian@beaglebone:~/project/toBeDeleted$ cd ..
debian@beaglebone:~/project$ ls
bye2.txt hello3.txt teste2.txt
bye.txt helloAndBye.txt teste.txt
circuitSchematic hello.txt theoretical_stuff
Code_for_the_project ListOfMaterials
hello2.txt list.txt

When you type a command without specifying a path, the shell assumes that you’re talking about a file inside your current directory. In the preceding example, there’s no toBeDeleted directory inside toBeDeleted, which is why you need to use rmdir with the relative path ../toBeDeleted.

Copying and renaming files

Copying and renaming files are common tasks, no matter what OS you use. In Linux, you can perform these tasks by using pretty straightforward commands. For copying, you use the following command:

cp [OPTIONS] <copy_from><copy_to>

copy_from is the name of the file from which you want to copy a file, and copy_to is where you want to save the copied file. The following code illustrates this command, starting by creating a <copy_to> folder:

debian@beaglebone:~/project$ mkdir importantFiles
debian@beaglebone:~/project$ cp hello2.txt importantFiles

The syntax for moving a file with the mv command is the same as the syntax for the cp command:

debian@beaglebone:~/project$ mv bye.txt importantFiles

If the importantFiles directory didn’t exist, the mv command would rename the file bye.txt, making it importantFiles. Although this renaming may lead to confusion and unexpected errors, use the following technique to rename files from the command prompt:

debian@beaglebone:~/project$ cd importantFiles
debian@beaglebone:~/project/importantFiles mv hello2.txt greetings.txt
debian@beaglebone:~/project/importantFiles cd ..

Now confirm the results of what you just typed :

debian@beaglebone:~/project$ ls importantFiles
bye.txt greetings.txt

The mv command means either “move a file” or “rename a file,” depending on whether its second input is a directory that already exists.

If the destination folder already has a file with the same name as the file you’re copying, that file will be overwritten!

You can use several options with these commands, two of which are quite useful and probably familiar to you. One option is-i, which protects you from overwriting files in the same way that you’re protected from deleting files with rm; you’re prompted to confirm before the file is overwritten. The other option is-v, which describes what’s going on, just like when it’s used with mkdir.

Selecting multiple files in Linux

Sometimes, you need to select multiple files, but without a GUI, dragging the mouse won’t do. When you use the command line, you can select multiple files by using wildcards.

The name does them justice, as wildcards are special characters that can be used to represent any character in different ways. Rather than providing a filename for your command to work with, you provide a pattern. The best way to explain this concept is to provide examples.

Start by creating a new folder (for matters of organization) and filling it with files of a similar name:

debian@beaglebone:~/project$ mkdir Hellos
debian@beaglebone:~/project$ cd Hellos
debian@beaglebone:~/project/Hellos$ touch hello1.txt hello2.txt hello3.txt hello4.txt
debian@beaglebone:~/project/Hellos$ ls
hello1.txt hello2.txt hello3.txt hello4.txt

Naturally, the patterns here are hello and .txt. You can use three wildcards.

The question-mark (?) wildcard replaces one single character, so hello?.txt refers to all those hellos. Try it with the file command:

debian@beaglebone:~/project/Hellos file hello?.txt
hello1.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty

Note, however, that the ? wildcard replaces just one character. If you had more than ten hellos, this code would select only the first nine:

debian@beaglebone:~/project/Hellos touch hello12.txt
debian@beaglebone:~/project/Hellos file hello?.txt
hello1.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty

This example is where the asterisk (*) wildcard comes in. Rather than replacing just one single character, it replaces any number of characters. hello* selects everything that starts with hello; *.txt selects everything that ends in .txt; and *hello* selects everything that has the word hello in it:

debian@beaglebone:~/project/Hellos touch oh_hello.txt helloBuddy.txt
debian@beaglebone:~/project/Hellos file hello*
hello12.txt: empty
hello1.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty
helloBuddy.txt: empty

debian@beaglebone:~/project/Hellos file *.txt
hello12.txt: empty
hello1.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty
helloBuddy.txt: empty
oh_hello.txt: empty

debian@beaglebone:~/project/Hellos file *hello*
hello12.txt: empty
hello1.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty
helloBuddy.txt: empty
oh_hello.txt: empty

As expected, file hello* won’t return information about the oh_hello.txt file, and file *hello* and file *.txt won’t miss any file. Note, however, that if you had files with the names bye.txt and hello.jpg in there, these two commands would yield different results: file *hello* would ignore bye.txt, and file *.txt would ignore hello.jpg.

The last wildcard is square brackets ([ ]), which replaces a character with a set of specific letters. To select all files whose names start with a, b, or c, for example, you can use [abc]*:

debian@beaglebone:~/project/Hellos touch awesome beaglebone can do extremely fantastic gigs
debian@beaglebone:~/project/Hellos file [abc]*
awesome: empty
beaglebone: empty
can: empty

You can also use [ ] the other way around, to select files that don’t not start with the specified characters, by using the ^ character:

debian@beaglebone:~/project/Hellos file [^abc]*
do: empty
extremely: empty
fantastic: empty
gigs: empty
hello12.txt: empty
hello1.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty
helloBuddy.txt: empty
oh_hello.txt: empty

Finally, you can specify a range by using [ ] and a hyphen, like so:

debian@beaglebone:~/project/Hellos file [b-e]*
beaglebone: empty
can: empty
do: empty
extremely: empty

Wildcards may be a bit confusing, but all you need to remember is the rule of thumb that a wildcard replaces one or more characters, allowing you to narrow or broaden the number of files you want to select. Playing around with wildcards is the best way to get a feel for how to use them. Following are some more examples, the first two of which deserve special attention and explanation:

debian@beaglebone:~/project/Hellos touch hello23.txt
debian@beaglebone:~/project/Hellos file hello[23].txt
hello2.txt: empty
hello3.txt: empty

hello23.txt doesn’t appear when you use file hello[23].txt. Weird, huh? This result is due to the fact that what’s inside the brackets is a list of one possible character to substitute for one character immediately next to hello and before .txt. file hello[23][23].txt or hello[32][32].txt or any other combination, would display hello23.txt but not hello2.txt or hello3.txt because it’s looking for twocharacters before .txt:

debian@beaglebone:~/project/Hellos touch A
debian@beaglebone:~/project/Hellos file *a*
awesome: empty
beaglebone: empty
can: empty
fantastic: empty

In this example, you’re selecting all files whose names contain a. The file A doesn’t appear due to the fact that, as stated earlier in this chapter, Linux is case-sensitive. The letter a and the letter A are completely different characters.

Here are some more examples to help you get familiar with how wildcards work:

debian@beaglebone:~/project/Hellos file hello[2-4].txt
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty
debian@beaglebone:~/project/Hellos file hello??.txt
hello12.txt: empty
debian@beaglebone:~/project/Hellos file hello[^23]*
hello12.txt: empty
hello1.txt: empty
hello4.txt: empty
helloBuddy.txt: empty
debian@beaglebone:~/project/Hellos file ?
A: empty
debian@beaglebone:~/project/Hellos file *
A: empty
awesome: empty
beaglebone: empty
can: empty
do: empty
extremely: empty
fantastic: empty
gigs: empty
hello12.txt: empty
hello1.txt: empty
hello23.txt: empty
hello2.txt: empty
hello3.txt: empty
hello4.txt: empty
helloBuddy.txt: empty
oh_hello.txt: empty

You can use wildcards with any other commands, just as you’d use the name of a file. As proof, bid adieu to the Hellos directory as follows:

debian@beaglebone:~/project/Hellos rm -v *hello*
removed ‛hello12.txt'
removed ‛hello1.txt'
removed ‛hello2.txt'
removed ‛hello3.txt'
removed ‛hello4.txt'
removed ‛helloBuddy.txt'
removed ‛oh_hello.txt'
debian@beaglebone:~/project/Hellos ls
A awesome beaglebone can do extremely fantastic gigs

You could simply have deleted everything right away by using the * wildcard because it replaces any number of characters. The following code does that:

debian@beaglebone:~/project/Hellos$ rm -v *
removed ‛A'
removed ‛awesome'
removed ‛beaglebone'
removed ‛can'
removed ‛do'
removed ‛extremely'
removed ‛fantastic'
removed ‛gigs'
debian@beaglebone:~/project/Hellos$ ls
debian@beaglebone:~/project/Hellos$ cd ..
debian@beaglebone:~/project$ rmdir Hellos

The computer uses spaces to separate the inputs of commands! That said, when you’re using asterisks, an accidental space could lead to catastrophic results. Suppose that you want to delete all the .jpg files you have inside a folder. To do that, you could use

rm *.jpg

Had you unwittingly placed an extra space in the command, as in

rm * .jpg

the shell would interpret this command as a direction to remove * — which means remove everything — and then attempt to remove a file named .jpg. You may unwittingly delete a very important file in that directory, and there’s no “undelete” option. One solution would be to use the -i option whenever you decide to delete many files, but having to confirm each deletion would be tedious and would defeat the purpose of using wildcards. The best solution is simply to be very cautious whenever you’re deleting files — and to double that caution if you’re doing so by resorting to wildcards.

You should always be cautious when deleting files. If, for any specific project you may encounter in the future, you find yourself working as a superuser, that caution should be much greater. Nothing can hold you back from deleting everything on the computer, leading to a system crash due to the deletion of a crucial file, directory, or whatever. The command that causes this problem is rm -rf /* issued by someone who’s logged in as superuser. We’re exposing you to this command because someone, somewhere may claim that it’s the solution to the problem you’re having. Now you’re prepared for this claim, and you can ignore it. You can also laugh and say, “Ah, almost got me there!”

Using long-listing format and permissions

Earlier in this chapter, in the section “Listing files and directories,” we introduce the long-listing format of the ls command, which is displayed when you use it with the -l option. This format offers quite a bit of information about the files in the directory you list:

debian@beaglebone:~/project$ ls -l
total 32
-rw-r--r-- 1 debian debian 32 Jul 1 00:11 bye2.txt
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 CircuitSchematic
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 Code_for_the_project
-rw-r--r-- 1 debian debian 0 Jul 1 00:11 hello2.txt

-rw-r--r-- 1 debian debian 0 Jul 1 00:11 hello3.txt
-rw-r--r-- 1 debian debian 43 Jul 1 00:09 helloAndBye.txt
drwxr-xr-x 2 debian debian 4096 Jul 1 00:43 importantFiles
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 ListOfMaterials
-rw-r--r-- 1 debian debian 18 Jul 1 00:15 list.txt
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 TheoreticalStuff

You should dissect these lines for the information they contain. Starting from the right (because those commands are the most intuitive and the easiest to explain), you have the following:

· The filename (bye2.txt): Remember that the names of directories are also filenames.

· The time and date of the last modification (Jul 1 00:11): If you had an older file, this format would change slightly. Rather than showing the time when you last altered the file, the year in which you modified it would be displayed.

· The size of the file, measured in bytes (32 or 4096): One important thing to note is that for the directories, this number is the size of the file that represents the directory, not the sum of the contents of the directory. Thus, all directories display a size of 4096 bytes, regardless of whether they are empty. To have the sizes of the contents printed in units that make more sense (such as 1K, 120M, and 2G), use the -h (human-readable) option.

· The owner of the file and the group that owns it (debian debian): The two columns that feature debian represent, from left to right, the owner of the file and the group that owns it. Thus, the second column could be something like LabPCs.

· The number of hard links to the file (1 or 2): The number before debian represents the number of hard links to the file. In the case of a directory, that number is the number of immediate subdirectories it contains, as well as the directory itself and the parent directory. Therefore, a directory with no subdirectories has at least two hard links to it.

The remaining columns consist of information regarding permissions; they provide insight into who is able to use the files and in which ways. You can do three things with a file: read it (r), write in it (w), and execute it (x). Also, there are three groups of people, from the point of view of your computer: the owner, the group, and the world.

That information is provided in the leftmost part of each line and is always a combination of ten characters. To understand this code, you can break it into four parts: one for the size of one character and three for the sizes of three characters:

· The first character tells you what kind of file you’re dealing with: a regular file (-) or a directory (d).

· Next are the permissions for the owner (the first three characters), the group (the next three characters), and everyone else (the last three characters). For a specific file, someone who has read permission can open the contents of the file or list a directory; someone who has write permission can change the contents of the file and of a directory (such as by creating or deleting files); and someone who has execute permission for a regular file can use it as a program and run it, or enter a directory.

Typically, you see -rw-r--r-- in a file. This code means that the owner can read it and write in it, and everyone else (the group and the world) can read it but not make any changes. The code is always rwx, so if you see a hyphen in the place of one of these letters, the file doesn’t give that specific permission to that group of people.

For a directory, you often see drwxr-xr-x. Here’s the letter-by-letter translation:

· It’s a directory (d).

· The owner can read, write, and execute it (rwx). Because this item is a directory, the owner can see its contents with the ls command or when using a GUI (read permission), add files to or delete files from it (write permission), and get inside the directory (execute permission).

· The group can read and execute it (r-x) but not write in it, meaning that they can list its contents (read permission) and also get inside it (execute permission), but they can’t create or delete any files (no write permission).

· Everyone else has the same permissions as the group — that is, they can check the contents without messing around with them.

Two small details are worth noting:

· Even if a file gives you write permission, it still answers to the directory that contains it. Even though you can alter the file itself, you can rename or delete it only if you have write permission for its directory.

· In reality, you can’t do anything in a directory if you don’t have the execute permission, so a three-character indicator such as rw- doesn’t allow you to do anything. Most things that you try to do result in a Permission denied error.

The chmod command enables you to change a file’s permissions. You have many ways to use this command, but perhaps the most intuitive way is to use the sum (+) and subtraction (-) operators, along with the people or groups to which you want to give or remove permissions: the user (the owner of the file), the group, the world (other users), or all of these by using u, g, o, or a, respectively.

In the following example a command removes write permission from hello2.txt for the user, gives write permission to the group for bye2.txt, and grants execute permission to the world for hello3.txt:

debian@beaglebone:~/project$ ls -l
total 32
-rw-r--r-- 1 debian debian 32 Jul 1 00:11 bye2.txt
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 CircuitSchematic
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 Code_for_the_project
-rw-r--r-- 1 debian debian 0 Jul 1 00:11 hello2.txt
-rw-r--r-- 1 debian debian 0 Jul 1 00:11 hello3.txt
-rw-r--r-- 1 debian debian 43 Jul 1 00:09 helloAndBye.txt
drwxr-xr-x 2 debian debian 4096 Jul 1 00:43 importantFiles
drwxr-xr-x 2 debian debian 4096 Jun 30 23:58 ListOfMaterials
-rw-r--r-- 1 debian debian 18 Jul 1 00:15 list.txt
drwxr-xr-x 2 debian root 4096 Jun 30 23:58 TheoreticalStuff
debian@beaglebone:~/project$ chmod u-w hello2.txt
debian@beaglebone:~/project$ chmod g+w bye2.txt
debian@beaglebone:~/project$ chmod o+x hello3.txt
debian@beaglebone:~/project$ ls -l
total 44
drwxr-xr-x 2 debian debian 4096 Apr 23 2014 Code_for_the_project
drwxr-xr-x 2 debian debian 4096 Apr 23 2014 ListOfMaterials
-rw-r--r-- 1 debian debian 10 Apr 23 2014 bye.txt
-r--rw-r-- 1 debian debian 35 Apr 23 2014 bye2.txt
drwxr-xr-x 2 debian debian 4096 Apr 23 2014 circuitSchematic
-rw-r--r-- 1 debian debian 33 Apr 23 2014 hello.txt
-r--r--r-- 1 debian debian 0 Apr 23 2014 hello2.txt
-r--r--r-x 1 debian debian 0 Apr 23 2014 hello3.txt
-rw-r--r-- 1 debian debian 43 Apr 23 2014 helloAndBye.txt
-rw-r--r-- 1 debian debian 173 Apr 23 2014 list.txt
-rw-r--r-- 1 debian debian 9 Apr 23 2014 teste.txt
-rw-r--r-- 1 debian debian 9 Apr 23 2014 teste2.txt
drwxr-xr-x 2 debian debian 4096 Apr 23 2014 theoretical_stuff

As you can verify, the user lost his or her permission to write in the file hello2.txt. To confirm, use the echo command:

debian@beaglebone:~/project$ echo 'This will not work' > hell
o2.txt
-bash: hello2.txt: Permission denied

For bye2.txt, even though you can’t readily test it, you can check the list to see that the group was given write permission for it. The same applies to hello3.txt, which now shows an x that wasn’t there earlier.

Managing Software on Your BeagleBone

When you know your way around the command line, downloading and installing new software on a computer or device running the Linux OS is quite easy and straightforward. The software comes in what are called packages— software programs that can be downloaded from the Internet and installed simply by typing a command in the prompt.

To download and install these packages, you normally use a package manager, which downloads and installs not only the software you requested, but also all other required software, known as dependencies. The Debian distribution uses a package manager called apt.

If you read other literature about the BeagleBone, you may find that you should use the opkg utility as the package manager. As mentioned in Chapter 2, up until recently, the standard distribution used by the BeagleBone was Ångström. The examples in this book use the Debian distribution, so apt is the way to go.

To manage your software, you need the authorization of the administrator, whom you already know as the superuser. Being logged in as root is often considered to be unsafe, as the computer becomes vulnerable not only to its user (who may unwittingly make undesired changes in the file system), but also to malicious software that may have gotten inside. With that in mind, you can carry out a command with the authorization of the root user without being logged in as such. To do so, type sudo (superuser do) before a command.

In any other situation, if you get an error message telling you that the command you typed can be executed only with the authorization of root, try using sudo before it. Be cautious, though. If the command is telling you that it needs the authorization of root, it’s probably because something serious is involved!

First and foremost, you have to update the list of available package versions that your package manager is aware of. (The package manager keeps such a list in the BeagleBone’s file system.) Type the following command:

sudo apt-get update

You need to be connected to the Internet for this command to work.

Text scrolls by after you type the command, giving information about the newest listings.

Next, you should update the software, which you can achieve by commanding apt to upgrade. This command upgrades all the packages you’ve installed to their most recent versions:

sudo apt-get upgrade

In terms of wording, the difference between updating and upgrading is subtle, but what they do is quite different (even though they’re usually done together). sudo apt-get update updates the list of available package versions but doesn’t install or upgrade any of them, whereas sudo apt-get upgrade updates the packages themselves, checking the list to do so. For that reason, you should always run update before upgrade.

Installing software

To install a package for which you already know the name, you have to type the following command:

sudo apt-get install <desired application>

To see how this process works, use the following command to install the Midnight Commander application, which is a visual file manager:

sudo apt-get install mc

This command downloads the package from the Internet and installs it, as well as any dependencies it requires to work properly.

Always run sudo apt-get update before installing software.

Running software

To run programs directly from the prompt, simply type their names, as shown in the following command and in Figure 4-4:

debian@beaglebone:~$ mc

Figure 4-4: Running Midnight Commander through PuTTY.

Updating software

You can update the latest versions of your software by typing the upgrade command:

sudo apt-get upgrade

Generally, though, you want to update the list of available package versions before you upgrade to ensure that apt gets you the most recent updates for your installed software.

In the “Installing software” section, we show you how to get updates and upgrades by writing the commands separately, but you can write them both in a single line as follows:

sudo apt-get update && sudo apt-get upgrade

The && is a binary operator that means AND. The AND operator is commonly used in programming to test for multiple conditions. For now, keep in mind that its use ensures that the second command executes only if the first succeeds. If your update fails for some reason (maybe because you lack an Internet connection), the system won’t even attempt to upgrade.

This process (specifically, the upgrading part) can take a very long time, which can be troublesome if you want to update a single application. Fortunately, you can do so by typing the install command again, remembering to update the list of available package versions first:

sudo apt-get update && sudo apt-get install mc

This command doesn’t install the software all over again. Instead, the package manager first checks for updates and installs them. If updates aren’t available, the package manager displays a message that the software is already up to date.

Removing software

To remove software from your BeagleBone, you resort once more to the apt package manager. Here’s an example:

sudo apt-get remove mc

This command, however, leaves behind files that are somehow related to the software, such as configuration files and logs. If you don’t intend to use those files in any way, you can remove everything by using purge:

sudo apt-get purge mc

You can also direct the system to check for unnecessary packages and/or files and remove them automatically.

The package manager downloads and installs not only the requested package, but also any other packages that it may depend on. Thus, if you delete some software, its dependencies may stay behind. The apt package manager deems the dependencies unnecessary and deletes them automatically when you issue the following command:

sudo apt-get autoremove

Don’t fret about giving so much power to the package manager. Before deletion, you see a list of the packages that will be removed, and you’re prompted to press Y to confirm that you do want those packages removed. You also see how much space will be freed.

To remove all files that are undoubtedly unnecessary, you can type the following command:

sudo apt-get clean

These files are usually installation files. They remain on your computer after the installation of a program, even though they’re no longer needed. Removing them isn’t an issue. If you decide to reinstall a package, you can simply do so as previously described in the “Installing software” section. The installation file downloads again.

We highly recommend not removing any package that you didn’t install yourself unless you’re absolutely certain that you know what it’s for. It may be a necessary package that comes with the Linux OS, and removing it may lead to a system crash.

Seeing what’s installed on your BeagleBone

To see a list of installed packages on your BeagleBone, type the following command:

dpkg --list

Note that this command doesn’t require root authorization. After all, you aren’t messing around with the software; you’re just listing it. Consequently, it’s not necessary to use sudo.

To see whether a specific package is installed, as well as a more detailed description about it, you can use the following command:

dpkg --status <nameOfThePackage>

Changing the Hostname and Password

Currently, the hostname of your BeagleBone is, rather boringly, beaglebone. You may want to change it to something more personal. Doing so is also useful when you start to use more than one BeagleBone on the same network, because the hostname is the name that’s displayed to all the other users on that network.

If you want to change the hostname, start by typing the following command:

debian@beaglebone:~$ sudo echo 'newHostName' > /etc/hostname

Your hostname is changed to the one that you prefer. The BeagleBone won’t recognize this “host,” however, so you need to edit the hosts file. To open and edit it, follow these steps:

1. Type the following in a text editor such as nano:

debian@beaglebone:~$ sudo nano /etc/hosts

2. On the line that reads 127.0.0.1 beaglebone, change beaglebone to your new hostname

3. Save the file, and quit nano.

4. Reboot your BeagleBone.

Your new hostname should appear during your next login.

Use the arrow keys to navigate nano, and press Ctrl+O to save and Ctrl+X to exit. If you attempt to exit without saving, you’re prompted to press Y if you want to save or N if you don’t.

The default debian user password is temppwd. If you want to change it, simply type the command passwd and follow the steps printed in the terminal:

debian@beaglebone:~$ passwd
Changing password for debian.
(current) UNIX password:
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
debian@beaglebone:~$

The text is hidden while you write the passwords.

Shutting Down and Rebooting

There are better ways to shut down and reboot your BeagleBone than simply unplugging it. Unceremoniously unplugging your BeagleBone is the equivalent of shutting down your computer by pressing the power button or even removing its power source, which sometimes leads to complications such as file corruption.

To shut down your BeagleBone, simply type this command on the command line:

debian@beaglebone:~$ sudo shutdown -h now

You see the following information after you use the shutdown command:

Broadcast message from root@beaglebone (pts/0) (Thu Jul 3 18:50:09 2014):
The system is going down for system halt NOW!
debian@beaglebone:~$

To reboot, type this:

debian@beaglebone:~$ sudo reboot

This is the result:

Broadcast message from root@beaglebone (pts/0) (Thu Jul 3 18:44:29 2014):
The system is going down for reboot NOW!

You need to log in again through SSH after rebooting.

Commanding the Prompt Like a Jedi Master

This section provides a few tips and tricks that maximize the efficiency with which you use the Linux OS. This material won’t help you save the galaxy or show you how to fetch the TV remote with telekinesis, but it should help you navigate the prompt much faster than before — and with a lot more style.

Recalling previous commands

You can easily recall the commands you’ve used previously by pressing the up- and down-arrow keys. Imagine that you listed the contents of a file by using ls -l; then you created a directory and a file inside this new directory. You want to see the list again to see the default permissions of this new directory. Rather than keying in ls -l again, you can simply press the up-arrow key twice.

Next, imagine that you want to list the contents of this new folder to see the file inside it, but you want to add the -h option. Simply press the up-arrow key to bring ls -l onscreen once more; you can use the left and right arrow keys to navigate through that line and then add the -h option and the name of the new directory. You can tell that this method saves some work.

Now imagine repeating the entire process for someplace other than your working directory, a place with a very long absolute path, such as this:

ls -l /home/debian/Desktop/project/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder

In fact, create this folder now for the sake of further exemplification:

debian@beaglebone:~/Desktop$ mkdir -p aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder

Autocompleting commands

After writing the first letters of a line, press Tab to command the shell to try to guess what you meant to write and to autocomplete it. Naturally, this feature is most useful when you want to access long filenames. If it fails, write a little more to give the shell a better hint. You can try it by typing the following at the Desktop and then pressing the Tab key:

debian@beaglebone:~/Desktop$ cd aF

The shell completes the line with cd aFolder/.

Note the slash at the end. When you used cd to access a directory in the previous sections, you never placed a slash at the end of its name. Placing or not placing a slash is exactly the same. Why does the autocompletion add a slash, then? That’s because it’s ready to continue guessing the names of files within that directory. If you keep pressing the Tab key, you eventually end up with the following command:

debian@beaglebone:~/Desktop$ cd aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder

Because nothing else was inside any of those folders, it was quite easy for the shell to autocomplete your command even without having hints; there was only one option, after all. Otherwise, the prompt prints a list of possible files, asking you to write a few more letters. The following example illustrates that:

debian@beaglebone:~/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder$ touch heyJohn heyMarie heyCarl

If you type file and then press Tab repeatedly, you see the following:

debian@beaglebone:~/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder$ file hey

Continue pressing Tab. The prompt suggests all the possibilities:

debian@beaglebone:~/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder$ file hey
heyCarl heyJohn heyMarie
debian@beaglebone:~/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder$ file hey

If you give the prompt a better hint, such as this,

debian@beaglebone:~/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder$ file heyJ

when you press Tab again, you see the result:

debian@beaglebone:~/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder$ file heyJohn

Using keyboard shortcuts

You have ways to navigate the command line other than pressing the left- and right-arrow keys, which sometimes seem to take forever to get you somewhere. Following are some useful keyboard shortcuts:

· Ctrl+A and Ctrl+E do the same thing as the Home and End keys — that is, they bring you to the beginning and the end of the current command, respectively.

· Ctrl+Left and Ctrl+Right jump between inputs (arguments) in a command; the cursor jumps from a space or a slash to the next.

· Ctrl+U clears the entire line.

· Ctrl+K deletes everything from the position of the cursor to the end of the line.

· Ctrl+W deletes a single word before the cursor.

· Ctrl+R allows you to search your command history. If you press Ctrl+R and then type cd, for example, your most recent command involving cd appears on the command line. Pressing Ctrl+R again shows you the cdcommand before that, and so on. Press the left- or right-arrow key when you find the one you want.

This search finds characters, not commands. If you had a command such as mkdir photos_from_cd, you could use Ctrl+R with cd to find it.

Using these Ctrl shortcuts helps you jump around quite fast. Suppose that you want to copy a file from the Desktop to the anEvenDeeperFolder directory. First, create the file by using the touch command:

debian@beaglebone:~/Desktop$ touch hello.txt

To copy the file, you would have to type the following cumbersome command:

debian@beaglebone:~/Desktop$ cp hello.txt /home/debian/Desktop/aFolder/aDeeperFolder/anEvenDeeperFolder

What a chore! Instead, you can achieve the same result by following these steps:

1. Press Ctrl+R and then type mkdir:

(reverse-i-search)‛mkdir': [m]kdir -p aFolder/aDeeperFolder/anEvenDeeperFolder/theDeepestFolder

The preceding example and those that follow are all about showing you how to have your cursor jumping around in a line by using keyboard shortcuts. In the examples, the terminal cursor is represented with closed brackets ([]). If your cursor is somewhere else and you press the keyboard shortcuts you’ll get different results.

2. Press Ctrl+right arrow until your cursor is right before the directory you want to eliminate from the path:

debian@beaglebone:~/Desktop$ mkdir -p aFolder/aDeeperFolder/anEvenDeeperFolder[/]theDeepestFolder

3. Press Ctrl+K to get rid of theDeepestFolder/:

debian@beaglebone:~/Desktop$ mkdir -p aFolder/aDeeperFolder/anEvenDeeperFolder[]

4. Press Ctrl+A to go to the beginning of the line:

debian@beaglebone:~/Desktop$ [m]kdir -p aFolder/aDeeperFolder/anEvenDeeperFolder

5. Press Ctrl+right arrow twice.

Your cursor is now after-p:

debian@beaglebone:~/Desktop$ mkdir -p[]aFolder/aDeeperFolder/anEvenDeeperFolder

6. Press Ctrl+W twice to erase mkdir -p,and then type cp hello.txt:

debian@beaglebone:~/Desktop$ []aFolder/aDeeperFolder/anEvenDeeperFolder

Alternatively, you can type something like cp he and then press Tab:

debian@beaglebone:~/Desktop$ cp he[]aFolder/aDeeperFolder/anEvenDeeperFolder[

7. Press Tab:

debian@beaglebone:~/Desktop$ cp hello.txt[]aFolder/aDeeperFolder/anEvenDeeperFolder

Keeping everything clean

Typing the command clear or pressing Ctrl+L quickly clears the screen, but it doesn’t clear the terminal window. In fact, the result is like pressing Enter or Return many times: If you scroll up, you still see the commands you used previously. If you truly want to clear everything, you can use the reset command.

The reset command reinitializes the terminal window, so that it appears to have just started (and, thus, has nothing in it). The command doesn’t reinitiate the shell, however, so it doesn’t alter the shell’s state. In layman’s terms, the shell’s state is the same, so you can still access your command history.