From crabapple.srv.cs.cmu.edu!news Tue Aug 17 10:20:11 EDT 1993 Article: 10890 of comp.lang.lisp Xref: crabapple.srv.cs.cmu.edu comp.lang.lisp:10890 Newsgroups: comp.lang.lisp Path: crabapple.srv.cs.cmu.edu!news From: sef@sef-pmax.slisp.cs.cmu.edu Subject: The Igor Project Message-ID: Sender: news@cs.cmu.edu (Usenet News System) Nntp-Posting-Host: sef-pmax.slisp.cs.cmu.edu Organization: School of Computer Science, Carnegie Mellon Date: Tue, 17 Aug 1993 05:07:31 GMT Lines: 94 Igor is a new ARPA-funded research project in Carnegie Mellon University's School of Computer Science. I am the project leader, and it is staffed by the wizards of the former CMU Common Lisp project, plus a few new faces. We have been working informally on Igor and Dylan since last April, while finishing up some loose ends on CMU CL. As I announced earlier, CMU CL will still be available, and we will continue to support it, though at a considerably reduced level of effort. Our primary goal is to develop the Igor programming environment, which will support (and be implemented in) the Dylan language. Igor will also provide tools for interfacing Dylan code to libraries and routines written in other languages, but Dylan will be the "universal glue". Igor is designed to support the ongoing evolution of a software system throughout its life cycle, from earliest prototyping through deployment and beyond. By remaining in a single language environment throughout the software life cycle, we minimize the loss of design information and the need to recover this knowledge later through costly "re-engineering". In order to achieve this goal, Igor must provide both an excellent dynamic development environment and the ability to deliver runtime code modules that are competitive in size and speed with the code produced by C, Fortran, or Ada. This is made possible by Dylan's clear separation of the development and runtime environments -- something not present to the same degree in Common Lisp. The Igor development environment will be built around a concept we call "hypercode" (analogous to "hypertext"). Code in Igor will not be a linear string of ASCII characters, but rather a complex data structure linking together routines, class definitions, comments, specifications, diagrams, test code, edit histories, configuration info, and more. The programmer will be able to view and browse this hypercode at many levels of detail, and the code definitions can be presented in whatever order makes the most sense at the time. (In some ways this is reminiscent of the old Interlisp environment.) An extensive library of classes and functions will also be available, with librarian software to guide users in finding what they needs. While software can be run and tested within the Igor development environment, the user can ask at any time to compile the current system into a "delivery module" that is as small and compact as possible. Once created, the delivery module will never be changed (though it may be replaced). All changes are made and tested back in the development environment. Since the delivery module is not meant to be altered, it can be welded together as tightly as object code coming from a conventional static language. At this point, code speed just becomes a question of good compiler technology. The delivery module can be small, since it contains only those library modules (or parts of modules) that the system needs at runtime. It might or might not include a garbage collector. About half of the effort in this project will go into building the Igor environment and half into developing a high-quality implementation of Dylan. In building our Dylan and the associated libraries, we will draw heavily on code developed for CMU CL, including chunks of the Python compiler. In addition to our own code, we will establish an online library for Dylan code that others would like to make freely available to the community. Sometime this fall we will release a prototype Dylan implementation embedded in CMU CL. This is not meant for serious use, but may be of interest to people who want to play around with Dylan. We are using it internally for cross-development and testing of ideas. We hope to have a stand-alone Dylan implementation ready for release by Fall of 1994, though this depends on a number of factors not entirely within our control. All releases will be announced on "comp.lang.dylan". Regarding intellectual property issues, our goals are to make the software we produce easily available to the research community and to help popularize Dylan, while still retaining some control over commercial use of the Igor development environment and derivative works. Our tentative plan is to copyright the Igor code, but with blanket permission to use the library and runtime code. This should eliminate any concerns over "runtime licenses" for commercial applications developed in Igor. Our Dylan compiler and the Igor environment code will be copyrighted but free for non-commercial use; anyone who wants to sell this code or incorporate any of it into a commercial product will need a license from CMU. We plan to set up a consortium for companies who are interested in working with us on this effort. The details of that are still being worked out. One final note: While we plan to base Igor on the Dylan language, we do not yet have a license to use the name "Dylan", which is an Apple trademark. We believe that this will be fixed by the time we have something ready for general release. -- Scott =========================================================================== Scott E. Fahlman Internet: sef+@cs.cmu.edu Senior Research Scientist Phone: 412 268-2575 School of Computer Science Fax: 412 681-5739 Carnegie Mellon University Latitude: 40:26:33 N 5000 Forbes Avenue Longitude: 79:56:48 W Pittsburgh, PA 15213 ===========================================================================