"Linux Gazette...making Linux just a little more fun!"

Marcel Gagné's article (Linux Journal #65, September 1999) on French cooking inspired me to share some recipes of my own. The cooking metaphor is not new to computing, as Donald Knuth, in his forward to "Fundamental Algorithms" confesses he almost used "Recipes for the Computer" as its title. Without stirring the metaphor too vigorously, Gagné's article gives me the opportunity to share two items of interest and give them the needed cooking flavor.

For some time, I've been concerned about what I regard are overuse or misuse of two programming constructs:

• temporary variables and files, and
• nested logic and decisions.

Before I'd read Marcel's article, my style of programming used the tool metaphor. While not much of a chef, I now prefer the cooking metaphor, as it connotes more of a learning, and sharing model, which is what we do in programming.

Marcel's recipe is an excellent starting point for my school of cooking, as his recipe is complete, all by itself, and offers the opportunity to visit each of the points once. First, here is a copy of his recipe, without the comment header.

for user_name in 'cat /usr/local/etc/mail_notify'
do
	no_messages='frm $user_name |
		grep -v "Mail System Internal Data" |
		wc -l'
	if [ "$no_messages" -gt "0" ]
	then
		echo "You have $no_messages e-mail message(s) waiting." > /tmp/$user_name.msg
		echo " " >> /tmp/$user_name.msg
		echo "Please start your e-mail client to collect mail." >> /tmp/$user_name.msg
		/usr/bin/smbclient -M $user_name < /tmp/$user_name.msg
	fi
done

A by-product of my cooking school is lots of short functions. There are those who are skeptical about adopting this approach. Let's suspend belief for just a moment as we go through the method. I'll introduce my seasonings one at a time, and then put Marcel Gagné's recipe back together at the end. Then you may judge the sauce.

One of the languages in my schooling was Pascal, which if you recall puts the main procedure last. So, I've learned to read scripts backwards, as that's usually where the action is anyway. In Marcel Gagné's script, we come to the point in the last line, where he sends the message to each client. (I don't know Samba, but I assume this will make a suitable function):

 
	function to_samba { /usr/bin/smbclient -M $1; }

And, what are we going to send the user, but a message indicating they have new mail. That function looks like this:

 
	function you_have_mail {
		echo "You have $1 e-mail message(s) waiting."
		echo " " 
		echo "Please start your e-mail client to collect mail."
	}

At this point, you've noticed a couple of things. The file names and the redirection of output and input are missing. We'll use them if we need them. But let me give you a little hint: we won't. Unix(Linux) was designed with the principle that recipes are best made from simple ingredients. Temporary files are OK, but Linux has other means to reduce your reliance on them. Introducing temporary files does a few things:

• leaves you with extra cleaning to do after the meal is served,
• forces you to make sure someone else isn't using the bowl when you need it for your recipe.

A key piece of the recipe is deciding whether or not our user needs to be alerted to incoming mail. Let's take care of that now:

 
	function num_msg { frm $1 | but_not "Mail System Internal Data" | linecount; }

What does the final recipe look like. All of Marcel Gagné's recipe is wrapped up in this one line of shell program:

 
	foreach user_notify  'cat /usr/etc/local/mail_notify'

So what does "user_notify" look like? I toiled with this one. Let me share the trials. First I did this:

 
	function user_notify { do_notify $(num_msg $1) $1; }

This version of user_notify would expect a "do_notify" to look like this:

 
	function do_notify { if [ "$1" -gt "0" ]; then notify_user $2 $1; fi; }

 
	function foo { { if [ "$X" -gt "0" ]; then eval $*; fi }

So, let's give "foo" a name. What does it do? If one of its arguments is non-zero, then it performs a function (it's first argument) on all the other arguments. Let's solve for X. It could be any of the positional parameters, but to be completely general, it probably should be the next one, as it's the only other one this function ever has to know about. So, let's call this thing:

 
	if_non_zero {function} {number} ....

 
	function if_non_zero { [ $2 -gt 0 ] && eval $*; }

 
	function user_notify { if_non_zero do_notify $(num_msg $1) $1; }

 
	function do_notify { you_have_mail $1 | to_samba $2; }

In that spirit, I'll let you readers write your own "but_not" and "linecount". Let me show you the "foreach" you can use:

 
      function foreach { cmd=$1; shift; for arg in $*; do eval $cmd $arg; done; }

 
      function foreach { for a $(shifted $*); do eval $1 $a; done; }

 
      function shifted { shift; echo $*; }

We need one final "Chapters of the Cookbook" instruction before putting this recipe back together. Let's imagine by now, that we are practicing student chefs and we have a little repertoire of our own. So what's an easy way to re-use those cooking tricks of the past. In the programming sense, we put them in a function library and invoke the library in our scripts. In this case, let's assume we have "foreach", "but_not", and "linecount" in the cookbook. Put that file "cookbook" either in the current directory, but more usefully, somewhere along your PATH variable. Using Marcel Gagné's example, we might expect to put it in, say, /usr/local/recipe/cookbook, so you might do this in your environment:

 
   PATH=$PATH:/usr/local/recipe

 
    . cookbook		#  "dot - cookbook"

 
# -- Mail Notification, Marty McGowan, [email protected], 9/9/99
#
  . cookbook
# -------------------------------------------- General Purpose --
function if_non_zero	{ [ $2 -gt 0 ] && eval $*; }
function to_samba	{ /usr/bin/smbclient -M $1; }
# --------------------------------------- Application Specific --
function num_msg	{ frm $1 | but_not "Mail System Internal Data" | linecount; }
function you_have_mail	{
	echo "You have $1 e-mail message(s) waiting."
	echo " " 
	echo "Please start your e-mail client to collect mail."
}
function do_notify	{ you_have_mail $1 | to_samba $2; }
function user_notify	{ if_non_zero do_notify $(num_msg $1) $1; }
#
# ------------------------------------------ Mail Notification --
#
  foreach user_notify  'cat /usr/etc/local/mail_notify'

 
# --------------- Samba Recipes, uses the Cookbook, Adds SAMBA --
. cookbook
# -------------------------------------------- General Purpose --
function to_samba	{ /usr/bin/smbclient -M $1; }

Let me say just two things about style: my functions either fit on one line or not. If they do, each phrase needs to be separated by a semi-colon (;), if not, a newline is sufficient. My multi-line function closes with a curly brace on it's own line. Also, my comments are "right-justified", with two trailing dashes. Find your style, and stick to it.

In conclusion, note how we've eliminated temporary files and variables. Nor are there nested decisions or program flow. How was this achieved? Each of these are now "atomic" actions. The one decision in this recipe, "does Marcel have any mail now?" has been encapsulated in the "if_non_zero" function, which is supplied the result of the "num_msg" query. Also, the looping construct has been folded into the "foreach" function. This one function has simplified my recipes greatly. (I've also found it necessary to write a "foreach" function which passes a single argument to each function executed.)

The temporary files disappeared into the pipe, which was Unix's (Linux's) single greatest invention. The idea that one program might read its input from the output from another was not widely understood when Unix was invented. And the temporary names disappeared into the shell variable arguments. The shell function, which is very well defined in the Korn shell, adds greatly to this simplification.

To debug in this style, I've found it practical to add two things to a function to tell me what's going on in the oven. For example:

 
   function do_notify	{ comment do_notify $*
	    you_have_mail $1 | tee do_notify.$$ |  to_samba $2
	    }

 
      function comment { echo $* 1>&2; } 

Copyright © 1999, Marty McGowan
Published in Issue 47 of Linux Gazette, November 1999