Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementations of echo.c

But a single malloc is nothing compared to the cost of a context switch into kernel mode.

For example, instead of cat -v, you'd have a second utility called, 'nonprint' which would just translate non-printing chars, and you'd call it using

     cat file1 file2 | nonprint

If you need more features from a basic utility like echo or cat you should create your own version, maybe with a slightly different name, and leave the original as it is.

All of these tools are intended to be composable, analogous to functions. 'cat -v' is like a function with too many arguments, one that does too much. If you need, for example, to allocate a block of zero'd memory, you don't add new flags to malloc(); you use memset() after allocation, you write a for loop, or you use calloc().

Likewise, the basic tools available on Unix can and should be thought of as functions, which take some number of arguments, and the implicit argument of an input channel. They produce as their output an integer as a return value and two output channels, stdout and stderr. Making a function that does too much (and this is as subjective for functions as it is for command-line tools) is known to be bad practice, but for the shell, it is often misunderstood. To misunderstand this is to misunderstand the core principals of the Unix environment.

It has nothing to do with the typical non-programmer user. On, say, Linux or OSX, the user doesn't write functions or talk to the shell very often. They click buttons in a GUI that doesn't in a meaningful sense offer composable programs, and it's an inefficient but simple way to interact with the machine, a way that matches their habits and understanding. cat, echo, sed, and awk aren't for these users; they're for programmers, and the typical user does not know or care whether cat can show non-printing characters, but as a programmer, I certainly care about a clean design for my environment.

   kamloops$ uname -s
   NetBSD
   kamloops$ echo $0
   sh
   kamloops$ env POSIXLY_CORRECT=1 echo -n
   kamloops$

[dave@mini ~]$ echo -n "-n foo

> "

-n foo

[dave@mini ~]$

Easy!

So rather than this:

  void test()
  {
    int *x = malloc(1000);
    int *y = malloc(1000);
    for(int i = 0; i < 999; i++) {
      if(badThing) {
        free(x);
        free(y);
        return;
      }
      doStuff()
      if(otherBadThing) {
        free(x);
        free(y);
        return;
      }
    }
    free(x);
    free(y);
    return;
  }

  void test()
  {
    int *x = malloc(1000);
    int *y = malloc(1000);
    for(int i = 0; i < 999; i++) {
      if(badThing)
        goto ret;
      doStuff()
      if(otherBadThing)
        goto ret;
    }
  ret:
    free(x);
    free(y);
    return;
  }

    void do_stuff(char *name) {
        char *my_name = strdup(name);
        if (condition_signalling_no_work()) goto done;
        if (do_something_with(my_name)) goto done;
        
        ...
        
        done:
          free(my_name);
          return;
    }