Lambda the Ultimate

Let me mention similarities first. I knew that Unix borrowed quite a lot from Multics: hierarchical file system, virtual memory, dynamic linking, memory-mapped files and i/o. Unix is still borrowing: logical volume management with on-line reconfiguration, and access control lists are the recent additions to Unix from Multics. What I didn't know that the concept of a shell with output redirection and backquote substitution, as well as the names of popular commands such as 'ls', 'cp', 'pwd', 'mv' were borrowed from Multics as well. BTW, Multics used characters '[' and ']' rather than backticks for command result substitution -- just like Tcl does. I also didn't know that Multics has been running well into mid 80s.

Two quotations from a web page http://www.multicians.org/unix.html illustrate fundamental differences between Multics and Unix:

"I [Tom Van Vleck, a major Multics developer] was working for MIT in those days, and one thing I did was to organize an MIT PDP-11 users' group and encourage them to look into Unix. The idea of a free, non-vendor-supported operating system was new to them."

Although this sounds like writings of OpenSource proponents, the described event took place in 1973.

"We went to lunch afterward, and I remarked to Dennis [Ritchie] that easily half the code I was writing in Multics was error recovery code. He said, "We left all that stuff out. If there's an error, we have this routine called panic, and when it is called, the machine crashes, and you holler down the hall, 'Hey, reboot it.'"

It appears (e.g., from his recent projects such as Plan9 and Inferno) that Dennis Ritchie no longer thinks that way. Nevertheless, I have not heard of a modern Unix/Linux developer taking such serious approach to design as described in http://www.multicians.org/andre.html

Thank you for posting the Multics references!

If we want to invoke a UNIX system command 'cp' to copy one file into the other, we have to write something like the following

	char * from_name = "foo.txt";
	char * bar_name = "bar.txt";


	pid_t pid;
	if( pid = fork() )
	{ /* in the parent process */
	  if( pid == (pid_t)(-1) )
	    perror("fork failed"), failure();
	  for(;;) {
	      if( waitpid(pid,0,0) == (pid_t)(-1) && errno == EINTR )
		continue;
	      else
		break;
	  }
	}
	else
	  execlp("cp", "cp", from_name, bar_name, (char*)0),
	  perror("exec failed"), _exit(127);

As I understand, in Multics we could simply write something like

	DCL cp entry(char (*),char(*));
	CALL cp(from_name,to_name);

I was especially impressed with dynamic linking capabilities of Multics. You can write a procedure 'foo' that calls another procedure (say, 'bar'), compile 'foo' and invoke right away. No need to do any linking. If 'foo' eventually tries to invoke 'bar', the system will search for it. If found, the code of 'bar' will be mapped into the 'foo' process, and the execution continued as if 'bar' were a local procedure. If 'bar' cannot be located, foo is suspended and the user is notified. The user may choose to write procedure 'bar', compile it, and continue the execution of foo. Multics also offers static linking (called bundling).