Talk:Basic Linux Command Line for Builders

I always give an example of a man page. -- MW 12:10, 27 Aug 2005 (PDT)

This page on linuxcommand.org

http://linuxcommand.org/lts0040.php ... could fill an hour of a class with just that.

Would talk about this, possibly

• location of common information, e.g., processor information in the file system
• symbolic links, in relation to GRUB, available kernels, etc.
• Read and write, from the standpoint of both a user and an operating system
• linux can teach you about how an operating system works because you can look at the steps individually.
• a big problem with cl students is they want to start learning about how an operating system works, but even small questions in that direction blow up really quickly.

The purpose of this class is to teach builders-to-be real basic stuff about using the command line in linux so when we say "ok, now go to dev" you know what to type. This is written as a script that, with ingenuity, can be either a teacher's guide or a self-guided lesson.

Proposal for New "Basic" Command Line Class"

The following is an edited version of the original CL class documentation with two goals:

• make it shorter
• improve hands on actions versus being talked at

to begin the class

This assumes you're at a terminal in the Free Geek classroom.

• log in, close the web browser.
• open a terminal session, ICEWM>Programs>XShells>Xterm (if the text is too small, hold down the control key and the right mouse button to get a font size menu)
• make the window larger, using either Alt-F10 or the maximize button.

If you're on a FreekBox3, you can open an xterminal by clicking on the button on the taskbar that looks like a monitor with a black screen. On an Ubuntu box, go to Applications>Accessories>Terminal

• Go over the parts of a command prompt. ie: user@system:location$
• Mention that the Linux command line is case sensitive. Meaning A and a are not the same letters.

Make a File

• sudo nano /home/username/Desktop/just_make_up_a_file_name
• Enter text. For example, "Hello, World!"

Parts of a Command

• Go over the parts of a command. ie: command -options target(s)
• command - The name of the program being run is the start of a line and must be separated from the options and target by a space or spaces. These are almost
• option - These modify the command. They mostly either begin with a "-" or a "--"
  • single letter options start with a single dash and can generally be strung together. The following examples are equivalent. Remember all commands are executed by pressing enter.

ls -a -l

ls -al

ls -la

• long option names start with a double dash. They cannot be combined, and may or may not have an equivalent single letter equivalent. The following are equivalent, reversing the sort order of the results of the command.

ls --reverse

ls -r

• target - This is the thing acted on, a file or directory generally.
• We will save in-depth talk about the extra information you see with the "-l" option for another class.
• Command, option, path (argument) ... can move options and paths around, but usually you will leave the path at the end in case you mistype it and need to correct it (up arrow).
• Have student type ls /home. This allows the student to see a practical use of ls (in this case its to see that names of the users on the computer).

listing, linking, removing, tab completion:

In this section, students learn that they are located in the file system, that you need to hit enter to make the command run, that the way the command runs can be modified with flags, and how to use tab completion.

• First: Point out that students can recall previously typed commands by pressing the up arrow.
• type ls and hit enter. (list files in the current directory)
• ls -l (and hit enter... the long listing, point out time/date info)
• ls -a (shows all files, note that most begin with . Point out . (the current directory) and .. (one step towards root in the filesystem))
• ls -al (shows all files the long way)
• ls (point out the Desktop directory again)
• ls D and hit tab, and hit enter. (note how it finished out the rest of the word Desktop)
• ln -s D<tab> yourname
• ls -l (note that yourname points to Desktop)

Note: periodically remind them about tab completion if they're not picking it up- it's a real arthritis-saver.

• ls D<tab>
• ls yourname (note that it's actually the same files as in Desktop)
• rm yourname
• ls (note that it removed yourname)

moving around

• cd D<tab> (becomes cd Desktop)
• ls
• cd ..
• ls
• cd /
• cd /home/username/Desktop/just_pick_a_file_name
• ls

  You are now in the root of the filesystem. Point out the directories and their uses.

• Now you let the student know that most of their personal stuff with be in /home/username/some_directory and that talking about what lives in what directory is a subject of a later class.
• cd ~
• ls

Filesystem structure

The Linux filesystem is arranged as a bush starting from the roots and moving through branches to leaves. There are not letters representing hard drives. The filesystem starts with "/" which is the root of the filesystem. Each branch has a name (and looks like a folder if using a GUI). Some branches are hidden so that people feel less inclined to monkey with them (recall ls -a). *Note* - Now is good time to explain the difference between the root user and the root of the filesystem.

• absolute path - The location of a file or directory in the filesystem starting from root. This always starts with a "/"

/home/guest/files/example.txt

• relative path - The location of a file or directory starting from you current working directory. It never starts with a "/". The following example assumes you are in /home/guest

files/example.txt

• Some stuff, especially stuff critical to the functioning of the operating system, will not let you read or write it (you don't have permission).

Copying and moving files

-cp /home/username/Desktop/ etc ... to ... /home/username/where_its_going (works just like GUI copy) -mv /home/username/Desktop/ etc ... to ... /home/username/where_its_going (works like cut and paste)

more tab-completion, text editors, modules file:

now we're going to use a text editor, which is basically like a very simple word processor- no bold, underlining or italics- just plain old text. (in this example i use nano, since that's what most build instructors end up teaching. mcedit is another text editor that would work). Tab completion works like "word-wheeling" in iTunes (most people have used iTunes).

• nano /etc/m hit tab twice. (note all the possible completions)
• nano /etc/mo<tab><tab> (note the shorter list)
• nano /etc/mod<tab><tab> (note the shorter list)
• nano /etc/modul<tab> (note how it completed it out to modules)
• nano /etc/modules
• nano /h <tab> /user <tab> /D <tab> /j <tab>
• sudo nano /home/user/Desktop/just_etc ...
• ctrl-o to save it. in the "File Name to write: " section near the bottom, it should say "/etc/modules". hit enter to save it. (note, they get a permission denied message, because they are not root)
• try again: ctrl-o, and change "/etc/modules" to "modules"
• ctrl-x to exit.
• nano modules (note that your changes were saved there)

system configuration via tab-completion:

• ls<tab><tab>
• lsp<tab> (completes lspci ... lists what is connected to the PCI bus)
• explain that tab completion works for commands also

final check-in:

do they seem to understand the concept of typical command syntax: command <option flags> arguments

"what to do, how to do it, and what to do it to"

any other questions?

Reference for further study

• http://www.linuxdevcenter.com/linux/cmd O'Reilly's Alphabetical Directory of Linux Commands
• http://www.karakas-online.de/gnu-linux-tools-summary/ GNU/Linux Command-Line Tools Summary
• http://www.linuxcommand.org/learning_the_shell.php Learning the Shell (The content/flow is pretty close to what is presented on this page)