DOCSLIB.ORG

Dylan Programming Release 1.0

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Dylan Programming Release 1.0 Dylan Programming Release 1.0 Neal Feinberg, Sonya E. Keene, Robert O. Mathews, P. Tucker Withington Nov 25, 2018 CONTENTS 1 Front Matter 3 2 Preface 5 2.1 Dylan...................................................5 2.2 Audience.................................................5 2.3 Goals of this book............................................5 2.4 Organization of this book........................................6 2.5 Program examples............................................6 2.6 Conventions used in this book......................................6 2.7 An image of Dylan............................................7 2.8 Acknowledgments............................................7 3 Part 1. Basic Concepts 9 3.1 Introduction...............................................9 3.2 Quick Start................................................ 14 3.3 Methods, Classes, and Objects...................................... 24 3.4 User-Defined Classes and Methods................................... 32 3.5 Class Inheritance............................................. 40 3.6 Multimethods............................................... 55 3.7 Modularity................................................ 59 3.8 A Simple Library............................................. 69 4 Part 2. Intermediate Topics 77 4.1 Nonclass Types.............................................. 77 4.2 Slots................................................... 82 4.3 Collections and Control Flow...................................... 95 4.4 Functions................................................. 111 4.5 Libraries and Modules.......................................... 126 4.6 Four Complete Libraries......................................... 147 5 Part 3. Sample Application 159 5.1 Design of the Airport Application.................................... 159 5.2 Definition of a New Collection...................................... 164 5.3 The Airport Application......................................... 169 6 Part 4. Advanced Topics 191 6.1 Multiple Inheritance........................................... 191 6.2 Performance and Flexibility....................................... 206 6.3 Exceptions................................................ 223 6.4 Macros.................................................. 235 i 7 Source Code of Program Examples 247 8 Resources on Dylan 249 8.1 World Wide Web pages for this book and its examples......................... 249 8.2 Newsgroup................................................ 249 8.3 Harlequin................................................. 249 8.4 Carnegie Mellon University....................................... 250 8.5 Apple Computer, Inc........................................... 250 8.6 Digitool, Inc................................................ 251 8.7 Marlais.................................................. 251 9 Dylan Object Model for C and C++ Programmers 253 9.1 The concept of pointers......................................... 253 9.2 The concept of classes.......................................... 256 10 Glossary 261 Index 267 ii Dylan Programming, Release 1.0 This book will be useful to anyone learning dynamic, object-oriented programming, whether it be in Dylan, Java, Smalltalk, or Lisp. —Andrew Shalit, author of The Dylan Reference Manual. CONTENTS 1 Dylan Programming, Release 1.0 2 CONTENTS CHAPTER ONE FRONT MATTER by Neal Feinberg, Sonya E. Keene, Robert O. Mathews, P. Tucker Withington Harlequin Incorporated Published by Addison-Wesley Longman, ISBN 0-201-47976-1 The authors have all worked on Harlequin’s Dylan product. Neal Feinberg manages the development of Harlequin’s database technology. Sonya E. Keene, author of Object-Oriented Programming in Common Lisp (Addison Wesley Longman, 1989) is also involved in publishing large documents ont the World Wide Web. Robert O. Mathews was previously the OSF documentation project leader for Motif and DCE. P. Tucker Withington designs and develops automatic memory-management facilities for Dylan. Dylan Programming is available in print from Harlequin, Addison-Wesley, or your bookseller. Copyright 1994, 1995, 1996 by The Harlequin Group Limited. All rights reserved. 3 Dylan Programming, Release 1.0 4 Chapter 1. Front Matter CHAPTER TWO PREFACE 2.1 Dylan Dylan (DYnamic LANguage) is a new programming language invented by Apple Computer and several partners. Dylan is dynamic, is object-oriented, and delivers efficient applications. The Dylan language is defined by The Dylan Reference Manual, written by Andrew Shalit, and published by Addison- Wesley (1996). That manual is the definitive reference on Dylan. The Dylan Reference Manual is available on the World Wide Web; see Resources on Dylan, for details. Dylan is up and running. You can get it from Harlequin, Carnegie Mellon University, Apple Computer, Digitool, and other organizations. Dylan implementations run on most of the popular computer platforms. Full-fledged implemen- tations provide both a compiler and a development environment. You can obtain public-domain implementations. See Resources on Dylan. 2.2 Audience This book is written for application programmers who have experience working in a conventional language, such as C, Pascal, COBOL, FORTRAN, or BASIC, or in an object-oriented language, such as C++, Java, Smalltalk, or Common LISP with CLOS. Familiarity with object-oriented programming and dynamic languages is not required. We do compare Dylan to C, C++, and Java in this book, but you can read and understand the book without any knowledge of C, C++, or Java. 2.3 Goals of this book The primary goals of this book are to teach you how to program in Dylan, and how to write programs in an object- oriented style. Along the way, we hope to convince you to use Dylan. It is intended to be a practical, elegant, and fun language to use. This book is a tutorial on programming in Dylan, and it does the following: • Begins with the most basic use of Dylan, and gradually expands to show the more powerful and advanced techniques. • Gives the flavor of working with the Dylan language in a typical Dylan environment. • Shows how to define classes and methods that work together to solve a problem. • Shows how to use many of Dylan’s classes, functions, and features to good effect within the context of an example application. • Introduces the more advanced features of Dylan, including multiple inheritance, performance, exceptions, and macros. 5 Dylan Programming, Release 1.0 This book does not attempt to be as complete as The Dylan Reference Manual, and does not provide the following kinds of material: • Complete descriptions of all classes and functions provided by Dylan • Complete descriptions of the detailed mechanisms in Dylan • To make full use of Dylan, programmers need The Dylan Reference Manual, as well as this book. 2.4 Organization of this book We have divided the chapters of this book into four parts: • Part 1. Basic Concepts, introduces the object-oriented and dynamic nature of Dylan. • Part 2. Intermediate Topics, provides more details about Dylan’s object-oriented techniques, and covers col- lections (that is, how to use strings, vectors, lists, and other kinds of collections), control flow, libraries, and modules. • Part 3. Sample Application, contains a complete working application that illustrates the topics covered in Part 1. Basic Concepts and Part 2. Intermediate Topics. • Part 4. Advanced Topics, covers four areas that are sophisticated and powerful: multiple inheritance, perfor- mance versus flexibility, exceptions, and macros. The chapters in Part 4. Advanced Topics show how we can improve the example shown in Part 3. Sample Application by applying advanced techniques. 2.5 Program examples This book includes many program examples. Our approach is to show how evolutionary programming might work by presenting an example simply at first, and then expanding it gradually. In Part 1. Basic Concepts, we develop an example of a simple library that represents time and position. That library is needed for the sample airport application that we develop in Part 3. Sample Application. The airport application simulates airplanes, runways, gates, flights, and airports. Its goal is to schedule gates for arriving and departing aircraft. To do scheduling, we need the library that represents and manipulates time and position. Harlequin and Addison-Wesley provide World Wide Web pages containing the source code of the program examples. See Source Code of Program Examples. Dylan’s core language is lean. It does not include input–output facilities, support for a user interface, or interfaces for communicating with programs written in other languages. These features are available in libraries supplied by vendors or in the public domain. We want this book to be applicable to the widest possible range of Dylan implementations, so we focus on the core Dylan language, and use only those library interfaces that are widely available. 2.6 Conventions used in this book • We use boldface when we introduce new terms, such as library. • We use bold typewriter font for code examples and names of Dylan functions and objects, such as define method. Code comments appear in oblique typewriter font — for example, // Method that says a greeting define method say-greeting (greeting :: <object>); format-out("%s\n", greeting); end; 6 Chapter 2. Preface Dylan Programming, Release 1.0 • Many Dylan environments provide a listener, which enables you to type in expressions and to see their return values and output. We use a hypothetical Dylan listener to show the result of evaluating
Load more

