Shell Scripting (II): Exercises

These are exercises for you to try once you have gone on the Shell Scripting (II) course. Solutions to this exercise will be examined in the Shell Scripting (III) course, so if you plan on attending that course then you must attempt this exercise before attending or you may find it very difficult to follow that course.

These exercises were designed to be done on PWF Linux. It is recommended that you try them on a PWF Linux system, as that is the environment in which they have been tested. However, they should work on most modern Linux distributions that have gnuplot 4.0 or higher (with PNG support), and Eye of GNOME 2.9.0 or higher (or another appropriate PNG viewer), installed.

If you don't do these exercises under PWF Linux you may need to recompile the iterator program (see the README file in the archive of files from the course for details). You should also have a look at the compatibility notes.

Obtaining the files for these exercises

In order to do these exercises, you'll need to get hold of the files used in class. If you are doing these on PWF Linux, then after you have logged in, type the following:

You'll be asked for a directory into which the files should be placed, the files will be unpacked to that directory and then set up for you. Look at the README file in the directory to which the files have been unpacked for instructions on how to run the script constructed in class.

If you are not doing these exercises on PWF Linux, then you'll need to get copies of the files that were used in class onto your own system and set up properly. These files are available in an archive here. You'll also need to unpack the archive and set things up with this setup.sh script. Download the archive and setup.sh script to the same directory. cd to the directory into which you downloaded those two files. Make sure the setup.sh script is executable by typing:

and then run it by typing:

The setup.sh script will ask you for a directory into which it should unpack the archive and will then set everything up for you.

Once the archive is successfully unpacked, see the README file for details of what it contains. This file also gives brief instructions on how to recompile the iterator source code, in case the precompiled version of iterator included in the archive won't run on your system.

Shell Scripting (II): Final exercises

In this course we've created several scripts that run a program with a given parameter set or run a program several times, once for each of a collection of parameter sets. We've looked at different ways of specifying those parameter sets (on the command line and via standard input). We're now going to look at ways of changine our scripts to make our exploration of the program's parameter space even more versatile.

Change to the directory containing the iterator program and the answers and scripts subdirectories. First of all, make sure that the multi-run-while.sh shell script in the scripts subdirectory has been modified as we did during the course. You can do this by overwriting the copy in the scripts subdirectory with the copy provided in the subdirectory like this:

(You only need to to do this once.)

There are three parts to this exercise, which you should attempt in the order given:

  1. Improve the run_program function in multi-run-while.sh so that as well as running iterator it also runs gnuplot (using the iterator.gplt file) to plot a graph of the output. See the course notes for one approach to this task.

  2. Now create a new shell script based on multi-run-while.sh that will run iterator three times for each parameter set the script reads in on standard input, changing the third parameter each time as follows:

    For a given parameter set a b c d, first your script should run iterator with the parameter set:

    …then with the parameter set:

    …and then with the parameter set:

    See the course notes for a more detailed description of this task.

  3. Now create a new shell script, based on the script you created in the previous part of the exercise, that does the following:

    Instead of running iterator three times for each parameter set it reads in, this script should accept a set of values on the command line, and use those instead of the hard-coded 10, 100, 1000 previously used.

    Thus, for each parameter set it reads in on standard input, it should run iterator substituting, in turn, the values from the command line for the third parameter in the parameter set it has read in.

    So, if the script from the previous part of the exercise was called multi-10-100-1000.sh, and we called this new script multi-iterations.sh (and stored both in the scripts subdirectory), then - assuming we are in the directory containing the iterator program and the scripts subdirectory - running our new script like this:

    should produce exactly the same output as running the script you wrote in the previous part of this exercise with the same input file:

    See the course notes for a hint on how to do this part of the exercise.

(If you can't see the point of the shell scripts you've been asked to write for the last two parts of this exercise, see the course notes for a possible scenario in which they would be useful.)

For those of you coming to the Shell Scripting (III) course, we'll be looking at your answers to these exercises there, so you need to have attempted them before then.

Compatibility notes

If you are not doing these exercises under PWF Linux then you should be aware of the following issues which may arise when using other Linux/Unix systems: