skip to primary navigationskip to content

Day Two

This exercise is set at the end of the second day of the Simple Shell Scripting for Scientists course. Solutions to this exercise will be examined on the third day of this course, so you must attempt this exercise before then or you may find it very difficult to follow the rest of this course.

The course notes for this day of the course are available (as a PDF) here.

These exercises were designed to be done on MCS Linux. However, it should work on most modern Linux distributions that have Python 2.7 (or any later version of Python 2), gnuplot 4.0 or higher (with PNG support), and Eye of GNOME 2.9.0 or higher (or another appropriate PNG viewer).

If you don't do this exercise on on MCS Linux then you should have a look at the compatibility notes before starting the exercise.

Obtaining the files for these exercises

On MCS Linux

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

cd "${UX}"/Lessons/Shell-Scripting-Scientists

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.

On another machine

You will need to download the course files archive to your computer.  You'll also need to unpack the archive and set things up with this script. Download the archive and script to the same directory. cd to the directory into which you downloaded those two files. Make sure the script is executable by typing:

chmod +x

and then run it by typing:


The 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.

The exercise

On day two of this course we 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 zombie program and the answers and scripts subdirectories. First of all, make sure that the multi-run-while 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 answers subdirectory like this:

cp -pf answers/multi-run-while scripts/multi-run-while

(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 so that as well as running zombie it also runs gnuplot (using the zombie.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 that will run zombie three times for each parameter set the script reads in on standard input, changing the fifth parameter each time as follows:

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

    a b c d 50

    …then with the parameter set:

    a b c d 500

    …and then with the parameter set:

    a b c d 5000

    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 zombie 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 50, 500, 5000 previously used.

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

    So, if the script from the previous part of the exercise was called multi-50-500-5000, and we called this new script multi-sizes (and stored both in the scripts subdirectory), then - assuming we are in the directory containing the zombie program and the scripts subdirectory - running our new script like this:

    cat scripts/param_set | scripts/multi-sizes 50 500 5000

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

    cat scripts/param_set | scripts/multi-50-500-5000

    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.)

We're going to be looking at the solutions to the above exercise on the next day of this course, so it is essential that you attempt the exercise before then.

Compatibility notes

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

  • The version of the zombie program provided in this archive is written in Python 2. It has only been tested with Python 2.7, although it will probably work with any version of Python 2 from Python 2.5 onwards (no promises, though).

  • You may have problems if you are using a shell other than bash. You may also have problems if you are using a version of bash earlier than version 2.04. Note that the scripts used in this course were all written to run under bash 4.1, but it is believed that they will run under bash 2.04 or higher (no promises, though). At least one of the scripts used in this course (hello-function) won't run properly under versions of bash earlier than 2.04 (this script isn't needed for these exercises, though).

  • You will have problems if you are using a version of mktemp earlier than version 1.3, as versions of mktemp prior to version 1.3 did not support the  ‑t option. In particular, versions of mktemp derived from BSD (such as that provided with MacOS X) do not support this option. If you want to use the scripts from this course with such versions of mktemp you will need to modify the scripts to explicitly create files and directories in /tmp instead of using the  ‑t option.

  • The gnuplot commands used have only been tested with gnuplot 4.4. They will probably work with gnuplot 4.0 or higher, but this has not been tested.

  • The version of gnuplot you use must have PNG support. This usually depends on how your version of gnuplot has been compiled. To find out if it has PNG support, start gnuplot and type the following:

    show version long

    If under Compile options either +PNG or +GD_PNG is listed, then your version of gnuplot has been compiled with PNG support.

  • If you do not have Eye of GNOME (eog) on your system, almost any other PNG viewer will do. Most modern web browsers can view PNG files. A list of some applications that support the PNG format is given here.


UIS Service Status

Phone padded  Service status line: (01223) 463085
Website  Sign up for SMS/email status alerts
Website  Read major IT incident reports

UIS bITe-size bulletin

A regular newsletter aimed at the University's IT community, highlighting service and project news from UIS.

Sign up >  |  Back issues

RSS Feed Latest news

Panopto maintenance at midnight tonight (00:00 on Thursday 8 October)

Oct 07, 2020

The Panopto Lecture Capture Cloud service will be undergoing maintenance on Thursday 8 October 2020 from 00:00 (midnight tonight) and will be unavailable for up to 3 hours.

GBN network joins up to plant protection

Sep 30, 2020

The University's data network, the Granta Backbone Network (GBN), has joined up to the plant protection provider LinesearchBeforeUDig. This will add an extra level of protection to our essential core infrastructure at this critical time for the University.

View all news