The A-Z of Programming Languages (Interviews with Programming Language Creators)
Total Page：16
File Type：pdf, Size：1020Kb
The A-Z of Programming Languages (interviews with programming language creators) Computerworld, 2008-20101 Ada: S. Tucker Taft ...................................................... 1 Arduino: Tom Igoe ...................................................... 5 ASP: Microsoft .......................................................... 9 AWK: Alfred Aho ....................................................... 11 AWK & AMPL: Brian Kernighan ....................................... 15 Bash: Chet Ramey....................................................... 17 C#: Anders Hejlsberg.................................................... 20 C++: Bjarne Stroustrup ................................................. 27 Clojure: Rich Hickey .................................................... 35 ColdFusion: Jeremy Allaire .............................................. 38 D: Walter Bright ......................................................... 41 Erlang: Joe Armstrong................................................... 44 F#: Don Syme .......................................................... 48 Falcon: Giancarlo Niccolai ............................................... 51 Forth: Charles Moore .................................................... 59 Groovy: Guillaume Laforge .............................................. 61 Haskell: Simon Peyton-Jones............................................. 65 INTERCAL: Don Wood................................................. 76 JavaScript: Brendan Eich................................................ 79 Lua: Roberto Ierusalimschy............................................... 84 MATLAB: Cleve Moler.................................................. 88 Modula-3: Luca Cardelli................................................. 91 Objective-C: Brad Cox .................................................. 93 Perl: Larry Wall ......................................................... 96 1When the table of contents is being read using a PDF viewer, the titles link to the Web pages of the original publications, and the page numbers are internal links Python: Guido van Rossum .............................................. 100 Scala: Martin Odersky ................................................... 105 Sh: Steve Bourne ........................................................ 109 Smalltalk-80: Alan Kay ................................................. 116 Tcl: John Ousterhout .................................................... 121 YACC: Stephen Johnson ................................................. 123 Ada: S. Tucker Taft S. Tucker Taft is a Chairman and CTO of SofCheck. Taft has been heavily involved in the Ada 1995 and 2005 revisions, and still works with the language today as both a designer and user. Computerworld spoke to Taft to learn more about the development and maintenance of Ada, and found a man deeply committed to language design and development How did you first become involved with Ada? After graduating in 1975, I worked for Harvard for four years as the ‘system mother’ for the first Unix system outside of Bell Labs. During that time I spent a lot of time with some of the computer science researchers, and became aware of the DOD-1 language design competition. I had been fascinated with programming language design for several years at that point, and thought it was quite exciting that there was a competition to design a standard language for mission-critical software. I also had already developed some strong opinions about language design, so I had some complaints about all of the designs. In September of 1980, a year after I left my job at Harvard, I returned to the Boston area and ended up taking a job at Intermetrics, the company responsible for the design of the Red language, one of the four semifinalists and one of the two finalists for DOD-1. By that time [the language was] renamed to Ada in honor of Lady Ada Lovelace, daughter of Lord Byron and associate of Charles Babbage. Although Intermetrics had shortly before lost the competition to Honeywell-Bull-Inria, they were still quite involved with the overall process of completing the Ada standard, and were in the process of bidding on one of the two major Ada compiler acquisitions, this one for the Air Force. After a 6-month design period and 12-month public evaluation, the Intermetrics design was chosen over two others and I became first the head of the Ada Program Support Environment part, and then ultimately of the Ada compiler itself. One of the requirements of the Air Force Ada Integrated Environment contract was to write the entire compiler and environment in Ada itself, which created some interesting bootstrap problems. In fact, we had to build a separate boot compiler in Pascal, before we could even compile the real compiler. By the time we delivered, we had written almost a million lines of Ada code, and had seen Ada go from a preliminary standard to a Military standard (MIL-STD-1815), to an ANSI standard (Ada 83), and finally to an ISO standard (ISO 8652, Ada 87). I also had to go through the personal progression of learning the language, griping about the language, and then finally accepting the language as it was, so I could use it productively. However, in 1988 the US Department of Defense announced that they were beginning the process to revise the Ada standard to produce Ada 9X (where X was some digit between 0 and 9). I quickly resurrected all my old gripes and a few new ones, and helped to write a proposal for Intermetrics to become the Ada 9X Mapping/Revision Team (the government’s nomenclature for the language design team). This time the Intermetrics team won the competition over several other teams, including one that included Jean Ichbiah, the lead designer of the original Ada 83 standard. I was the technical lead of the Intermetrics MRT team, with Christine Anderson of the Air Force as the manager of the overall Ada 9X project on the government side. What are the main differences between the original Ada and the 95 revision? The big three Ada 95 language revisions were hierarchical libraries, protected objects, and object- oriented programming. Hierarchical libraries referred to the enhancement of the Ada module namespace to take it from Ada 83’s simple flat namespace of library units, where each unit had a single unique identifier, to a hierarchical namespace of units, with visibility control between parent and child library unit. Protected objects referred to the new passive, data-oriented synchronization construct that we defined to augment the existing active message/rendezvous-oriented task construct of Ada 83. Object-oriented programming was provided in Ada 95 by enhancing an existing derived-type capability of Ada 83, by supporting type extension as part of deriving from an existing type, as 1 well as supporting run-time polymorphism with the equivalent of virtual functions and run-time type tags. What prompted the Ada revision in 95? ISO standards go through regular revision cycles. Generally every five years a standard must be reviewed, and at least every ten years it must be revised. There were also some specific concerns about the language, though generally the language had turned out to be a reasonably good fit to the needs of mission-critical software development. In particular, Ada’s strong support for abstract data types in the guise of packages and private types had emerged as a significant step up in software engineering, and Ada’s run-time checking for array bounds and null pointers had helped catch a large class of typical programming errors earlier in the life-cycle. Was there a particular problem you were trying to solve? Object-oriented programming was growing in popularity at the time, though it was still not fully trusted by much of the mission-critical software development community. In addition, the Ada 83 tasking model was considered elegant, but did not provide the level of efficiency or control that many real-time system developers would have preferred. Once the Ada 9X revision process began, a requirements team was formed to solicit explicit comments from the Ada community about the language, both in terms of things to preserve and things to improve. Have you faced any hard decisions in your revision of Ada? Every language-design decision was pretty hard, because there were many goals and requirements, some of which were potentially conflicting. Perhaps the most difficult decisions were political ones, where I realized that to achieve consensus in the language revision process among the ISO delegations, we (the design team) would have to give up some of our personal favourite revision proposals. Are you still working with the language now and in what context? Yes, I am still working with the language, both as a user and as a language designer. As you may know the newest version of the language, known as Ada 2005, just recently achieved official standardization. The Ada 2005 design process was quite different from the Ada 95 process, because Ada 2005 had no Department of Defense supported design team, and instead had to rely on strictly voluntary contributions of time and energy. Nevertheless, I am extremely proud of the accomplishments of the Ada 2005 design working group. We managed to round out many of the capabilities of Ada 95 into a language that overall I believe is even better integrated, is more powerful and flexible, while also being even safer and more secure. Would you have done anything differently in the development of Ada 95 or Ada 2005 if you had the chance? The few technical problems in the development