Ousterhout's dichotomy

Ousterhout's dichotomy is computer scientist John Ousterhout's claim^[1] that high-level programming languages tend to fall into two groups, each with distinct properties and uses: "system programming languages" and "scripting languages". This distinction underlies the design of his language Tcl.

System programming languages (or "applications languages") usually have the following properties:

• They are statically typed
• They support the creation of complex data structures
• Programs in them are compiled into machine code
• Programs in them are meant to operate largely independently of other programs

System programming languages tend to be used for components and applications with large amounts of internal functionality such as operating systems, database servers, and Web browsers. These applications typically employ complex algorithms and data structures and require high performance. Prototypical examples of system programming languages include C and Modula-2.

By contrast, scripting languages (or "glue languages") tend to have the following properties:

• They are dynamically typed
• They have little or no provision for complex data structures
• Programs in them ("scripts") are interpreted

Scripting languages tend to be used for applications where most of the functionality comes from other programs (often implemented in system programming languages); the scripts are used to "glue" together other programs or add additional layers of functionality on top of existing programs. Ousterhout claims that scripts tend to be short and are often written by less sophisticated programmers, so execution efficiency is less important than simplicity and ease of interaction with other programs. Common applications for scripting include Web page generation, report generation, graphical user interfaces, and system administration. Prototypical examples of scripting languages include AppleScript, C Shell, DOS batch files, and Tcl.

Many believe that the dichotomy is highly arbitrary, and refer to it as "Ousterhout's fallacy" or "Ousterhout's false dichotomy". While strong-versus-weak typing, data structure complexity, and independent versus stand-alone might be said to be unrelated features, the usual critique of Ousterhout's dichotomy is of its distinction of compilation versus interpretation, since neither semantics nor syntax depend significantly on whether code is compiled into machine-language, interpreted, tokenized, or byte-compiled at the start of each run, or any mixture of these. Many languages fall between being interpreted or compiled (e.g. Lisp, Forth, UCSD Pascal, Perl, and Java). This makes compilation versus interpretation a dubious parameter in a taxonomy of programming languages.

References

This article was originally based on material from the Free On-line Dictionary of Computing, which is licensed under the GFDL.

1. ^ Ousterhout, John (March 1998). "Scripting: Higher Level Programming for the 21st Century". IEEE Computer magazine. http://www.tcl.tk/doc/scripting.html. Retrieved 2011-10-09. 

Further reading

• Kumar, Deepak (September 2010). "Reflections: language wars and false dichotomies". ACM Inroads 1 (3). http://portal.acm.org/citation.cfm?id=1835431. 
• Grover, Andy. "Become a better programmer by bridging Ousterhout's Dichotomy". Open Source Bridge. http://www.slideshare.net/guest2838a0/bridging-ousterhouts-dichotomy. 
• Travis, Greg (October 21, 2002). "Build a Reflection-based Interpreter in Java (Sidebar: Scripting vs. Programming)". DevX. http://www.devx.com/Java/Article/7866/1763?supportItem=4. Retrieved 2010-11-08. 

External links

• Ousterhout's dichotomy at the Tcl wiki