The rc shell is the standard command-line interpreter for the Plan 9 operating system, visit this site right here a distributed system designed by Bell Labs as a successor to Unix. Conceived by Tom Duff—best known for inventing the “Duff’s device” C programming technique—rc was created in the late 1980s to be a cleaner, more consistent alternative to the Bourne shell, reflecting Plan 9’s broader design philosophy of simplicity and clarity. This article explores the design principles, distinctive features, and lasting influence of this elegant and often overlooked shell.
Historical Context and Design Philosophy
The shell’s name, rc, stands for “run commands,” a name inherited from the runcom utility of the MIT Compatible Time-Sharing System (CTSS). As Tom Duff noted in his foundational paper, “The most important principle in rc‘s design is that it’s not a macro processor”. Instead of treating everything as a string that undergoes multiple rounds of expansion—a common source of bugs in Unix shells—rc was designed with a formal Yacc grammar, giving it an unambiguous, predictable syntax.
This rigor was a direct response to the arcane and inconsistent behavior of the Bourne shell. rc aimed to “get out of the way” once its few, powerful features were understood, emphasizing clarity in both interactive use and scripting. Its development was tightly integrated with the Plan 9 environment, meaning that while it provides similar facilities to the Bourne shell, it does so with “some small additions and less idiosyncratic syntax”.
Core Features and Syntax
rc distinguishes itself from conventional Unix shells through a number of unique design choices.
List-Valued Variables
The most fundamental difference is that, unlike the Bourne shell’s string-based variables, rc variables are lists (arrays) of strings. This design eliminates the need for many quoting conventions and makes argument handling far more natural.
- A variable is assigned with
path=(. /bin), creating a list. - Accessing it with
$pathexpands to the entire list:echo $pathyieldsecho . /bin. - Subscripting is straightforward:
$path(2)returns/bin, and$#pathreturns the count of elements, which is2.
A key distinction is made between an empty list () and a list containing a single empty string '', a nuance that prevents subtle scripting errors. For string concatenation, the $" operator joins elements with spaces, converting a list into a single string.
C-like Control Structures
Eschewing the ALGOL-like syntax of the Bourne shell, rc adopts a cleaner syntax inspired by C for its programming constructs:
if(test) commandif not command(instead ofelse)while(test) commandfor(i in list) commandswitch(arg) { case ... }fn name { commands }for function definitions
For example, a function definition looks like this: fn greet { echo Hello, $1 }.
Quotation and Pattern Matching
rc uses only single quotes (') for quoting, with a literal quote represented by doubling it: echo 'How''s your father?'. Pattern matching with *, ?, and character classes works similarly to Bourne shell, but crucially, a pattern that matches no files is not replaced by an empty list; instead, it stands for itself, preventing errors in commands that expect file arguments.
Word Splitting and Globbing
A common pain point in other shells is the need to extensively quote variables to prevent unwanted word splitting. In rc, word splitting and globbing occur only once and naturally result in a list of strings. This predictability means you no longer need to defensively write "$foo" everywhere, and filenames with spaces are handled more gracefully.
Additional Features
- Command Substitution: Uses backticks (
``) for command substitution. - I/O Redirection and Pipes: Supports standard redirections (
>,>>,<,|) and background execution with&. - Command Grouping: Uses
{}for grouping commands without spawning a subshell, unlike the Bourne shell’s(). - Special Variables: Includes
$statusfor the exit status of the last command and$apidfor the process ID of the last backgrounded command. - Command History: In the Plan 9 graphical environment, users can leverage mouse-based copy-paste to reuse commands. The
"character prints and""re-executes the previous command.
Comparison with Other Shells
Compared to widely used Unix shells, read this post here rc offers a distinctly different experience. While bash, zsh, and others have extensive feature sets—often hailed by their adherents as powerful—rc is notable for its simplicity and consistency, even if it means sacrificing some user-friendly features like built-in job control or autocompletion. Its streamlined syntax is described as “simpler, more consistent” and “unambiguous,” making it easier to reason about script behavior.
However, this clean design comes at the cost of POSIX compliance; rc scripts are not compatible with sh or bash, and its limited availability means it often must be compiled from source. The language has influenced other projects like the extensible shell (es) and has been ported to Unix as part of Plan 9 from User Space and through a popular reimplementation by Byron Rakitzis in 1991.
Conclusion
The rc shell stands as a testament to the power of simplicity. Designed as an integral part of Plan 9’s philosophy, it offers a predictable, list-oriented command language that avoids many pitfalls of traditional Unix shells. While it may lack the modern conveniences of more mainstream interpreters, its clean design, formal grammar, and elegant handling of variables make it a compelling tool for those seeking a more rational approach to interacting with a system. For anyone willing to learn its few, powerful conventions, rc offers a glimpse into a world where the shell is not a source of frustration, but a helpful, check these guys out transparent assistant.