XTAG - a Graphical Workbench for Developing Tree-Adjoining Grammars*

Total Page:16

File Type:pdf, Size:1020Kb

XTAG - a Graphical Workbench for Developing Tree-Adjoining Grammars* XTAG - A Graphical Workbench for Developing Tree-Adjoining Grammars* Patrick Paroubek**, Yves Schabes and Aravind K. Joshi Department of Computer and Information Science University of Pennsylvania Philadelphia PA 19104-6389 USA pap/schabes/[email protected] Abstract XTAG runs under Common Lisp and X Window (CLX). We describe a workbench (XTAG) for the development of tree-adjoining grammars and their parsers, and dis- 1 Introduction cuss some issues that arise in the design of the graphical interface. Tree-adjoining grammar (TAG) [Joshi et al., 1975; Joshi, Contrary to string rewriting grammars generating 1985; Joshi, 1987] and its lexicalized variant [Schabes et trees, the elementary objects manipulated by a tree- al., 1988; Schabes, 1990; Joshi and Schabes, 1991] are adjoining grammar are extended trees (i.e. trees of depth tree-rewriting systems in which the syntactic properties one or more) which capture syntactic information of lex- of words are encoded as tree structured-objects of ex- ical items. The unique characteristics of tree-adjoining tended size. TAG trees can be combined with adjoining grammars, its elementary objects found in the ~lexicon and substitution to form new derived trees. 1 (extended trees) and the derivational history of derived Tree-adjoining grammar differs from more traditional trees (also a tree), require a specially crafted interface in tree-generating systems such as context-free grammar in which the perspective has Shifted from a string-based to two ways: a tree-based system. XTAG provides such a graphical 1. The objects combined in a tree-adjoining grammar interface in which the elementary objects are trees (or (by adjoining and substitution) are trees and not tree sets) and not symbols (or strings). strings. In this approach, the lexicon associates with The kernel of XTA G is a predictive left to right parser a word the entire structure it selects (as shown in for unification-based tree-adjoining grammar [Schabes, Figure 1) and not just a (non-terminal) symbol as 1991]. XTAG includes a graphical editor for trees, a in context-free grammars. graphical tree printer, utilities for manipulating and displaying feature structures for unification-based tree- 2. Unlike string-based systems such as context-free adjoining grammar, facilities for keeping track of the grammars, two objects are built when trees are com- derivational history of TAG trees combined with adjoin- bined: the resulting tree (the derived tree) and its ing and substitution, a parser for unification based tree- derivational history (the derivation tree). 2 adjoining grammars, utilities for defining grammars and These two unique characteristics of tree-adjoining lexicons for tree-adjoining grammars, a morphological grammars, the elementary objects found in the lexicon recognizer for English (75 000 stems deriving 280 000 in- (extended trees) and the distinction between derived tree flected forms) and a tree-adjoining grammar for English and its derivational history (also a tree), require a spe- that covers a large range of linguistic phenomena. cially crafted interface in which the perspective must Considerations of portability, efficiency, homogeneity be shifted from a string-based to a tree-based system. and ease of maintenance, lead us to the use of Common Lisp without its object language addition and to the use 1We assume familiarity throughout the paper with the of the X Window interface to Common Lisp (CLX) for definition of TAGs. See the introduction by Joshi [1987] the implementation of XTAG. for an introduction to tree-adjoining grammar. We refer the reader to Joshi [1985], Joshi [1987], Kroch and Joshi [1985], XTA G without the large morphological and syntactic Abeill~ et al. [1990a], Abeill~ [1988] and to Joshi and Schabes lexicons is public domain software. The large morpho- [1991] for more information on the linguistic characteristics logical and syntactic lexicons can be obtained through of TAG such as its lexicalization and factoring recursion out an agreement with ACL's Data Collection Initiative. of dependencies. 2The TAG derivation tree is the basis for semantic inter- *This work was partially supported by NSF grants DCR- pretation [Shieber and Schabes, 1990b], generation [Shieber 84-10413, ARO Grant DAAL03-87-0031, and DARPA Grant and Schabes, 1991] and machine translation [Abeill~ et al., N0014-85-K0018. 1990b] since the information given in this data-structure is **Visiting from the L aboratoire Informatique Th~orique et richer than the one found in the derived tree. Furthermore, Programmation, Institut Blaise Pascal, 4 place Jussieu, 75252 it is at the level of the derivation tree that ambiguity must PARIS Cedex 05, France. be defined. 223 s rithm [Chalnick, 1989]. The algorithm is an im- provement of the ones developed by R.eingold and NP NPo$ VP Tolford [1981] and, Lee [1987]. It guarantees in lin- ear time that tress which are structural mirror im- (0~1) D~N (/~1) V SI*NA ages of on another are drawn such that their dis- plays are reflections of one another while achieving J I minimum width of the tree. boy thi nk s • Capabilities for grouping trees into sets which can be linked to a file. This is particularly useful since lexicalized TAGs organize trees into tree-families NPo$ VP which capture all variations of a predicative lexical item for a given subcategorization frame. V NPI$ PP2 S • Utilities for editing and processing equations for unification based tree-adjoining grammar [Vijay- Shanker and ]oshi, 1988; Schabes, 1990]. take P NP2 NP0$ VP • A predictive left to right parser for unification-based tree-adjoining grammar [Schabes, 1991]. into N 2 V NPI$ • Utilities for defining a grammar (set of trees, set of I I tree families, set of lexicons) which the parser uses. account saw • Morphological lexicons for English [Karp et al., Figure 1: Elementary trees found in a tree-adjoining 1992] grammar lexicon • A tree-adjoining grammar for English that covers a large range of linguistic phenomena. XTA G provides such a graphical interface in which the 2 XTAG Components elementary objects are trees (or tree sets) and not sym- bols (or strings of symbols). The communication with the user is centralized around Skeletons of such workbenches have been previously the interface manager window (See Figure 2) which gives realized on Symbolics machines [Schabes, 1989; Schif- the user control over the different modules of XTAG. ferer, 1988]. Although they provided some insights on the architectural design of a TAG workbench, they were test I never expanded to a full fledged natural language envi- ronment because of inherent limitations (such as their lack of portability). Q Pp~ XTAG runs under Common Lisp [Steele, 1990] and it F ~~ha~utrMOVpnXL~ uses the Common LISP X Interface (CLX) to access the O eV,~x~Vpm~ graphical primitives defined by the Xll protocol. XTAG 0 ,~V'IMOVpnxl O QWlm~Vpn~. is portable across machines and Common Lisp compilers. The kernel of XTA G is a predictive left to right parser for unification-based tree-adjoining grammar [Schabes, F /mm,M~ ~Im~s~a~n~w~ ham,w~r m,OvsLm,m 0 ~Vl,tdVsl 1991]. The system includes the following components O pR0s~Vsl 0 com0~l and features: O !~v~umDVd G MimJVsl • Graphical edition of trees. The graphical display of F ~w~e]',sJNa~nml~s~lJsh,Snw~n~0Vslp~.trem a tree is the only representation of a tree accessible @ eW0~0Vslp~ to the user. Some of the operations that can be o epnmOWlp=~ performed graphically on trees are: O =Whu~Vsll~2 0 [~Vsll~2 - Add and edit nodes. o l~L~,~ov~ap~ 0 II~1~V~I~2 - Copy, paste, move or delete subtrees. 0 l~t~m~tt~p~ F ~~}Is~ Jpn~ml~n.~0 Val./re~ - Combine two trees with adjunction or substitu- O ao,~/al tion. These operations keep track of the deriva- O aW0nx~Va]. tional history and update attributes stated in form of feature structures as defined in the Figure 2: Manager Window. framework of unification-based tree-adjoining grammar [Vijay-Shanker and Joshi, 1988]. This window displays the contents of the tree buffers - View the derivational history of a derived tree currently loaded into the system. The different functions and its components (elementary trees). of XTAG are available by means of a series of pop-up menus associated to buttons, and by means of mouse • A tree display module for efficient and aesthetic for- actions performed on the mouse-sensitive items (such as matting of a tree based on a new tree display algo- the tree buffer names and the tree names). 224 A tree editor for a tree contained in one of the tree XTAG uses a centralized clipboard for all binary op- buffer contained in the window can be called up by click- erations on trees (all operations are either unary or bi- ing over its tree name. Each tree editor manages one tree nary). These operations (such as paste, adjoin or substi- and as many tree editors as needed can run concurrently. tute) are always performed between the tree contained For example, Figure 2 holds a set of files (such in XTAG's clipboard and the current tree. The contents as Tnx0Vsl.trees) 3 which each contain trees (such as of the clipboard can be displayed in a special view-only anx0Vsl). When this tree is selected for editing, the window. window shown in Figure 3 is displayed. Files can be The request to view the derivational history of a tree handled independently or in group, in which case they result of a combining operation triggers the opening of a form a tree family (flag F next to a buffer name). view-only window which displays the associated deriva- tion tree.
Recommended publications
  • The Copyright Law of the United States (Title 17, U.S
    NOTICE WARNING CONCERNING COPYRIGHT RESTRICTIONS: The copyright law of the United States (title 17, U.S. Code) governs the making of photocopies or other reproductions of copyrighted material. Any copying of this document without permission of its author may be prohibited by law. CMU Common Lisp User's Manual Mach/IBM RT PC Edition David B. McDonald, Editor April 1989 CMU-CS-89-132 . School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213 This is a revised version of Technical Report CMU-CS-87-156. Companion to Common Lisp: The Language Abstract CMU Common Lisp is an implementation of Common Lisp that currently runs on the IBM RT PC under Mach, a Berkeley Unix 4.3 binary compatible operating system. This document describes the implementation dependent choices made in developing this implementation of Common Lisp. Also, several extensions have been added, including the proposed error system, a stack crawling debugger, a stepper, an interface to Mach system calls, a foreign function call interface, the ability to write assembler language routines, and other features that provide a good environment for developing Lisp code. This research was sponsored by the Defense Advanced Research Projects Agency (DOD), ARPA Order No. 4976 under contract F33615-87-C-1499 and monitored by the Avionics Laboratory, Air Force Wright Aeronautical Laboratories, Aeronautical Systems Division (AFSC), Wright-Patterson AFB, OHIO 45433-6543. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Defense Advanced Research Projects Agency or the U.S.
    [Show full text]
  • Automated Support for Software Development with Frameworks
    Automated Support for Software Development with Frameworks Albert Schappert and Peter Sommerlad Wolfgang Pree Siemens AG - Dept.: ZFE T SE C. Doppler Laboratory for Software Engineering D-81730 Munich, Germany Johannes Kepler University - A-4040 Linz, Austria Voice: ++49 89 636-48148 Fax: -45111 Voice: ++43 70 2468-9431 Fax: -9430 g E-mail: falbert.schappert,peter.sommerlad @zfe.siemens.de E-mail: [email protected] Abstract However, the object–oriented concepts and frameworks intro- duce additional complexity to software development. A framework This document presents some of the results of an industrial research gains its functionality by the cooperation of different components. project on automation of software development. The project’s ob- Thus, the use of a single component may be based on its interrela- jective is to improve productivity and quality of software devel- tionships with others that must be understood and mastered by the opment. We see software development based on frameworks and application developer. libraries of prefabricated components as a step in this direction. Present work on software architecture also emphasizes the in- An adequate development style consists of two complementary terrelationships between software components depending on each activities: the creation of frameworks and new components for other to get control on this additional complexity. There the term de- functionality not available and the composition and configuration sign pattern is used to describe and specify component interaction of existing components. mechanisms in an informal way[Pree, 1994a][Buschmann et al., Just providing adequate frameworks and components does not 1994][Gamma et al., 1994].
    [Show full text]
  • Allegro CL User Guide
    Allegro CL User Guide Volume 1 (of 2) version 4.3 March, 1996 Copyright and other notices: This is revision 6 of this manual. This manual has Franz Inc. document number D-U-00-000-01-60320-1-6. Copyright 1985-1996 by Franz Inc. All rights reserved. No part of this pub- lication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means electronic, mechanical, by photocopying or recording, or otherwise, without the prior and explicit written permission of Franz incorpo- rated. Restricted rights legend: Use, duplication, and disclosure by the United States Government are subject to Restricted Rights for Commercial Software devel- oped at private expense as specified in DOD FAR 52.227-7013 (c) (1) (ii). Allegro CL and Allegro Composer are registered trademarks of Franz Inc. Allegro Common Windows, Allegro Presto, Allegro Runtime, and Allegro Matrix are trademarks of Franz inc. Unix is a trademark of AT&T. The Allegro CL software as provided may contain material copyright Xerox Corp. and the Open Systems Foundation. All such material is used and distrib- uted with permission. Other, uncopyrighted material originally developed at MIT and at CMU is also included. Appendix B is a reproduction of chapters 5 and 6 of The Art of the Metaobject Protocol by G. Kiczales, J. des Rivieres, and D. Bobrow. All this material is used with permission and we thank the authors and their publishers for letting us reproduce their material. Contents Volume 1 Preface 1 Introduction 1.1 The language 1-1 1.2 History 1-1 1.3 Format
    [Show full text]
  • Comprehensive Support for Developing Graphical Highly
    AN ABSTRACT OF THE THESIS OF J-Iuan -Chao Keh for the degree of Doctor of Philosophy in Computer Science presented on July 29. 1991 Title:Comprehensive Support for Developing Graphical. Highly Interactive User Interface Systems A Redacted for Privacy Abstract approved: ed G. Lewis The general problem of application development of interactive GUI applications has been addressed by toolkits, libraries, user interface management systems, and more recently domain-specific application frameworks. However, the most sophisticated solution offered by frameworks still lacks a number of features which are addressed by this research: 1) limited functionality -- the framework does little to help the developer implement the application's functionality. 2) weak model of the application -- the framework does not incorporate a strong model of the overall architecture of the application program. 3) representation of control sequences is difficult to understand, edit, and reuse -- higher-level, direct-manipulation tools are needed. We address these problems with a new framework design calledOregon Speedcode Universe version 3.0 (OSU v3.0) which is shown, by demonstration,to overcome the limitations above: 1) functionality is provided by a rich set of built-in functions organizedas a class hierarchy, 2) a strong model is provided by OSU v3.0 in the form ofa modified MVC paradigm, and a Petri net based sequencing language which together form the architectural structure of all applications produced by OSU v3.0. 3) representation of control sequences is easily constructed within OSU v3.0 using a Petri net editor, and other direct manipulation tools builton top of the framework. In ddition: 1) applications developed in OSU v3.0 are partially portable because the framework can be moved to another platform, and applicationsare dependent on the class hierarchy of OSU v3.0 rather than the operating system of a particular platform, 2) the functionality of OSU v3.0 is extendable through addition of classes, subclassing, and overriding of existing methods.
    [Show full text]
  • Evolution and Composition of Object-Oriented Frameworks
    Evolution and Composition of Object-Oriented Frameworks Michael Mattsson University of Karlskrona/Ronneby Department of Software Engineering and Computer Science ISBN 91-628-3856-3 © Michael Mattsson, 2000 Cover background: Digital imagery® copyright 1999 PhotoDisc, Inc. Printed in Sweden Kaserntryckeriet AB Karlskrona, 2000 To Nisse, my father-in-law - who never had the opportunity to study as much as he would have liked to This thesis is submitted to the Faculty of Technology, University of Karlskrona/Ronneby, in partial fulfillment of the requirements for the degree of Doctor of Philosophy in Engineering. Contact Information: Michael Mattsson Department of Software Engineering and Computer Science University of Karlskrona/Ronneby Soft Center SE-372 25 RONNEBY SWEDEN Tel.: +46 457 38 50 00 Fax.: +46 457 27 125 Email: [email protected] URL: http://www.ipd.hk-r.se/rise Abstract This thesis comprises studies of evolution and composition of object-oriented frameworks, a certain kind of reusable asset. An object-oriented framework is a set of classes that embodies an abstract design for solutions to a family of related prob- lems. The work presented is based on and has its origin in industrial contexts where object-oriented frameworks have been developed, used, evolved and managed. Thus, the results are based on empirical observations. Both qualitative and quanti- tative approaches have been used in the studies performed which cover both tech- nical and managerial aspects of object-oriented framework technology. Historically, object-oriented frameworks are large monolithic assets which require several design iterations and are therefore costly to develop. With the requirement of building larger applications, software engineers have started to compose multiple frameworks, thereby encountering a number of problems.
    [Show full text]
  • The Embeddable Common Lisp
    ACM Lisp Pointers 8(1), 1995, 30-41 The Embeddable Common Lisp Giuseppe Attardi Dipartimento di Informatica, Universit`adi Pisa Corso Italia 40, I-56125 Pisa, Italy net: [email protected] Abstract The Embeddable Common Lisp is an implementation of Common Lisp designed for being embeddable within C based applications. ECL uses standard C calling conventions for Lisp compiled functions, which allows C programs to easily call Lisp functions and viceversa. No foreign function interface is required: data can be exchanged between C and Lisp with no need for conversion. ECL is based on a Common Runtime Support (CRS) which provides basic facilities for memory management, dynamic loading and dumping of binary images, support for multiple threads of execution. The CRS is built into a library that can be linked with the code of the application. ECL is modular: main modules are the program development tools (top level, debugger, trace, stepper), the compiler, and CLOS. A native implementation of CLOS is available in ECL: one can configure ECL with or without CLOS. A runtime version of ECL can be built with just the modules which are required by the application. 1 Introduction As applications become more elaborate, the facilities required to build them grow in number and sophistica- tion. Each facility is accessed through a specific package, quite complex itself, like in the cases of: modeling, simulation, graphics, hypertext facilities, data base management, numerical analysis, deductive capabilities, concurrent programming, heuristic search, symbolic manipulation, language analysis, special device control. Reusability is quite a significant issue: once a package has been developed, tested and debugged, it is un- desirable having to rewrite it in a different language just because the application is based in such other language.
    [Show full text]
  • 51. Graphical User Interface Programming
    Brad A. Myers Graphical User Interface Programming - 1 51. Graphical User Interface Programming Brad A. Myers* Human Computer Interaction Institute Carnegie Mellon University 5000 Forbes Avenue Pittsburgh, PA 15213 [email protected] http://www.cs.cmu.edu/~bam (412) 268-5150 FAX: (412) 268-1266 *This paper is revised from an earlier version that appeared as: Brad A. Myers. “User Interface Software Tools,” ACM Transactions on Computer-Human Interaction. vol. 2, no. 1, March, 1995. pp. 64-103. Draft of: January 27, 2003 To appear in: CRC HANDBOOK OF COMPUTER SCIENCE AND ENGINEERING – 2nd Edition, 2003. Allen B. Tucker, Editor-in-chief Brad A. Myers Graphical User Interface Programming - 2 51.1. Introduction Almost as long as there have been user interfaces, there have been special software systems and tools to help design and implement the user interface software. Many of these tools have demonstrated significant productivity gains for programmers, and have become important commercial products. Others have proven less successful at supporting the kinds of user interfaces people want to build. Virtually all applications today are built using some form of user interface tool [Myers 2000]. User interface (UI) software is often large, complex and difficult to implement, debug, and modify. As interfaces become easier to use, they become harder to create [Myers 1994]. Today, direct manipulation interfaces (also called “GUIs” for Graphical User Interfaces) are almost universal. These interfaces require that the programmer deal with elaborate graphics, multiple ways for giving the same command, multiple asynchronous input devices (usually a keyboard and a pointing device such as a mouse), a “mode free” interface where the user can give any command at virtually any time, and rapid “semantic feedback” where determining the appropriate response to user actions requires specialized information about the objects in the program.
    [Show full text]
  • Design and Implementation of ET++, a Seamless Object-Oriented Application Framework1
    Design and Implementation of ET++, a Seamless Object-Oriented Application Framework1 André Weinand, Erich Gamma, Rudolf Marty Abstract: ET++ is a homogeneous object-oriented class library integrating user interface building blocks, basic data structures, and support for object input/output with high level application framework components. The main goals in designing ET++ have been the desire to substantially ease the building of highly interactive applications with consistent user interfaces following the well known desktop metaphor, and to combine all ET++ classes into a seamless system structure. Experience has proven that writing a complex application based on ET++ can result in a reduction in source code size of 80% and more compared to the same software written on top of a conventional graphic toolbox. ET++ is im- plemented in C++ and runs under UNIX™ and either SunWindows™, NeWS™, or the X11 window system. This paper discusses the design and implementation of ET++. It also reports key experience from working with C++ and ET++. A description of code browsing and object inspection tools for ET++ is included as well. ET++ is available in the public domain.2 Key Words: application framework, user interfaces, user interface toolkits, object-oriented programming, C++ programming language, programming environment 1 Introduction Making computers easier to use is one of the reasons for the current interest in interactive and graphical user interfaces that present information as pictures instead of text and numbers. They are easy to learn and fun to use. Constructing such interfaces, on the other hand, often requires considerable effort because they must not only provide the functionality of conventional programs, but also have to show data as well as manipulation concepts in a pictorial way.
    [Show full text]
  • Rhapsody Developer's Guide
    Jesse Feiler AP PROFESSIONAL AP Professional is a division of Academic Press Boston San Diego New York London Sydney Tokyo Toronto Find us on the Web! http:/ /www.apnet.com This book is printed on acid-free paper. @ Copyright © 1997 by Academic Press. All rights reserved. No part of this publication may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopy, recording, or any information storage and retrieval system, without permission in writing from the publisher. Excerpts from Chartsmith are copyright © 1997 by Blacksmith, Inc. All rights reserved. Excerpts from OpenBase are copyright © 1997 by OpenBase International, Ltd. All rights reserved. Excerpts from Create are copyright © 1997 by Stone Design, Inc. All rights reserved. Excerpts from OmniWeb are copyright © 1997 by Omni Development, Inc. All rights reserved. Excerpts from TIFFany are copyright © 1997 by Caffeine Software. All rights reserved. All brand names and product names mentioned in this book are trademarks or registered trademarks of their respective companies. Academic Press 525 B Street, Suite 1900, San Diego, CA 92101-4495 1300 Boylston Street, Chestnut Hill, MA 02167 United Kingdom Edition published by ACADEMIC PRESS LIMITED 24-28 Oval Road, London NW1 7DX ISBN 0-12-251334-7 Printed in the United States of America 97 98 99 00 CP 9 8 7 6 5 4 3 2 1 Table of Contents Advanced Mac Look and Feel i Y e llo w Box Mac OS 0P6NSTgP based JaCT^ Core OS: Microkernel, ^0, Fiie System... |Power Macintosh, PowerPC Piatform Hardware Semantics T ables ........................................................................................... xv Preface...........................................................................................................
    [Show full text]
  • GNU/Linux AI & Alife HOWTO
    GNU/Linux AI & Alife HOWTO GNU/Linux AI & Alife HOWTO Table of Contents GNU/Linux AI & Alife HOWTO......................................................................................................................1 by John Eikenberry..................................................................................................................................1 1. Introduction..........................................................................................................................................1 2. Traditional Artificial Intelligence........................................................................................................1 3. Connectionism.....................................................................................................................................1 4. Evolutionary Computing......................................................................................................................1 5. Alife & Complex Systems...................................................................................................................1 6. Agents & Robotics...............................................................................................................................1 7. Programming languages.......................................................................................................................2 8. Missing & Dead...................................................................................................................................2 1. Introduction.........................................................................................................................................2
    [Show full text]
  • WCL: Delivering Efficient Common Lisp Applications Under Unix 1
    WCL: Delivering Efficient Common Lisp Applications under Unix Wade Hennessey Center for Design Research Stanford University wade@ sunrise. stanf ord. edu Abstract: Common Lisp implementations for Unix from foreign data. However, because Lisp programs can- have traditionally provided a rich development environ- not be provided to other programmers in a form com- ment at the expense of an inefficient delivery environ- patible with the native system linker, Lisp must remain ment. The goal of WCL is to allow hundreds of Lisp “in control” by linking foreign code into the Lisp image. applications to be realistically available at once, while Unfortunately, foreign debugging information is usually allowing several of them to run concurrently. WCL ac- lost in the process, thus making debugging of mixed complishes this by providing Common Lisp as a Unix language programa difficult. shared library that can be linked with Lisp and C code Standalone applications are produced by dynami- to produce efficient applications. For example, the cally loading application code into a running Lisp and executable for a Lisp version of the canonical “Hello then saving a memory image to disk. Autoloading can World!” program requires only 40k bytes under SunOS be used to delay the loading of code until runtime, thus 4.1 for SPARC. WCL also supports a full development reducing image size, but it can substantially increase the environment, including dynamic file loading and debug- startup time of an application. Treeshakers and selec- ging. A modified version of GDB [1], the GNU Debug- tive loading of subparts of the Lisp system are also used ger, is used to debug WCL programs, providing support to reduce the size of saved memory images, but the in- for mixed language debugging.
    [Show full text]
  • Programming Environments John Foderaro In
    Programming Environments John Foderaro In this issue we feature a description of Delph! Common Lisp, an enhanced version of Kyoto Common Lisp. Company: Delphi S.p.A. Via della Vetraia, 11 1-55049 Viareggio, Italy tel: + 39 (584) 395225 fax: + 39 (584) 395366 tlx: 501542 DELPlll I Product name: Delphi Common Lisp Version of product described: All versions. This version available when: This year. Contact Delphi for more information. Hardware available on: Sun 3, Sun 4, Sun 386i, general 386-based machines running Unix system V. Available on a wide variety of hardware and operating systems in the near future. Delphi Common Lisp is a full implementation of Common Lisp than runs on a range of general-purpose computers. DCL provides several major facilities on top of the Common Lisp standard to provide a more complete and powerful programming language including - Common Lisp Object System, in complete accordance with the ANSI X3J 13 subcommittee proposal. - CLX, the emerging standard binding between Common l,isp and the X Window system "client" functionality. It's implemented entirely in Lisp (doesn't go through XLib) and provides direct access from Lisp to all X Window client functions. - "Multithread" facility to create and control concurrent threads of program execution. Useful for U.I. design and other applications where interrupts can come from a variety of sources as well as parallel processing research. - ttigh productivity facilities like ZetaLisp LOOP macro, Symbolics-style DEFSYSTEM, autoioad facility, EMACS editor interface Influence: The Common Lisp component of DCL is based on Kyoto Common Lisp, meaning that it's extremely portable and, now, performs quite well.
    [Show full text]