Recommended publications
  • Common Lispworks User Guide
    LispWorks® for the Windows® Operating System Common LispWorks User Guide Version 5.1 Copyright and Trademarks Common LispWorks User Guide (Windows version) Version 5.1 February 2008 Copyright © 2008 by LispWorks Ltd. All Rights Reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of LispWorks Ltd. The information in this publication is provided for information only, is subject to change without notice, and should not be construed as a commitment by LispWorks Ltd. LispWorks Ltd assumes no responsibility or liability for any errors or inaccuracies that may appear in this publication. The software described in this book is furnished under license and may only be used or copied in accordance with the terms of that license. LispWorks and KnowledgeWorks are registered trademarks of LispWorks Ltd. Adobe and PostScript are registered trademarks of Adobe Systems Incorporated. Other brand or product names are the registered trade- marks or trademarks of their respective holders. The code for walker.lisp and compute-combination-points is excerpted with permission from PCL, Copyright © 1985, 1986, 1987, 1988 Xerox Corporation. The XP Pretty Printer bears the following copyright notice, which applies to the parts of LispWorks derived therefrom: Copyright © 1989 by the Massachusetts Institute of Technology, Cambridge, Massachusetts. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, pro- vided that this copyright and permission notice appear in all copies and supporting documentation, and that the name of M.I.T.
    [Show full text]
  • The Evolution of Lisp
    1 The Evolution of Lisp Guy L. Steele Jr. Richard P. Gabriel Thinking Machines Corporation Lucid, Inc. 245 First Street 707 Laurel Street Cambridge, Massachusetts 02142 Menlo Park, California 94025 Phone: (617) 234-2860 Phone: (415) 329-8400 FAX: (617) 243-4444 FAX: (415) 329-8480 E-mail: [email protected] E-mail: [email protected] Abstract Lisp is the world’s greatest programming language—or so its proponents think. The structure of Lisp makes it easy to extend the language or even to implement entirely new dialects without starting from scratch. Overall, the evolution of Lisp has been guided more by institutional rivalry, one-upsmanship, and the glee born of technical cleverness that is characteristic of the “hacker culture” than by sober assessments of technical requirements. Nevertheless this process has eventually produced both an industrial- strength programming language, messy but powerful, and a technically pure dialect, small but powerful, that is suitable for use by programming-language theoreticians. We pick up where McCarthy’s paper in the first HOPL conference left off. We trace the development chronologically from the era of the PDP-6, through the heyday of Interlisp and MacLisp, past the ascension and decline of special purpose Lisp machines, to the present era of standardization activities. We then examine the technical evolution of a few representative language features, including both some notable successes and some notable failures, that illuminate design issues that distinguish Lisp from other programming languages. We also discuss the use of Lisp as a laboratory for designing other programming languages. We conclude with some reflections on the forces that have driven the evolution of Lisp.
    [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]
  • ESA: a CLIM Library for Writing Emacs-Style Applications
    ESA: A CLIM Library for Writing Emacs-Style Applications Robert Strandh Troels Henriksen LaBRI, Université Bordeaux 1 DIKU, University of Copenhagen 351, Cours de la Libération Universitetsparken 1, Copenhagen 33405 Talence Cedex [email protected] France [email protected] David Murray Christophe Rhodes ADMurray Associates Goldsmiths, University of London 10 Rue Carrier Belleuse, 75015 Paris New Cross Road, London, SE14 6NW [email protected] [email protected] ABSTRACT style applications. The central distinguishing feature of an We describe ESA (for Emacs-Style Application), a library Emacs-style application, for our purposes, is that it uses for writing applications with an Emacs look-and-feel within short sequences of keystrokes as the default method of in- the Common Lisp Interface Manager. The ESA library voking commands, and only occasionally requires the user to takes advantage of the layered design of CLIM to provide a type the full name of the command in a minibuffer. A spe- command loop that uses Emacs-style multi-keystroke com- cial keystroke (M-x) is used to invoke commands by name. mand invocation. ESA supplies other functionality for writ- This interaction style is substantially different from the one ing such applications such as a minibuffer for invoking ex- provided by CLIM by default, and therefore required us to tended commands and for supplying command arguments, write a different CLIM top level. Fortunately, CLIM was Emacs-style keyboard macros and numeric arguments, file designed to make this not only possible but fairly straight- and buffer management, and more. ESA is currently used forward, as the implementation of a replacement top level in two major CLIM applications: the Climacs text editor can build on the protocol layers beneath, just as the default (and the Drei text gadget integrated with the McCLIM im- top level is built.
    [Show full text]
  • Hannes Mehnert [email protected] December
    Introduction Dylan Going Further Dylan Hannes Mehnert [email protected] December 16, 2004 Hannes Mehnert [email protected] Dylan Introduction Dylan Going Further Introduction Overview Hello World History Dylan Libraries and Modules Classes Generic Functions Types Sealing Going Further Hannes Mehnert [email protected] Dylan Introduction Overview Dylan Hello World Going Further History Overview I DYnamic LANguage Hannes Mehnert [email protected] Dylan Introduction Overview Dylan Hello World Going Further History Overview I DYnamic LANguage I Object Oriented: everything is an object Hannes Mehnert [email protected] Dylan Introduction Overview Dylan Hello World Going Further History Overview I DYnamic LANguage I Object Oriented: everything is an object I Safe: type-checking of arguments and values, no buffer overruns, no implicit casting, no raw pointers Hannes Mehnert [email protected] Dylan Introduction Overview Dylan Hello World Going Further History Overview I DYnamic LANguage I Object Oriented: everything is an object I Safe: type-checking of arguments and values, no buffer overruns, no implicit casting, no raw pointers I Efficient: can compile to code nearly as efficient as C Hannes Mehnert [email protected] Dylan Introduction Overview Dylan Hello World Going Further History Hello world define method hello-world () format-out(``Hello world\n''); end method; Hannes Mehnert [email protected] Dylan Introduction Overview Dylan Hello World Going Further History factorial define method factorial ( i ) if (i = 0) 1 else i
    [Show full text]
  • ESA: a CLIM Library for Writing Emacs-Style Applications
    ESA: A CLIM Library for Writing Emacs-Style Applications Robert Strandh Troels Henriksen LaBRI, Université Bordeaux 1 DIKU, University of Copenhagen 351, Cours de la Libération Universitetsparken 1, Copenhagen 33405 Talence Cedex [email protected] France [email protected] David Murray Christophe Rhodes ADMurray Associates Goldsmiths, University of London 10 Rue Carrier Belleuse, 75015 Paris New Cross Road, London, SE14 6NW [email protected] [email protected] ABSTRACT style applications. The central distinguishing feature of an We describe ESA (for Emacs-Style Application), a library Emacs-style application, for our purposes, is that it uses for writing applications with an Emacs look-and-feel within short sequences of keystrokes as the default method of in- the Common Lisp Interface Manager. The ESA library voking commands, and only occasionally requires the user to takes advantage of the layered design of CLIM to provide a type the full name of the command in a minibuffer. A spe- command loop that uses Emacs-style multi-keystroke com- cial keystroke (M-x) is used to invoke commands by name. mand invocation. ESA supplies other functionality for writ- This interaction style is substantially different from the one ing such applications such as a minibuffer for invoking ex- provided by CLIM by default, and therefore required us to tended commands and for supplying command arguments, write a different CLIM top level. Fortunately, CLIM was Emacs-style keyboard macros and numeric arguments, file designed to make this not only possible but fairly straight- and buffer management, and more. ESA is currently used forward, as the implementation of a replacement top level in two major CLIM applications: the Climacs text editor can build on the protocol layers beneath, just as the default (and the Drei text gadget integrated with the McCLIM im- top level is built.
    [Show full text]
  • A Python Implementation for Racket
    PyonR: A Python Implementation for Racket Pedro Alexandre Henriques Palma Ramos Thesis to obtain the Master of Science Degree in Information Systems and Computer Engineering Supervisor: António Paulo Teles de Menezes Correia Leitão Examination Committee Chairperson: Prof. Dr. José Manuel da Costa Alves Marques Supervisor: Prof. Dr. António Paulo Teles de Menezes Correia Leitão Member of the Committee: Prof. Dr. João Coelho Garcia October 2014 ii Agradecimentos Agradec¸o... Em primeiro lugar ao Prof. Antonio´ Leitao,˜ por me ter dado a oportunidade de participar no projecto Rosetta com esta tese de mestrado, por todos os sabios´ conselhos e pelos momentos de discussao˜ e elucidac¸ao˜ que se proporcionaram ao longo deste trabalho. Aos meus pais excepcionais e a` minha mana preferida, por me terem aturado e suportado ao longo destes quase 23 anos e sobretudo pelo incondicional apoio durante estes 5 anos de formac¸ao˜ superior. Ao pessoal do Grupo de Arquitectura e Computac¸ao˜ (Hugo Correia, Sara Proenc¸a, Francisco Freire, Pedro Alfaiate, Bruno Ferreira, Guilherme Ferreira, Inesˆ Caetano e Carmo Cardoso), por todas as sug- estoes˜ e pelo inestimavel´ feedback em artigos e apresentac¸oes.˜ Aos amigos em Tomar (Rodrigo Carrao,˜ Hugo Matos, Andre´ Marques e Rui Santos) e em Lisboa (Diogo da Silva, Nuno Silva, Pedro Engana, Kaguedes, Clara Paiva e Odemira), por terem estado pre- sentes, duma forma ou doutra, nos essenciais momentos de lazer. A` Fundac¸ao˜ para a Cienciaˆ e Tecnologia (FCT) e ao INESC-ID pelo financiamento e acolhimento atraves´ da atribuic¸ao˜ de uma bolsa de investigac¸ao˜ no ambitoˆ dos contratos Pest-OE/EEI/LA0021/2013 e PTDC/ATP-AQI/5224/2012.
    [Show full text]
  • ASDF 3, Or Why Lisp Is Now an Acceptable Scripting Language (Extended Version)
    ASDF 3, or Why Lisp is Now an Acceptable Scripting Language (Extended version) François-René Rideau Google [email protected] Abstract libraries, or network services; one can scale them into large, main- ASDF, the de facto standard build system for Common Lisp, has tainable and modular systems; and one can make those new ser- been vastly improved between 2009 and 2014. These and other im- vices available to other programs via the command-line as well as provements finally bring Common Lisp up to par with "scripting via network protocols, etc. languages" in terms of ease of writing and deploying portable code The last barrier to making that possible was the lack of a that can access and "glue" together functionality from the underly- portable way to build and deploy code so a same script can run ing system or external programs. "Scripts" can thus be written in unmodified for many users on one or many machines using one or Common Lisp, and take advantage of its expressive power, well- many different compilers. This was solved by ASDF 3. defined semantics, and efficient implementations. We describe the ASDF has been the de facto standard build system for portable most salient improvements in ASDF and how they enable previ- CL software since shortly after its release by Dan Barlow in 2002 ously difficult and portably impossible uses of the programming (Barlow 2004). The purpose of a build system is to enable divi- language. We discuss past and future challenges in improving this sion of labor in software development: source code is organized key piece of software infrastructure, and what approaches did or in separately-developed components that depend on other compo- didn’t work in bringing change to the Common Lisp community.
    [Show full text]
  • Commonloops Merging Lisp and Object-Oriented Programming Daniel G
    CommonLoops Merging Lisp and Object-Oriented Programming Daniel G. Bobrow, Kenneth Kahn, Gregor Kiczales, Larry Masinter, Mark Stefik, and Frank Zdybel Xerox Palo Alto Research Center Palo Alto, California 94304 CommonLoops blends object-oriented programming Within the procedure-oriented paradigm, Lisp smoothly and tightly with the procedure-oriented provides an important approach for factoring design of Lisp. Functions and methods are combined programs that is'different from common practice in in a more general abstraction. Message passing is object-oriented programming. In this paper we inuoked via normal Lisp function call. Methods are present the linguistic mechanisms that we have viewed as partial descriptions of procedures. Lisp data developed for integrating these styles. We argue that types are integrated with object classes. With these the unification results in something greater than the integrations, it is easy to incrementally move a program sum of the parts, that is, that the mechanisms needed between the procedure and object -oriented styles. for integrating object-oriented and procedure-oriented approaches give CommonLoops surprising strength. One of the most important properties of CommonLoops is its extenswe use of meta-objects. We discuss three We describe a smooth integration of these ideas that kinds of meta-objects: objects for classes, objects for can work efficiently in Lisp systems implemented on a methods, and objects for discriminators. We argue that wide variety of machines. We chose the Common Lisp these meta-objects make practical both efficient dialect as a base on which to bui|d CommonLoops (a implementation and experimentation with new ideas Common Lisp Object-Oriented Programming System).
    [Show full text]
  • Jon L. White Collection on Common Lisp
    http://oac.cdlib.org/findaid/ark:/13030/c89w0mkb No online items Jon L. White collection on Common Lisp Finding aid prepared by Bo Doub, Kim Hayden, and Sara Chabino Lott Processing of this collection was made possible through generous funding from The Andrew W. Mellon Foundation, administered through the Council on Library and Information Resources' Cataloging Hidden Special Collections and Archives grant. Computer History Museum 1401 N. Shoreline Blvd. Mountain View, CA, 94043 (650) 810-1010 [email protected] March 2017 Jon L. White collection on X6823.2013 1 Common Lisp Title: Jon L. White collection Identifier/Call Number: X6823.2013 Contributing Institution: Computer History Museum Language of Material: English Physical Description: 8.75 Linear feet,7 record cartons Date (bulk): Bulk, 1978-1995 Date (inclusive): 1963-2012 Abstract: The Jon L. White collection on Common Lisp contains material relating to the development and standardization of the programming language Common Lisp and, more generally, the Lisp family of programming languages. Records date from 1963 to 2012, with the bulk of the material ranging from 1978 to 1995, when White was working at MIT’s Artificial Intelligence Laboratory, Xerox PARC (Palo Alto Research Center), Lucid, and Harlequin Group. Throughout many of these positions, White was serving on the X3J13 Committee to formalize a Common Lisp standard, which aimed to combine and standardize many previous dialects of Lisp. This collection consists of conference proceedings, manuals, X3J13 Committee correspondence and meeting minutes, notebooks, technical papers, and periodicals documenting White’s work in all of these roles. Other dialects of Lisp--especially MAClisp--are also major focuses of the collection.
    [Show full text]
  • How to Make Lisp Go Faster Than C [Pdf]
    IAENG International Journal of Computer Science, 32:4, IJCS_32_4_19 ______________________________________________________________________________________ How to make Lisp go faster than C Didier Verna∗ Abstract statically (hence known at compile-time), just as you would do in C. Contrary to popular belief, Lisp code can be very ef- cient today: it can run as fast as equivalent C code Safety Levels While dynamically typed Lisp code or even faster in some cases. In this paper, we explain leads to dynamic type checking at run-time, it how to tune Lisp code for performance by introducing is possible to instruct the compilers to bypass the proper type declarations, using the appropriate all safety checks in order to get optimum per- data structures and compiler information. We also formance. explain how eciency is achieved by the compilers. These techniques are applied to simple image process- Data Structures While Lisp is mainly known for ing algorithms in order to demonstrate the announced its basement on list processing, the Common- performance on pixel access and arithmetic operations Lisp standard features very ecient data types in both languages. such as specialized arrays, structs or hash tables, making lists almost completely obsolete. Keywords: Lisp, C, Numerical Calculus, Image Pro- cessing, Performance Experiments on the performance of Lisp and C were conducted in the eld of image processing. We bench- 1 Introduction marked, in both languages, 4 simple algorithms to measure the performances of the fundamental low- More than 15 years after the standardization process level operations: massive pixel access and arithmetic of Common-Lisp [5], and more than 10 years after processing.
    [Show full text]
  • Basic Lisp Techniques
    Basic Lisp Techniques David J. Cooper, Jr. February 14, 2011 ii 0Copyright c 2011, Franz Inc. and David J. Cooper, Jr. Foreword1 Computers, and the software applications that power them, permeate every facet of our daily lives. From groceries to airline reservations to dental appointments, our reliance on technology is all-encompassing. And, it’s not enough. Every day, our expectations of technology and software increase: • smart appliances that can be controlled via the internet • better search engines that generate information we actually want • voice-activated laptops • cars that know exactly where to go The list is endless. Unfortunately, there is not an endless supply of programmers and developers to satisfy our insatiable appetites for new features and gadgets. Every day, hundreds of magazine and on-line articles focus on the time and people resources needed to support future technological expectations. Further, the days of unlimited funding are over. Investors want to see results, fast. Common Lisp (CL) is one of the few languages and development options that can meet these challenges. Powerful, flexible, changeable on the fly — increasingly, CL is playing a leading role in areas with complex problem-solving demands. Engineers in the fields of bioinformatics, scheduling, data mining, document management, B2B, and E-commerce have all turned to CL to complete their applications on time and within budget. CL, however, no longer just appropriate for the most complex problems. Applications of modest complexity, but with demanding needs for fast development cycles and customization, are also ideal candidates for CL. Other languages have tried to mimic CL, with limited success.
    [Show full text]