Mob Software: The Erotic Life of Code [html] [pdf]
This essay was first presented by Richard P. Gabriel at the ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications on October 19, 2000, in Minneapolis, Minnesota, USA. Musical interspersions are from the collection of Ron Goldman.
Worse Is Better [html]
One of the better known pieces I wrote is affectionately called "Worse is Better." Rather than a single download for this work, there is an entire page dedicated to the worse-is-better saga.
The Why of Y [pdf]
In the 1980's I wrote a column for AI Expert, and one of the more popular columns was a sort-of hacker's view of where the applicative order fixed-point function came from.
Repetition, Generativity, and Patterns [html]
This is the introduction to "Pattern Languages of Program Design, 2," Vlissides, John M., Coplien, James O., and Kerth, Norman L. (eds), Addison-Wesley, 1996.
Christopher Alexander: The Search for Beauty [pdf]
The Nature of Order: The Post-Patterns World [pdf]
The Nature of Order [pdf - 45mb]
These are three presentations I have given over the years. The first is a fairly comprehensive look at all of Christopher Alexander’s work aside from "Notes on the Synthesis of Form" (which I regard as juvenalia) covering both pattern languages and his most recent work called, "The Nature of Order." The second talk is the parts of the first talk that deal only with "The Nature of Order." The third is a comprehensive look at "The Nature of Order," but it's a very large file.
I have done some work to adapt the ideas in "The Nature of Order" to poetry, and some stuff I wrote about that can be found on this page.
RPG’s Writing Broadside [html]
In my book of essays. "Patterns of Software," and in some other publications, I have published a list of nine pieces of advice for scientific and technical writers. Usually they are printed in a larger essay, but I’ve seen it posted on doors at some schools.
Tone, Tone, Tone [html]
In 1999, Spencer Reiss, one of the senior editors for Wired magazine, asked me to write a short essay having to do with the then-coming millennium. I wrote this essay for him - and he liked it - but he moved onto another job before he could publish it. See what you think of it.
The Design of Parallel Programming Languages [html]
This is a version of a paper I wrote called "Ten Ideas for Programming Language Design." This revised version appeared in a book commemorating the career of John McCarthy.
The Evolution of Lisp
HOPL Version [pdf]
Uncut Version [pdf]
In 1992, Guy Steele Jr. and I were invited to write a paper on the history of Lisp for the ACM Conference on the History of Programming Languages II. This is a copy of the paper we submitted, which was published in a book called "History of Programming Languages II," edited by Thomas J. Bergin, Jr., Richard G. Gibson, Jr., and Peter S. Gordon.
The conference was run under the stern but expert control of Jean Sammet, who wished nothing to go wrong to the extent that all questions to be asked at the conference needed to be submitted and approved beforehand. Steele and I did our darnedest to work within the rules, which included working with a historian to make sure we didn't violate accepted methodology. But we fell down when it came to the presentation. We were supposed to submit that for approval long before the conference, but we were too busy to even write the presentation until the night before. The next day we told Jean Sammet that we didn't think she would have approved our presentation, which was a tag team between Steele and myself where he told the technical story of what features were added when, and I told the human story which included political intrigue. We used a particularly unusual set of slides derived from a single diagram we drew which showed time, geography, influences, implementation s, and people. Jean Sammet told us that it was the best presentation she had seen in years, and she was glad we didn't submit our slides, since she would have rejected them.
Steele and I set out to write a much more ambitious paper, in which we tried to understand how languages evolved through a combination of technical, social, commercial, and psychological forces. We felt that a programming language in a dynamic world would be subject to a variety of forces, and not simply the design skills of a single person or group with a vision of its applications. We wrote a draft of that paper, but conference historian Michael S. Mahoney felt we were not on solid enough scholarly footing with the time we had left to validate what, to him, were speculations. We commented out the portions he found unacceptable and pushed forward with the paper, and the HOPL version above is the result. However, 32 pages of material were cut. I've cranked up Tex and turned off the conditionals that removed that material, and the result is the Uncut version. Because we stopped writing this version in the middle and then polished only the remaining parts of it, the result is likely quite rough, and I know many references are left out. We had intended to produce a book based on the version here, but we never did. I hope you enjoy it even in this work-in-progress form.
In October 2008, Steele and I reprised the talk with gave at HOPL II, and for the proceedings, we took the material on language evolution and put it into a separate paper, "A Pattern of Language Evolution." This is the pdf of that paper.
The Jini Community Pattern Language [pdf]
In 1998, Ron Goldman and I were given the task of creating the Jini Community. We wanted to create a community that would self-organize in the manner of a chaord. We decided to write a pattern language which would enable members of the community to create Jini services, either by themselves or in conjunction with others. This is that pattern language.
Lessons From The Science of Nothing At All [html]
This is a keynote address I gave on October 10, 2001 at the Product Development and Management Association Conference in Santa Clara, California.
Fake Systems Qual circa 1982 [html]
This speaks for itself.
Fluid Domains [html]
Deliberate Writing [html]
These two old papers are about my thesis system which achieved simple planning and writing tasks using a sort of self-organization.
A Critique of Common Lisp [pdf]
At the 1984 Symposium on Lisp and Functional Programming, Rod Brooks and Gabriel broke rank and delivered the stunning opening paper, "A Critique of Common Lisp." This was all the more stunning because Gabriel and Brooks were founders of a company whose business plan was to become the premier Common Lisp company. Fahlman, on hearing the speech delivered by Gabriel, called it traitorous.
This paper was only the first in a string of critiques of Common Lisp, and many of those critiques quoted this paper. The high points of the paper reveal a series of problems that proved to plague Common Lisp throughout the decade.
Technical Issues of Separation in Function Cells and Value Cells
This paper, written with Kent Pitman, talks about the issues surrounding a Lisp-1 versus a Lisp-2. In a Lisp-1, variables and functions share the same namespace, and in a Lisp-2, they don't.
Parallel Lisp research from the 1980s and early 1990s, wih John McCarthy and others.
Energize/Cadillac & Lucid's Demise
Lucid's C/C++ Programming Environment and an editorial about Lucid's demise with my response.
Used Software [pdf]
An early (circa 1986) Junkyard Wars view of reuse - a little before "reuse" became a household word.
What Computers Can’t Do (and Why)
Wild Version [pdf]
Mild Version [pdf]
An early (circa 1986) essay on the limitations of computers.This was written as an editorial for the journal Lisp and Symbolic Computation (LASC) with Guy L. Steele Jr. for Volume 1, Numbers 3-4.
Whither Software [1.2 mb pdf]
The Road Not Taken [4.9 mb pdf]
These are the slides for a talk I gave on March 11, 2002, at the Santa Fe Institute Business Network Topical Meeting: Whither Technology? An extended version ("The Road Not Taken") was presented as a Keynote at JAOO 2002.
Turing, Searle, and Thought
Nickieben Bourbaki's response to John R. Searle's 1990 essay, "Is the Brain's Mind a Computer Program?"
Triggers & Practice: How Extremes in Writing Relate to Creativity and Learning [pdf]
I presented this keynote at XP/Agile Universe 2002 in Chicago, Illinois. The thrust of the talk is that it is possible to teach creative activities through an MFA process and to get better by practicing, but computer science and software engineering education on one hand and software practices on the other do not begin to match up to the discipline the arts demonstrate. Get to work.
Fine Points of Pattern Writing [1.3 mb pdf]
These are some thoughts I had about pattern writing, which I presented as a special session at PLoP 2002.
Workshop Leader Seminar [pdf]
We need to act more like teachers when we lead technical writers' workshops. These slides contain tips for workshop leaders.
Resolved: Objects Have Failed
I participated in a debate on the question "Objects Have Failed" at OOPSLA 2002 in Seattle, Washington. My teammate was Brian Foote, and our opponents were Guy L. Steele Jr. and James Noble. My opening remarks were scripted, as were Guy Steele's, and my rebuttals were drawn from an extensive set of notes.
- rpg's Opening Remarks [html]
- gls's Opening Remarks [html]
- Discursive Notes [1.1 mb pdf ]
- Notes as Slides [7.1 mb pdf ]
Memorial for Leonard N. Zubkoff
My friend Leonard Zubkoff died in the Summer of 2002, and on March 29, 2003, a memorial was held for him. I wrote this for his memorial and read it there.
Software Preservation [pdf]
The Computer History Museum under the leadership of Grady Booch held a workshop from October 1617, 2003, on the topic of preserving historically interesting software source code and artifacts. This was my presentation.
Science of Design [pdf]
NSF sponsored a workshop at Airlie House in Virginia from November 24, 2003, on the topic of "Science of Design: Software Intensive Systems." This was my presentation.
Integrating Form and Function [pdf]
The Santa Fe Institute and Collegium Budapest held a workshop from Novermber 1619, 2003, in Budapest. I was invited to give a presentation, and prepared the one here, but when I got there I saw that my presentation was not appropriate, so I withdrew it.
Do Programmers Need Seat Belts?
I wrote this around 1993 as part of my duties at ParcPlace Systems, which was a SmallTalk company. In it I argued for dynamic languages, a debate that I lost.
Common Lisp Object System
In the late 1980s, a group of us designed CLOS, which became part of Common Lisp.
In April 2004, I attended a DARPA workshop on Self-Aware Systems. While there I led a breakout session on systems engineering, focused a bit on self-sustaining systems engineering. Here are my workshop position statement (pdf) and the presentation (pdf) I made reporting on the breakout session on systems engineering.
OOPSLA 2004 Workshops, Panels, and Presentations
In Vancouver, October 2004, I ran a workshop on Art and Science, attended a workshop, and presented on 3 panels. These are the position papers and slides I used for them:
- Extravagaria 2Art Assisting Science, "What is Science? What is Art?" [pdf]
- For the panel, "Software Development: Math & Science or Arts & Crafts?," "Explore; Discover; Understand" [position paper pdf] [presentation pdf]
- For the panel , "Challenges in Outsourcing and Global Development: How Will Your Job Change?", "Outsourcing: Those Cheap Bastards" [position paper pdf] [presentation pdf]
- For the session, "Onward! Breakthrough Ideas," "The Stability after Confusion" [position paper pdf] [presentation pdf]
- For the workshop, "The Customer Role in Agile Projects," "Clients, Customers, and the Celebration of Change" [position paper pdf]
The Art of Lisp & Writing
In 2003 I wrote a foreword for "Successful Lisp: How to Understand and Use Common Lisp," by David B. Lamkins. This is that foreword.
Creation: A Culture of Gift
In 2005 I wrote a short response to an essay by Frederick Turner ("Creating a Culture of Gift"), both of which were published in Conversations on Philanthropy: An Interdisciplinary Series of Reflections and Research, Volume II, New Paradigms. This is that response.
This paper appeared in Onward! 2006. This is the version before it was submitted for publication.
Open Standards, Open Source, and the Public Good
This essay was written over Labor Day weekend in 2004 in response to an urgent request by the Lab director (of the Lab we were working for at the time) for Ron Goldman and me to write a "Labs whitepaper" on why governments should favor open source over proprietary software. The whitepaper was to be given to some California legislator staffers the following Wednesday. We were given no direction regarding the tone, style, or content, so we put together what we thought was a good argument in a light academic style. The paper was rejected by the Lab director and president of the company because it was not perky enoughthey preferred it to be in the style of a light and incisive blog entry. But, perhaps it contains some useful arguments.
The Poetry of Programming
In December of 2003 I was intervewied by a writer at Sun Microsystems for a piece that appeared on the Java web page. Over the years that interview has been popular. In fact, when it came out on the Java page, it quickly gathered the most hits (by far) of any interview to appear there. Now that I am no longer at Sun, I don't know how long they will keep it on the site, so I've moved it over here. Enjoy.
The Commons as New Economy & What This Means for Research [pdf]
This is a position paper I wrote for an open source workshop at ICSE 2007. The abstract starts like this: "Suppose the entire social and commercial fabric supporting the creation of software is changingchanging by becoming completely a commons and thereby dropping dramatically in cost. How would the world change and how would we recognize the changes?"
Writers’ Workshops As Scientific Methodology [pdf]
This is a short paper I was invited to submit to a special issue of IEEE Software by the guest editors, but they decided to reject it. It's nothing special, but the editor-in-chief of IEEE Software told me she would consider it for one of their regular issues. I didn't take her up on it.
Design Beyond Human Abilities [3.3 mb pdf]
On November 16, 2007, I presented a talk on Design as my Wei Lun Public Lecture at the Chinese University of Hong Kong. This is a revised and reimagined transcript of that talk. I have given a similar talk to this several time since Spring 2006.
[Note: to make this file of managable size, I downsampled the slides quite a bit.]
Design of An Optimizing, Dynamically Retargetable Compiler for Common Lisp [pdf]
"This paper describes the techniques used to develop the Lucid Portable Common Lisp compiler. The major focus of this paper is on the problems and techniques relating to the goals of producing a compiler which is retargetable and, at the same time, capable of producing highly tailored code for each target architecture. The compiler that resulted from this effort is not only retargetable, but dynamically retargetable in the sense that multiple target descriptions may reside in the same runtime environment, and the desired target is passed as an optional argument to the compiler."
I posted this paper because some researchers have written about similar approaches but seem not to know about this work. It was presented at the 1986 ACM Conference on Lisp and Functional Programming.
S-1 Common Lisp Implementation [pdf]
This is a paper Rod Brooks, Guy Steele, and I wrote for Lisp and Functional Programming conference in 1982, about S-1 Lisp.
Lisp-in-Lisp: High Performance and Portability [pdf]
Another paper by Rod Brooks, Guy Steele, and me on S-1 Lisp, for IJCAI 1983.
The Three Bears Problem [pdf]
This little position paper was submitted to an NSF workshop on revising the undergraduate programming language curriculum. It was judged off topic, which is right, but I thought they wouldn't notice.
The Road: Reinventing Education [pdf]
This paper was written in 1 day by 7 of us at ChiliPLoP in Carefree, Arizona, in the Winter of 2008. We came up with the idea for it on a Monday, wrote it beginning Tuesday afternoon, and submitted it just before the deadline for Onward! on Wednesday. It was rejected (not enough substantiation and review of prior educational approaches etc - perhaps the committee wasn't sure what Onward! is about).
Designed as Designer
An essay on design and artand where creativity comes from.
Science is Not Enough: On the Creation of Software [script (pdf)][slides (6.8mb pdf)]
This is a talk I gave at the Software Product Line Conference in August 2009. It is in two parts: the script and the slides. The slides PDF is 6.8mb.
Requirements for a Common Prototyping System [pdf]
In 1988 I was part of a DARPA study group looking at the idea of a Common Prototyping Language. The group included Robert Balzer, Frank Belz, Robert Dewar, David Fisher, John Guttag, Paul Hudak, and Mitchell Wand. We didn't agree on a prototyping language, but instead thought about a prototyping system. This is the group's final report. I was its editor.
Using CLOS-like Concepts in a Prototyping System [pdf]
In 1989 I worked on combining work on the Common Prototyping System with work on Qlisp for a workshop at OOPSLA 1989. This paper is what I wrote, and it's like the stuff in "The Design of Parallel Programming Languages."
A Review of The Art of the Metaobject Protocol [pdf]
I wrote a review of this book in 1993 for the journal Artificial Intelligence. This is that review.
Better Science Through Art [pdf]
An essay on how artists, engineers, and scientists perform their professions, arguing that they all use the same techniques.
Defamiliarization: Flarf, Conceptual Writing, and Using Flawed Software Tools as Creative Partners [workshop paper pdf] [journal paper pdf]
An essay on how art can be made using flawed tools, and the beginning of the theory of why it works.
The Structure of a Programming Language Revolution [pdf]
An essay on engineering intermixing with science, and an exploration of incommensurabilty in programming language research. An Onward! Essay.
Publication Culture in Computer Science and Software Engineering [pdf]
I was sent what seemed to be a call for position papers for a Dagstuhl on publication culture being put on by someone at ACM to study the future of computer science publication. I believed that with my experience with journals and conferences, I would be a natural participant. I didn't realize the workshop was for a closed club and I was on the outside. This is the position paper I submittedit's a little braggy about my experiences.
Structured Descriptions [pdf]
This was the first paper I wrote. It was a lowly Vision Flash at the MIT AI Lab, but it convinced David Waltz to take me with him to the University of Illinois to start an AI Lab. This was the beginning of my career.
I Throw Itching Powder at Tulips [pdf]
An essay on using programming to construct instruments to explore nature and pursue knowledge. This is about programming to discover and understand, not to create something of economic value. An example is the InkWell project, which is to understand how to write in a writerly way.
InkWell: A Creative Writers Creative Assistant [pdf]
About Inkwell, which is a system to revise and write text to match personality types and mimick writers. Also is pretty creative.
"in the control room of the banquet" [pdf]
An Onward! essay about InkWell writing haiku and an exploration of the Turing Test using a variation conducted at a writers' conference.
Glue It All Together With Python
Glue It All Together With Python
Guido van Rossum
1895 Preston White Drive
Reston, VA 20191
Email: email@example.com, firstname.lastname@example.org
Position paper for the OMG-DARPA-MCC Workshop on Compositional Software Architecture in Monterey, California, January 6-8, 1998.
Python is an advanced scripting language that is being used successfully to glue together large software components. It spans multiple platforms, middleware products, and application domains. Python is an object-oriented language with high-level data structures, dynamic typing, and dynamic binding. Python has been around since 1991, and has a very active user community. For more information, see the Python website http://www.python.org.
Like Tcl, Python is easily extensible with C/C++/Java code, and easily embeddable in applications. Python even uses Tk, the Tcl GUI toolkit, for a de-facto standard portable GUI toolkit. Unlike Tcl, however, Python supports object-oriented programming. Python programmers can create classes, use multiple inheritance, define methods, overload operators, and so on.
Syntactically, Python code looks like executable pseudo code. Program development using Python is 5-10 times faster than using C/C++, and 3-5 times faster than using Java. In many cases, a prototype of an application can be written in Python without writing any C/C++/Java code. Often, the prototype is sufficiently functional and performs well enough to be delivered as the final product, saving considerable development time. Other times, the prototype can be translated in part or in whole to C++ or Java -- Python's object-oriented nature makes the translation a straightforward process.
The best approach is often to write only the performance-critical parts of the application in C++ or Java, and use Python for all higher-level control and customization. There are several anecdotes about applications that started out as pure C++ code to which Python was added as an extension language, where in each new version the percentage of the application written in Python increased, while also increasing the overall performance, functionality and reliability of the application. (E.g. Case Study: Python in a Commercial Environment, by Greg Stein, Microsoft, in Proceedings of the 6th International Python Conference, and the Alice VR project at UvA and CMU.)
Python has a strong presence on the web. It is suitable for CGI programming (on all platforms: Unix, Windows and Mac); there are interfaces to all major commercial databases. Python has a library that interfaces to the main Internet and web protocols, and has HTML parsing and generation toolkits. Python was a major implementation language for Infoseek when they were smaller. At least one company (Digital Creations) is selling a suite of server side tools using Python. And finally, Python has been used to implement a web browser (Grail).
Python is also well represented in the distributed systems world. It is one of the main languages supported by Xerox PARC's ILU (Inter-Language Unification; a CORBA compatible distributed object system), and many distributed applications have been built in Python using ILU. Python is also used by the Hector project at the University of Queensland, Australia.
Finally, Python is well integrated with the Windows platforms. Python programs can interact with COM and DCOM services, and can even implement new COM and DCOM services (which is not possible using Visual Basic!). Python can also be used as a scripting engine in Microsoft's Active Scripting architecture.
Using Python as an Integration Language
Relevant to the topic of this workshop, Python is in use at many places as an integration language, used to glue together ("steer") existing components. The strategy here is to create Python extension modules (written in C/C++) that make the functionality of large components written in C/C++ available to the Python programmer. The extension ("glue") modules are required because Python cannot call C/C++ functions directly; the glue extensions handle conversion between Python data types and C/C++ data types and error checking, translation error return values into Python exception.
Creation of glue extensions is simplified by the existence of SWIG, which reads header files containing function and method prototypes and automatically generates the necessary type conversion and error checking code. In situations where the underlying code (usually C code) doesn't use an object-oriented model, the glue extension can in turn be wrapped in a Python module that defines a proper class hierarchy, while delegating the performance critical operations to the C code.
Using Python, better applications can be developed because different kinds of programmers can work together on a project. For example, when building a scientific application, C/C++ programmers can implement efficient numerical algorithms, while scientists on the same project can write Python programs that test and use those algorithms. The scientist doesn't have to learn a low-level programming language, and the C/C++ programmer doesn't need to understand the science involved.
Without Python, large amounts of C/C++ code often have to be written just to provide a flexible enough input mechanism so that scientists can feed the program its data, in all the variantions that are required for reasons of experimental setup (for instance). With Python, Python can be used to wrote a much more flexible input mechanism in a much shorter time, or Python itself can be the ultimate flexible input mechanism. As an extreme example, Lawrence Livermore National Laboratories is using Python to eventually replace a scripting language (BASIS) that was developed in house for the same purpose; BASIS started out as a simple input mechanism for Fortran programs, and gradually acquired many features of scripting languages (variables, conditionals, loops, procedures and so on) with increasing awkwardness.
Because Python has existing interfaces to so many different components in very different application domains, Python is ideal for oddball integration tasks. It can link a commercial database to number-crunching code; it can add a graphical user interface to a network management tool; it can send email from a virtual reality application.
Python can fulfill an important integration role in the design of large applications with a long life expectancy. It allows a fast response to changes in user requirements that require adapting the higher-level application logic without changing the fundamental underlying components. It also allows quick adaptation of the application to changes in the underlying components.
Epilogue: Python and Java Integration
A new Python implementation written in 100% Pure Java, dubbed JPython, is currently under development; alpha releases are available for evaluation. JPython offers seamless scripting for Java. It is a full implementation of the Python language and standard library, adding direct access to the universe of Java classes. Java code can also use Python classes -- this is important for callbacks, for instance.
The main thrust for JPython is that it does for Java what Python already does for C and C++: to present programmers with more options in the trade-off between development time and execution time, by providing a more dynamic, more expressive alternative. JPython's integration with Java is superior to Python's integration with C/C++: due to Java's Reflection API, JPython can use arbitrary Java classes without the help of a wrapper generator such as SWIG. (C/C++ code must first be made available to Java through the Java native code interface; once it is callable from Java it is callable from JPython.)