Shell – A program that runs in a shell (e.g. pine) vs. a shell script

shellshell-scriptterminal

Having a bit of trouble finding the answer to my question, perhaps because I may be asking the wrong question.

I understand bash scripts. I write them all the time to do little helpful things repeatedly.

However I would like to know the difference between a shell script, and a program that runs in a shell. For example, what is pine? What language is it written in? It runs in a shell, but as far as I know it's not a shell script, it's a self-contained program that you can navigate around in, and when you exit, you return to the shell exactly where you were when you launched it.

If I wanted to write a program that functions similar to pine, in that it runs in the shell as a program with various functionality, where would I begin? Where can I find some examples of programs written in this way?

Best Answer

I think you're confusing a shell (a command line interpreter) with a terminal emulator.

A shell, when run interactively and pine require a terminal or terminal emulator to interact with the user. pine has nothing to do with the shell though.

A terminal in the older days was a device with a monitor and keyboard connected to a computer over a serial line to interact with the computer (which itself had no monitor or keyboard). The interface is simple and text based.

The serial line on the computer is a character device file (something like /dev/ttyS0 on Linux for instance). Applications that interact with the terminal write data to that device for display on the terminal.

For instance, in the simplest case, pine writing ASCII a to /dev/ttyS0 would cause the sequence of bits corresponding to that a character to be sent over the serial line, and the terminal displays a a on the screen at the current cursor position.

And when the user presses a on the keyboard, in the simplest case, the terminal sends that same sequence of bits on the other wire that goes to the computer and the system puts the a character on a buffer, and when pine does a read() on /dev/ttyS0, it returns that a character.

Terminals have evolved from a things like tele-typewriters (no screen, the a was printed on paper) to ones with CRT monitors, then some with more an more capabilities like cursor positioning, region clearing/scrolling, colour support all of which pine uses, or even graphical capabilities. X later provided with a much more advanced way to interact with a computer this time over a network instead of serial line and windowing capabilities and this time using a much more complex protocol than just a sequence of characters to be sent and a few escape sequences.

Still, decades of applications had been written for the terminal. There are a lot of things that can be done with the terminal that can't be done with X. Because the data is just two streams of characters going in both directions, it's easy for instance to export a terminal session over the network (think telnet, ssh), and an application like cat can be used to write to a terminal to display the content of a file for the user to view on his screen and can be used the exact same way, unmodified for that same content to be stored in a file or sent over the network to some server... (all is needed is redirect where that output goes). The same kind of thing can't be done with X applications that generally have one usage and can't cooperate with each other easily.

For those reasons and more, terminals have always been in use even long after X was wild-spread.

Only, now, instead of having real terminals, we have terminal emulators like xterm, gnome-terminal, eterm... Those emulate a terminal but are just themselves X applications (that run on the computer and are displayed on a X server, on the same computer or another).

By default, when you start such a terminal emulator application, a shell is started in them, which is why there's sometimes confusion between the two. You don't have to run a shell in a terminal emulator, pine doesn't have to be started by a shell, but it does require a terminal. It is a semi-graphic terminal application. It interacts with a terminal device, and at the other end of that device, it expects a terminal or terminal emulator with a minimal set of capabilities like cursor positioning, standout character highlighting...

Related Solutions

Bash – How to run a program that has its own command line within a shell script program

If fbat insists on getting its input from the terminal and you want to automate, the solution is to use expect (or pexpect). Here is an example of an expect script which might automate your program:

#!/usr/bin/expect -f
spawn ./fbat
expect ">>"
send "load map leprmap.txt\r"
expect ">>"
send "load phe phe_dbpsim2e1.txt\r"
expect ">>"
send "trait resid\r"

Because I don't have access to fbat, the above is, of course, not tested.

To install expect on a debian-like sytem, run:

apt-get install expect

Shell – Running a program with several parameters using shell script

You can use a for loop:

for iteration in 10 100 1000 10000 100000; do
    python -W ignore Experiment.py --iteration "${iteration}"
done

If you have multiple parameters, and you want all the various permutations of all parameters, as @Fox noted in a comment below, you can use nested loops. Suppose, for example, you had a --name parameter whose values could be n1, n2, and n3, then you could do:

for iteration in 10 100 1000 10000 100000; do
    for name in n1 n2 n3; do
         python -W -ignore Experiment.py --iteration "${iteration}" --name "${name}"
    done
done

You could put that in a file, for example runExperiment.sh and include this as the first line: #!/bin/bash. You could then run the script using either:

bash runExperimen.sh

Or, you could make the script executable, then run it:

chmod +x runExperiment.sh
./runExperiment.sh

If you're interested in some results before others, that'll guide how you structure the loops. In my example above, the script will run:

... --iteration 10 --name n1
... --iteration 10 --name n2
... --iteration 10 --name n3
... --iteration 100 --name n1

So it runs all experiments for iteration 10 before moving on to the next iteration. If instead you wanted all experiments for name n1 before moving on to the next, you could make the name loop the "outer" loop.

for name in ...; do
    for iteration in ...; do

Best Answer

Related Solutions

Bash – How to run a program that has its own command line within a shell script program

Shell – Running a program with several parameters using shell script

Related Question