Librarians like handouts. To make a handout for this lesson, adapt/print from http://data-lessons.github.io/library-shell/reference/.
The grep flags
-E flag is not supported by Git Bash for Windows. Note the sections of Episode 2 that describe this (for example the callout ‘Invalid option – o?’). Be prepared to manage this difference between OS behaviour.
Many people have questioned whether we should still teach the shell. After all, anyone who wants to rename several thousand data files can easily do so interactively in the Python interpreter, and anyone who’s doing serious data analysis is probably going to do most of their work inside the IPython Notebook or R Studio. So why teach the shell?
The first answer is,
“Because so much else depends on it.”
configuring your default editor,
and controlling remote machines frequently assume a basic familiarity with the shell,
and with related ideas like standard input and output.
Many tools also use its terminology
(for example, the
%cd magic commands in IPython).
The second answer is,
“Because it’s an easy way to introduce some fundamental ideas about how to use computers.”
As we teach people how to use the Unix shell,
we teach them that they should get the computer to repeat things
(via tab completion,
! followed by a command number,
rather than repeating things themselves.
We also teach them to take things they’ve discovered they do frequently
and save them for later re-use
(via shell scripts),
to give things sensible names,
and to write a little bit of documentation
(like comment at the top of shell scripts)
to make their future selves’ lives better.
The third answer is, “Because it enables use of many domain-specific tools and compute resources researchers cannot access otherwise.” Familiarity with the shell is very useful for remote accessing machines, using high-performance computing infrastructure, and running new specialist tools in many disciplines. We do not teach HPC or domain-specific skills here but lay the groundwork for further development of these skills. In particular, understanding the syntax of commands, flags, and help systems is useful for domain specific tools and understanding the file system (and how to navigate it) is useful for remote access.
Finally, and perhaps most importantly, teaching people the shell lets us teach them to think about programming in terms of function composition. In the case of the shell, this takes the form of pipelines rather than nested function calls, but the core idea of “small pieces, loosely joined” is the same.
All of this material can be covered in three hours as long as learners using Windows do not run into roadblocks such as:
data directory for in-workshop exercises and live coding examples.
You can clone the shell-novice directory or use the
button on the right to get the entire repository. We also now provide
a zip file of the
data directory that can be downloaded on its own
from the repository by right-click + save or see the “setup” page on the lesson website for more details.
Content: Unless you have a truly generous amount of time (4+ hours), it is likely that you will not cover ALL the material in this lesson in a single half-day session. Plan ahead on what you might skip, what you really want to emphasize, etc.
Exercises: Think in advance about how you might want to handle exercises during the lesson. How are you assigning them (website, slide, handout)? Do you want everyone to try it and then you show the solution? Have a learner show the solution? Have groups each do a different exercise and present their solutions?
reference.md can be printed out and given to students as a reference, your choice.
Super cool online resource!
http://explainshell.com/ will dissect any shell command you type in
and display help text for each piece. Additional nice manual tool could be http://tldr-pages.github.io/ with short very descriptive manuals for shell commands, useful especially on Windows while using Git BASH where
man could not work.
Another super cool online resource is http://www.shellcheck.net, which will check shell scripts (both uploaded and typed in) for common errors.
Resources for “splitting” your shell so that recent commands remain in view: https://github.com/rgaiacs/swc-shell-split-window.
Running a text editor from the command line can be the biggest stumbling block during the entire lesson: many will try to run the same editor as the instructor (which may leave them trapped in the awful nether hell that is Vim), or will not know how to navigate to the right directory to save their file, or will run a word processor rather than a plain text editor. The quickest way past these problems is to have more knowledgeable learners help those who need it.
Introducing and navigating the filesystem in the shell (covered in Navigating Files and Directories section) can be confusing. You may have both terminal and GUI file explorer open side by side so learners can see the content and file structure while they’re using terminal to navigate the system.
Tab completion sounds like a small thing: it isn’t.
Re-running old commands using
isn’t a small thing either,
and neither are wildcard expansion and
Each one is an opportunity to repeat one of the big ideas of Software Carpentry:
if the computer can repeat it,
some programmer somewhere will almost certainly have built
some way for the computer to repeat it.
Building up a pipeline with four or five stages,
then putting it in a shell script for re-use
and calling that script inside a
is a great opportunity to show how
“seven plus or minus two”
connects to programming.
Once we have figured out how to do something moderately complicated,
we make it re-usable and give it a name
so that it only takes up one slot in working memory
rather than several.
It is also a good opportunity to talk about exploratory programming:
rather than designing a program up front,
we can do a few useful things
and then retroactively decide which are worth encapsulating
for future re-use.
If everything is going well, you can drive home the point that file extensions are essentially there to help computers (and human readers) understand file content and are not a requirement of files (covered briefly in Navigating Files and Directories). This can be done in the Pipes and Filters section by showing that you can redirect standard output to a file without the .txt extension (e.g., lengths), and that the resulting file is still a perfectly usable text file. Make the point that if double-clicked in the GUI, the computer will probably ask you what you want to do.
We have to leave out many important things because of time constraints, including file permissions, job control, and SSH. If learners already understand the basic material, this can be covered instead using the online lessons as guidelines. These limitations also have follow-on consequences:
It’s hard to discuss
#! (shebang) without first discussing
permissions, which we don’t do.
#! is also pretty
complicated, so even if we did discuss permissions, we
probably still wouldn’t want to discuss
Installing Bash and a reasonable set of Unix commands on Windows always involves some fiddling and frustration. Please see the latest set of installation guidelines for advice, and try it out yourself before teaching a class.
On Windows machines
nano hasn’t been properly installed with the
Software Carpentry Windows Installer
it is possible to use
notepad as an alternative. There will be a GUI
interface and line endings are treated differently, but otherwise, for
the purposes of this lesson,
nano can be used almost interchangeably.
On Windows, it appears that:
$ cd $ cd Desktop
will always put someone on their desktop. Have them create the example directory for the shell exercises there so that they can find it easily and watch it evolve.
Stay within POSIX-compliant commands, as all the teaching materials do.
Your particular shell may have extensions beyond POSIX that are not available
on other machines, especially the default OSX bash and Windows bash emulators.
For example, POSIX
ls does not have an
-I option, and POSIX
-n 10 or
-10, but not the long form of
Installing Bash and a reasonable set of Unix commands on Windows always involves some fiddling and frustration. Please see the latest set of installation guidelines for advice, and try it out yourself before teaching a class. Options we have explored include:
Cygwin was the preferred option until mid-2013, but once we started teaching Git, msysGit proved to work better. Desktop virtual machines and cloud-based VMs work well for technically sophisticated learners, and can reduce installation and configuration at the start of the workshop, but:
Whatever you use, please test it yourself on a Windows machine before your workshop: things may always have changed behind your back since your last workshop. And please also make use of our Software Carpentry Windows Installer.