[TUHS] 'Command subcommand ...' history

[Clem Cole]

SCCS started out as single commands, and many of us learned to use that way
(I still do - for simple things I still find it easy to use - including as
the front end to all my troff).   Anyway, a couple of the SCCS macro
commands tended to be used together or in sequence and that is the key
step.   When Eric started to use SCCS for development of Ingres in the late
1970s, as Larry pointed out, Eric wrote the BSD sccs command wrapper.***

That said, I'm not sure Eric's sccs command was the first time I had seen
tool wrapper, although it may have been the first "tool" wrapper as a C
program in that sense.  I have some memories of a couple of others that
were shell scripts, but I can't remember any specifics, other than the C
compiler itself (cc was originally a shell script) and the original man
command.   I do remember looking at what Eric did when I first came across
it, as I recall I had to mess with it -- may it did not run on the 40 class
systems without some hacking - I really don't remember why.

I think the key is that shell scripts were becoming more and more things we
wrote with every day and more and more tools became scripts.   But on the
PDP-11, the shell was limited and took resources, so converting from a
shell script to C program was not unusual for speed.   The next step was
things like Eric's sccs command.

Clem


*** As an aside, it is an interesting question is how the SCCS commands and
CPIO sources originally made it to UCB.  Those tools were part of PWB 1.0
and 2.0 - which was not released to Universities - although Mashey had
published at least one paper about it and was an ACM National Lecturer at
the time.  Hence, many people knew about SCCS (I had heard him talk about
it 1979 at conference in Oregon).   Anyway, other than those tools, I do
not see much other evidence of PWB's specifics in the UCB archives.   I've
always guessed it was an unnamed "OYOC" student that left them there or it
may also have come from the Joy/Kowaski - uMich connection.  I don't think
it was Ken because Ken wrote tar so he is unlikely to have left cpio.   But
Ted was always fan of cpio (and may have had a hand in its creation).
 We'll probably never know ;-)  I certainly had become familiar with the
PWB tools a few years earlier at CMU, via the same type of path "OYOC"
 (either Phil or Ted) - which is also why so many of us knew about lots of
the work at AT&T - it was pretty well written about and published.

On Fri, Mar 24, 2017 at 11:44 AM, Larry McVoy <lm at mcvoy.com> wrote:

> On Fri, Mar 24, 2017 at 03:42:02PM +0000, Tim Bradshaw wrote:
> > Lots of tools now seem to use this strategy: there's some kind of
> wrapper which has its own set of commands (which in turn might have further
> subcommands).  So for instance
> >
> >     git remote add ...
> >
> > is a two layer thing.
> >
> > Without getting into an argument about whether that's a reasonable or
> ideologically-correct approach, I was wondering what the early examples of
> this kind of wrapper-command approach were.  I think the first time I
> noticed it was CVS, which made you say `cvs co ...` where RCS & SCCS had a
> bunch of individual commands (actually: did SCCS?).  But I think it's
> possible to argue that ifconfig was an earlier example of the same thing.
> I was thinking about dd as well, but I don't think that's the same: they're
> really options not commands I think.
>
> BSD's sccs wrapper worked this way, I believe thats where I saw it first.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20170327/b1453d15/attachment.html>