DOCSLIB.ORG

Csc 372 Comparative Programming Languages Background S-Expressions S-Expressions

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Csc 372 Comparative Programming Languages Background S-Expressions S-Expressions Background Scheme is based in LISP which was developed by John CSc 372 McCarthy in the mid 50s. LISP stands for LISt Processing, not Lots of Irritating Comparative Programming Silly Parentheses. Languages Functions and data share the same representation: 3: Scheme — Introduction S-Expressions. A basic LISP implementation needs six functions Christian Collberg cons, car, cdr, equal, atom, cond. [email protected] Scheme was developed by Sussman and Steele in Department of Computer Science 1975. University of Arizona Copyright c 2004 Christian Collberg 372—Fall 2004—3 [1] 372—Fall 2004—3 [2] S-Expressions S-Expressions — Examples An S-Expression is a balanced list of parentheses. Legal Illegal 66 More formally, an S-expression is ( () 1. a literal (i.e., number, boolean, symbol, character, (5)) (4 5) string, or empty list) (these are sometimes called ()() ((5)) atoms). (4 (5) (()()) 2. a list of s-expressions. )( ((4 5) (6 (7))) 372—Fall 2004—3 [3] 372—Fall 2004—3 [4] S-Expressions as Trees S-Expressions as Function Calls An S-expression can be seen as a linear representation A special case of an S-expression is when the first of tree-structure: element of a list is a function name. Such an expression can be evaluated. 2 2 (6) (3 4) > (+ 4 5) 9 > (add-five-to-my-argument 20) 6 3 4 25 > (draw-a-circle 20 45) #t (2 (3 4) (5 (6) 7)) 2 3 4 5 7 6 372—Fall 2004—3 [5] 372—Fall 2004—3 [6] S-Expressions as Functions Function Application. As we will see, function definitions are also In general, a function application is written like this: S-expressions: (operator arg1 arg2 : : : argn) § ¤ ( define ( farenheit−2−celsius f ) The evaluation proceeds as follows: ( ∗ ( − f 3 2 ) 5 / 9 ) 1. Evaluate operator. The result should be a function ) F. ¦ ¥ 2. Evaluate So, Scheme really only has one syntactic structure, the arg1; arg2; : : : argn S-expression, and that is used as a data-structure (to to get represent lists, trees, etc), as function definitions, and val1; val2; : : : valn as function calls. 3. Apply F to val1; val2; : : : valn. 372—Fall 2004—3 [7] 372—Fall 2004—3 [8] Function Application — Examples Numbers > (+ 4 5) Scheme has 9 Fractions (5/9) > (+ (+ 5 6) 3) 14 Integers (5435) > 7 Complex numbers (5+2i) 7 Inexact reals (#i3.14159265) > (4 5 6) eval: 4 is not a function > (+ 5 4) > #t 9 #t > (+ (* 5 4) 3) 23 > (+ 5/9 4/6) 1.2 > 5/9 0.5 372—Fall 2004—3 [9] 372—Fall 2004—3 [10] Numbers. Numbers. > (+ 5/9 8/18) Scheme tries to do arithmetic exactly, as much as 1 possible. > 5+2i Any computations that depend on an inexact value 5+2i becomes inexact. > (+ 5+2i 3-i) 8+1i Scheme has many builtin mathematical functions: > (* 236542164521634 3746573426573425643) 886222587860913289285513763860662 > (sqrt 16) > pi 4 #i3.141592653589793 > (sqrt 2) > e #i1.4142135623730951 #i2.718281828459045 > (sin 45) > (* 2 pi) #i0.8509035245341184 #i6.283185307179586 > (sin (/ pi 2)) #i1.0 372—Fall 2004—3 [11] 372—Fall 2004—3 [12] Identifiers Defining Variables Unlike languages like C and Java, Scheme allows define binds an expression to a global name: identifiers to contain special characters, such as (define name expression) ! $ % & * + - . / : < = > ? @ ˆ ˜ . Identifiers should not begin with a character that can > (define PI 3.14) begin a number. This is a consequence of Scheme’s simple syntax. > PI You couldn’t do this in Java because then there would 3.14 be many ways to interpret the expression X-5+Y. > (define High-School-PI (/ 22 7)) Legal Illegal > High-School-PI h-e-l-l-o 3some 3.142857 give-me! -stance WTF? 372—Fall 2004—3 [13] 372—Fall 2004—3 [14] Defining Functions Defining Helper Functions define binds an expression to a global name: A Scheme program consists of a large number of functions. (define (name arg1 arg2 ...) expression) One function typically is defined by calling other arg1 arg2 ... are formal function parameters. functions, so called helper or auxiliary functions. > (define (f) ’hello) > (define (square x) (* x x)) > (f) > (define (cube x) (* x (square x))) hello > (cube 3) > (define (square x) (* x x)) 27 > (square 3) 9 372—Fall 2004—3 [15] 372—Fall 2004—3 [16] References References. Free interpreter: http://www.drscheme.org. Language reference manual: Manual: http://www.swiss.ai.mit.edu/ftpdir/scheme-reports/r5rs.ps. http://www.swiss.ai.mit.edu/projects/scheme/documentation/scheme.html Some of this material is taken from Tutorials: http://www.ecf.utoronto.ca/˜gower/CSC326F/slides, c Diana Inkpen 2002, Suzanne Stevenson 2001. http://ai.uwaterloo.ca/˜dale/cs486/s99/scheme-tutorial.html http://cs.wwc.edu/%7Ecs_dept/KU/PR/Scheme.html http://www.cis.upenn.edu/%7Eungar/CIS520/scheme-tutorial.html http://dmoz.org/Computers/Programming/Languages/Lisp/Scheme 372—Fall 2004—3 [17] 372—Fall 2004—3 [18] History of the Lisp Language History of the Lisp Language. http://www.apl.jhu.edu/Ähall/text/Papers/Brief-History-of-Lisp.ps MacLisp improved on the Lisp 1.5 notion of special variables and error handling. The following information is derived from the history section of dpANS Common MacLisp also introduced theconcept of functions that could take a variable number Lisp. of arguments, macros, arrays, non-local dynamic exits, fast arithmetic, the first good Lisp compiler, and an emphasis on execution speed. Lisp is a family of languages with a long history. Early key ideas in Lisp were developed by John McCarthy during the 1956 Dartmouth Summer Research Interlisp introduced many ideas into Lisp programming environments and Project on Artificial Intelligence. McCarthy’s motivation was to develop analgebraic methodology. One of the Interlisp ideasthat influenced Common Lisp was an list processing language for artificial intelligence work. Implementation efforts for iteration construct implemented by Warren Teitelman that inspired the loop macro early dialects of Lisp were undertaken on the IBM 704, the IBM 7090, the Digital used both on the Lisp Machines and in MacLisp, and now in Common Lisp. Equipment Corporation (DEC) PDP-1, the DECPDP-6, and the PDP-10. The primary dialect of Lisp between 1960 and 1965 was Lisp 1.5. By the early 1970’s there were two predominant dialects of Lisp, both arising from these early efforts: MacLisp and Interlisp. Forfurther information about very early Lisp dialects, see The Anatomy of Lisp or Lisp 1.5 Programmer’s Manual. 372—Fall 2004—3 [19] 372—Fall 2004—3 [20] History of the Lisp Language. History of the Lisp Language. Although the first implementations of Lisp were on the IBM 704 and the IBM 7090, The Lisp machine concept was developed in the late 1960’s. In the early 1970’s, later work focussed on theDEC PDP-6 and, later, PDP-10 computers, the latter Peter Deutsch, working withDaniel Bobrow, implemented a Lisp on the Alto, a being the mainstay of Lisp and artificial intelligence work at such places as single-user minicomputer, using microcode to interpret a byte-code Massachusetts Institute of Technology (MIT), Stanford University, and Carnegie implementation language. Shortly thereafter, Richard Greenblatt began work on a Mellon University(CMU) from the mid-1960’s through much of the 1970’s. The different hardwareand instruction set design at MIT. Although the Alto was not a PDP-10 computer and its predecessor the PDP-6 computer were, by design, total success as a Lisp machine, a dialect of Interlisp known as Interlisp-D became especially well-suited to Lisp because they had 36-bit words and 18-bit addresses. available on the D-series machines manufactured by Xerox—the Thisarchitecture allowed a cons cell to be stored in one word; single instructions Dorado,Dandelion, Dandetiger, and Dove (or Daybreak). An upward-compatible could extract the car and cdr parts. The PDP-6 and PDP-10 had fast, powerful extension of MacLisp called Lisp Machine Lisp became available on the early MIT stack instructions that enabled fast function calling. But the limitations ofthe Lisp Machines. Commercial Lisp machines from Xerox, LispMachines (LMI), and PDP-10 were evident by 1973: it supported a small number of researchers using Symbolics were on the market by 1981. During the late 1970’s, Lisp Machine Lisp Lisp, and the small, 18-bit address space (262,144 36-bit words) limited the size of began to expand towards a much fuller language. Sophisticated lambdalists, setf, a single program. One response to the address spaceproblem was the Lisp multiple values, and structures like those in Common Lisp are the results of early Machine, a special-purpose computer designed to run Lisp programs. The other experimentation with programming styles by the Lisp Machine group. response was to use general-purpose computers with address spaces larger than 18 bits, such as the DEC VAX and the S-1 MarkIIA. 372—Fall 2004—3 [21] 372—Fall 2004—3 [22] History of the Lisp Language. History of the Lisp Language. Jonl White and others migrated these features to MacLisp. Around 1980, Scott Richard P. Gabriel began the design of a Lisp to run on the S-1 Mark IIA Fahlman and others at CMU began work on a Lisp to run on the Scientific supercomputer. S-1 Lisp, nevercompletely functional, was the test bed for Personal Integrated Computing Environment (SPICE) workstation. One of the adapting advanced compiler techniques to Lisp implementation. Eventually the goals of the project was to design a simpler dialect thanLisp Machine Lisp. S-1 and NIL groups collaborated. The Macsyma group at MIT began a project during the late 1970’s called the New The first effort towards Lisp standardization was made in 1969, when Anthony Implementation of Lisp (NIL)for the VAX, which was headed by White.
Load more

Recommended publications
  • How Lisp Systems Look Different in Proceedings of European Conference on Software Maintenance and Reengineering (CSMR 2008)
    How Lisp Systems Look Different In Proceedings of European Conference on Software Maintenance and Reengineering (CSMR 2008) Adrian Dozsa Tudor Gˆırba Radu Marinescu Politehnica University of Timis¸oara University of Berne Politehnica University of Timis¸oara Romania Switzerland Romania [email protected] [email protected] [email protected] Abstract rently used in a variety of domains, like bio-informatics (BioBike), data mining (PEPITe), knowledge-based en- Many reverse engineering approaches have been devel- gineering (Cycorp or Genworks), video games (Naughty oped to analyze software systems written in different lan- Dog), flight scheduling (ITA Software), natural language guages like C/C++ or Java. These approaches typically processing (SRI International), CAD (ICAD or OneSpace), rely on a meta-model, that is either specific for the language financial applications (American Express), web program- at hand or language independent (e.g. UML). However, one ming (Yahoo! Store or reddit.com), telecom (AT&T, British language that was hardly addressed is Lisp. While at first Telecom Labs or France Telecom R&D), electronic design sight it can be accommodated by current language inde- automation (AMD or American Microsystems) or planning pendent meta-models, Lisp has some unique features (e.g. systems (NASA’s Mars Pathfinder spacecraft mission) [16]. macros, CLOS entities) that are crucial for reverse engi- neering Lisp systems. In this paper we propose a suite of Why Lisp is Different. In spite of its almost fifty-year new visualizations that reveal the special traits of the Lisp history, and of the fact that other programming languages language and thus help in understanding complex Lisp sys- borrowed concepts from it, Lisp still presents some unique tems.
    [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]
  • 1960 1970 1980 1990 Japan California………………… UT IL in PA NJ NY Massachusetts………… Europe Lisp 1.5 TX
    Japan UT IL PA NY Massachusetts………… Europe California………………… TX IN NJ Lisp 1.5 1960 1970 1980 1990 Direct Relationships Lisp 1.5 LISP Family Graph Lisp 1.5 LISP 1.5 Family Lisp 1.5 Basic PDP-1 LISP M-460 LISP 7090 LISP 1.5 BBN PDP-1 LISP 7094 LISP 1.5 Stanford PDP-1 LISP SDS-940 LISP Q-32 LISP PDP-6 LISP LISP 2 MLISP MIT PDP-1 LISP Stanford LISP 1.6 Cambridge LISP Standard LISP UCI-LISP MacLisp Family PDP-6 LISP MacLisp Multics MacLisp CMU SAIL MacLisp MacLisp VLISP Franz Lisp Machine Lisp LISP S-1 Lisp NIL Spice Lisp Zetalisp IBM Lisp Family 7090 LISP 1.5 Lisp360 Lisp370 Interlisp Illinois SAIL MacLisp VM LISP Interlisp Family SDS-940 LISP BBN-LISP Interlisp 370 Spaghetti stacks Interlisp LOOPS Common LOOPS Lisp Machines Spice Lisp Machine Lisp Interlisp Lisp (MIT CONS) (Xerox (BBN Jericho) (PERQ) (MIT CADR) Alto, Dorado, (LMI Lambda) Dolphin, Dandelion) Lisp Zetalisp TAO (3600) (ELIS) Machine Lisp (TI Explorer) Common Lisp Family APL APL\360 ECL Interlisp ARPA S-1 Lisp Scheme Meeting Spice at SRI, Lisp April 1991 PSL KCL NIL CLTL1 Zetalisp X3J13 CLTL2 CLOS ISLISP X3J13 Scheme Extended Family COMIT Algol 60 SNOBOL METEOR CONVERT Simula 67 Planner LOGO DAISY, Muddle Scheme 311, Microplanner Scheme 84 Conniver PLASMA (actors) Scheme Revised Scheme T 2 CLTL1 Revised Scheme Revised2 Scheme 3 CScheme Revised Scheme MacScheme PC Scheme Chez Scheme IEEE Revised4 Scheme Scheme Object-Oriented Influence Simula 67 Smalltalk-71 LOGO Smalltalk-72 CLU PLASMA (actors) Flavors Common Objects LOOPS ObjectLisp CommonLOOPS EuLisp New Flavors CLTL2 CLOS Dylan X3J13 ISLISP Lambda Calculus Church, 1941 λ Influence Lisp 1.5 Landin (SECD, ISWIM) Evans (PAL) Reynolds (Definitional Interpreters) Lisp370 Scheme HOPE ML Standard ML Standard ML of New Jersey Haskell FORTRAN Influence FORTRAN FLPL Lisp 1.5 S-1 Lisp Lisp Machine Lisp CLTL1 Revised3 Zetalisp Scheme X3J13 CLTL2 IEEE Scheme X3J13 John McCarthy Lisp 1.5 Danny Bobrow Richard Gabriel Guy Steele Dave Moon Jon L White.
    [Show full text]
  • Writing a Best-Effort Portable Code Walker in Common Lisp
    Writing a best-effort portable code walker in Common Lisp Michael Raskin∗ LaBRI, University of Bordeaux [email protected] ABSTRACT ACM Reference format: One of the powerful features of the Lisp language family is Michael Raskin. 2017. Writing a best-effort portable code walker possibility to extend the language using macros. Some of in Common Lisp. In Proceedings of 10th European Lisp Simpo- sium, Vrije Universiteit Brussel, Belgium, April 2017 (ELS2017), possible extensions would benefit from a code walker, i.e. a 8 pages. library for processing code that keeps track of the status DOI: 10.5281/zenodo.3254669 of different part of code, for their implementation. But in practice code walking is generally avoided. In this paper, we study facilities useful to code walkers 1 INTRODUCTION provided by \Common Lisp: the Language" (2nd edition) and the Common Lisp standard. We will show that the Much of the power of Common Lisp comes from its extensibil- features described in the standard are not sufficient to write ity. Abstractions that cannot be expressed by functions can a fully portable code walker. still be expressed by macros; actually, many of the features One of the problems is related to a powerful but rarely described in the standard must be implemented as macros. discussed feature. The macrolet special form allows a macro Whilst macros are powerful on their own, some ways of function to pass information easily to other macro invocations extending Lisp would benefit from using higher-level code inside the lexical scope of the expansion. transformation abstractions. For many such abstractions the Another problem for code analysis is related to the usage of most natural way to implement them includes code walk- non-standard special forms in expansions of standard macros.
    [Show full text]
  • A Lisp Oriented Architecture by John W.F
    A Lisp Oriented Architecture by John W.F. McClain Submitted to the Department of Electrical Engineering and Computer Science in partial fulfillment of the requirements for the degrees of Master of Science in Electrical Engineering and Computer Science and Bachelor of Science in Electrical Engineering at the MASSACHUSETTS INSTITUTE OF TECHNOLOGY September 1994 © John W.F. McClain, 1994 The author hereby grants to MIT permission to reproduce and to distribute copies of this thesis document in whole or in part. Signature of Author ...... ;......................... .............. Department of Electrical Engineering and Computer Science August 5th, 1994 Certified by....... ......... ... ...... Th nas F. Knight Jr. Principal Research Scientist 1,,IA £ . Thesis Supervisor Accepted by ....................... 3Frederic R. Morgenthaler Chairman, Depattee, on Graduate Students J 'FROM e ;; "N MfLIT oARIES ..- A Lisp Oriented Architecture by John W.F. McClain Submitted to the Department of Electrical Engineering and Computer Science on August 5th, 1994, in partial fulfillment of the requirements for the degrees of Master of Science in Electrical Engineering and Computer Science and Bachelor of Science in Electrical Engineering Abstract In this thesis I describe LOOP, a new architecture for the efficient execution of pro- grams written in Lisp like languages. LOOP allows Lisp programs to run at high speed without sacrificing safety or ease of programming. LOOP is a 64 bit, long in- struction word architecture with support for generic arithmetic, 64 bit tagged IEEE floats, low cost fine grained read and write barriers, and fast traps. I make estimates for how much these Lisp specific features cost and how much they may speed up the execution of programs written in Lisp.
    [Show full text]
  • Common Lisp Ultraspec – a Project for Modern Common Lisp Documentation
    Common Lisp UltraSpec – A Project For Modern Common Lisp Documentation Michał „phoe” Herda #lisp-pl @ Freenode Jagiellonian University, Cracow, Poland Previously on European Lisp Symposium 2016 Yet Another Rant About The State Of Common Lisp Documentation Michał „phoe” Herda Presenting the European Lisp Symposium 2017 Exclusive: Yet Another Rant About The State Of Common Lisp Documentation, Part 2 Michał „phoe” Herda http://www.lispworks.com/documentation/HyperSpec/... http://www.sbcl.org/manual/... http://ccl.clozure.com/manual/... http://www.clisp.org/... http://bauhh.dyndns.org:8000/clim-spec/... http://bauhh.de/clxman/... http://metamodular.com/CLOS-MOP/... 50+(?) more websites with library-specific docs Fin, Part 2 (...except it’s not) A Possible Solution To The State Of Common Lisp Documentation, Part 2 Michał „phoe” Herda Parsing dpANS with RegEx Parsing HTML (context-free grammar) with RegEx (regular grammar): Parsing TeX (context-sensitive grammar) with RegEx (regular grammar): Parsing a known subset of TeX used in dpANS with RegEx (regular grammar): (with proper care) What’s done so far? ● Done ● All Dictionaries (e.g. MAPCAR, ADJOIN, …) ● Glossary ● Not done / TODO ● Concepts (e.g. 2.2 Reader Algorithm) ● Linking (esp. glossary entries) What’s done so far? ● Done ● All Dictionaries (e.g. MAPCAR, ADJOIN, …) ● Glossary ● Not done / TODO ● Concepts (e.g. 2.2 Reader Algorithm) ● Linking (esp. glossary entries) ● Review ● Diffs to the original dpANS ● Once it’s finished, SHIP IT! What am I aiming for? Editable Complete Downloadable
    [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]
  • Successful Lisp - Contents
    Successful Lisp - Contents Table of Contents ● About the Author ● About the Book ● Dedication ● Credits ● Copyright ● Acknowledgments ● Foreword ● Introduction 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 Appendix A ● Chapter 1 - Why Bother? Or: Objections Answered Chapter objective: Describe the most common objections to Lisp, and answer each with advice on state-of-the-art implementations and previews of what this book will explain. ❍ I looked at Lisp before, and didn't understand it. ❍ I can't see the program for the parentheses. ❍ Lisp is very slow compared to my favorite language. ❍ No one else writes programs in Lisp. ❍ Lisp doesn't let me use graphical interfaces. ❍ I can't call other people's code from Lisp. ❍ Lisp's garbage collector causes unpredictable pauses when my program runs. ❍ Lisp is a huge language. ❍ Lisp is only for artificial intelligence research. ❍ Lisp doesn't have any good programming tools. ❍ Lisp uses too much memory. ❍ Lisp uses too much disk space. ❍ I can't find a good Lisp compiler. ● Chapter 2 - Is this Book for Me? Chapter objective: Describe how this book will benefit the reader, with specific examples and references to chapter contents. ❍ The Professional Programmer http://psg.com/~dlamkins/sl/contents.html (1 of 13)11/3/2006 5:46:04 PM Successful Lisp - Contents ❍ The Student ❍ The Hobbyist ❍ The Former Lisp Acquaintance ❍ The Curious ● Chapter 3 - Essential Lisp in Twelve Lessons Chapter objective: Explain Lisp in its simplest form, without worrying about the special cases that can confuse beginners.
    [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]
  • 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]
  • History of the Lisp Language
    History of the Lisp Language History of the Lisp Language The following information is derived from the history section of dpANS Common Lisp. Lisp is a family of languages with a long history. Early key ideas in Lisp were developed by John McCarthy during the 1956 Dartmouth Summer Research Project on Artificial Intelligence. McCarthy’s motivation was to develop an algebraic list processing language for artificial intelligence work. Implementation efforts for early dialects of Lisp were undertaken on the IBM 704, the IBM 7090, the Digital Equipment Corporation (DEC) PDP−1, the DEC PDP−6, and the PDP−10. The primary dialect of Lisp between 1960 and 1965 was Lisp 1.5. By the early 1970’s there were two predominant dialects of Lisp, both arising from these early efforts: MacLisp and Interlisp. For further information about very early Lisp dialects, see The Anatomy of Lisp or Lisp 1.5 Programmer’s Manual. MacLisp improved on the Lisp 1.5 notion of special variables and error handling. MacLisp also introduced the concept of functions that could take a variable number of arguments, macros, arrays, non−local dynamic exits, fast arithmetic, the first good Lisp compiler, and an emphasis on execution speed. For further information about Maclisp, see Maclisp Reference Manual, Revision 0 or The Revised Maclisp Manual. Interlisp introduced many ideas into Lisp programming environments and methodology. One of the Interlisp ideas that influenced Common Lisp was an iteration construct implemented by Warren Teitelman that inspired the loop macro used both on the Lisp Machines and in MacLisp, and now in Common Lisp.
    [Show full text]