DOCSLIB.ORG

L02: Symbolic Computation and Common Lisp (Pre Lecture)

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
L02: Symbolic Computation and Common Lisp (Pre Lecture) L02: Symbolic Computation and Common Lisp (Pre Lecture) Dr. Neil T. Dantam CSCI-561, Colorado School of Mines Fall 2021 Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 1 / 58 Kay on Lisp https://youtu.be/pUoBSC3uoeo?t=40m49s Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 2 / 58 “Maxwell’s Equations of Programming” Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 3 / 58 What is Lisp? Definition (Lisp) A family of programming languages based on s-expressions. Data Structure “Math” NIL n defun factorial NIL n 1 if = 0 != n n n n ( ∗ ( − 1)! if =6 0 1 NIL if 0 NIL Code = n ( defun f a c t ( n ) NIL ( i f (= n 0) n * NIL 1 (∗ n ( f a c t (− n 1 ) ) ) ) ) factorial 1 NIL - n Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 4 / 58 Code is Data “Homoiconic” Code Data Structure NIL ( defun f a c t ( n ) defun factorial NIL ( i f (= n 0) n 1 (∗ n ( f a c t (− n 1 ) ) ) ) ) 1 NIL if 0 NIL = n NIL n * NIL factorial 1 NIL - n “data processing” ⇐⇒ “code processing” Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 5 / 58 Introduction Why study Lisp? Outcomes ◮ Different way of thinking about programming ◮ Understand s-expressions ◮ Functional Programming: mathematical ◮ Understand lisp programming functions w/o (explicit) state change operators ◮ Language theory algorithms and proofs often are functional/recursive/inductive ◮ Lisp has good support for functional programming ◮ Symbolic Computing: manipulating expressions of mathematical functions ◮ Symbolic expressions in language theory ◮ Lisp has good support for symbolic processing Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 6 / 58 The Lisp Learning Process Yee-haw! start “Lisp is weird!” “I dislike Learn to think differences!” give symbolically? not yet up yes end “Lisp is awesome!” end Lisp might feel like it’s “from outer space” (at first). The symbolic view of programming is different, often useful. Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 7 / 58 Outline Symbolic Computing Rewrite Systems Implementing Expressions List Manipulation Lisp Programming Overview Implementation Details Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 8 / 58 Symbolic Computing Outline Symbolic Computing Rewrite Systems Implementing Expressions List Manipulation Lisp Programming Overview Implementation Details Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 9 / 58 Symbolic Computing Rewrite Systems Rewrite Systems Definition (Rewrite System) A well defined method for mathematical reasoning employing axioms and rules of inference or transformation. A formal system or calculus. Example (Expressions) Example (Reductions) ◮ Algebraic Equations: ◮ Distributive Properties: 2 3 ◮ a0x + a1x + a3x ◮ x ∗ (y + z) xy + xz ◮ 3x + 1 = 10 ◮ ◮ Propositional Logic: α ∨ (β ∧ γ) (α ∨ β) ∧ (α ∨ γ) ◮ ◮ (p1 ∨ p2) ∧ p3 De Morgan’s Laws: ◮ (p1 ∧ p2) =⇒ p3 ◮ ¬(α ∧ β) (¬α ∨¬β) ◮ ¬(α ∨ β) (¬α ∧¬β) Progressively apply reductions until reaching desired expression. Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 10 / 58 Symbolic Computing Rewrite Systems Example: Algebra Given: 3x + 1 = 10 Find: x Solution: Initial 3x + 1 = 10 −1 3x + 1 − 1 = 10 − 1 Simplify 3x = 9 /3 3x/3 = 9/3 Simplify x = 3 How would you write a program to solve for x? Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 11 / 58 Symbolic Computing Implementing Expressions The Cons Cell Declaration Example s t r u c t cons { S-Expression void ∗ f i r s t ; s t r u c t cons ∗ r e s t ; (1 2 3) }; Cons Cell Diagram Diagram CAR / CDR / 1 2 3 NIL first rest Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 12 / 58 Symbolic Computing Implementing Expressions Example: Nested Lists nested nested (a (b c) (d e)) a b c d e ( z( }| {) z( }| {)) a NIL d e NIL (a (b c) c NIL (d e)) b Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 13 / 58 Symbolic Computing Implementing Expressions Exercise 1: Nested Lists (a (b c) d e) (a b c ((d) e)) Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 14 / 58 Symbolic Computing Implementing Expressions Abstract Syntax Concrete / Infix Abstract Syntax Tree S-Expression ◮ Function / Operator ◮ Root: ◮ First: Root, Function / Operator Function / Operator ◮ Arguments / Operands ◮ Children: ◮ Rest: Children, Arguments / Operands Arguments / Operands f (x0,..., xn) f (f x0 ... xn) x0 ... xn a + b + (+ a b) a b Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 15 / 58 Symbolic Computing Implementing Expressions Example: S-Expression Infix Expression Abstract Syntax Tree S-expression 3x + 1 = 10 = (= (+ (* 3 x) 1) 10) + 10 * 1 (= (+ (* 3 x) 1) 10) 3 x Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 16 / 58 Symbolic Computing Implementing Expressions Example: Cell Diagram S-Expression (= (+ (* 3 x) 1) 10) Cell Diagram 10 NIL = 1 NIL + 3 NIL * x Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 17 / 58 Symbolic Computing Implementing Expressions List vs. Tree List Tree s t r u c t cons { s t r u c t t r e e n o d e { void ∗ f i r s t ; void ∗ f i r s t ; s t r u c t cons ∗ r e s t ; s t r u c t cons ∗ c h i l d r e n ; }; }; s t r u c t cons { void ∗ f i r s t ; s t r u c t cons ∗ r e s t ; }; Same structure Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 18 / 58 Symbolic Computing Implementing Expressions Data Structure, Redux 3x + 1 = 10 Cons Cells Tree = = 10 NIL + 10 + 1 NIL * 1 * 3 x 3 NIL x Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 19 / 58 Symbolic Computing Implementing Expressions Exercise 2.a: S-Expression 2(x-1) = 4 2(x − 1)= 4 Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 20 / 58 Symbolic Computing Implementing Expressions Exercise 2.b: S-Expression a ∧ (b ∨ x) ∧ (c ∨¬x) a ∧ (b ∨ x) ∧ (c ∨¬x) Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 21 / 58 Symbolic Computing Implementing Expressions Exercise 2.c: S-Expression a ∧ (b ∨ x) ∧ (c ∨¬x) – continued Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 22 / 58 Symbolic Computing Implementing Expressions Hey! That’s a lot of irritating, silly parenthesis! Lisp Syntax Python Syntax (= (+ (∗ 3 x ) [ ’=’ ,[ ’+’ ,[ ’ ∗ ’ , 3 , ’ x ’ ] 1) 1 ] , 10) 10] The point is the data structure for code: process code like any other data! Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 23 / 58 Symbolic Computing Implementing Expressions Evaluation and Quoting Evaluation Quoting Evaluating (executing) an Returns the quoted s-expression: expression and yielding its return value: ’(fun abc) The s-expression: (fun abc) (fun abc) return value of fun applied to a, b, and c Example Example ◮ ’(+ 1 2) (+ 1 2) ◮ (+ 1 2) 3 ◮ ’1 1 ◮ 1 1 ◮ ’x x ◮ (quote x) x Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 24 / 58 Symbolic Computing List Manipulation Dotted List Notation ’(x . y) x y ’(x y) NIL x y ’(x . (y z)) NIL x y z ’(x (y z)) NIL x NIL y z Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 25 / 58 Symbolic Computing List Manipulation CONStruct Creating Lists CONS Contruct a new cons cell: (cons x y) a fresh cons cell with x in the car (first) and y in the cdr (rest) (cons α β) (α . β) α β (cons 1 NIL) (1 . nil) (1) 1 NIL (cons 2 (cons 1 NIL)) (2 . (1 . nil)) (2 1) 2 1 NIL Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 26 / 58 Symbolic Computing List Manipulation List Function LIST Return a list containing the supplied objects: (list a0 ... an) a list containing objects a0,..., an (list) NIL (list α) (cons α NIL) α NIL (list α β) (cons α (list β)) α β NIL (list αβγ) (cons α (list β γ)) α β γ NIL Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 27 / 58 Symbolic Computing List Manipulation Exercise 3: List Construction ◮ (cons ’x ’y) ◮ (cons ’x ’(y z)) ◮ (cons ’x (list ’y ’z)) ◮ (list (+ 1 2 3)) ◮ (list ’(+ 1 2 3)) ◮ (list ’∗ (+ 2 2) ’(− 2 2)) Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 28 / 58 Symbolic Computing List Manipulation List Access CAR / CDR Cons cell CAR CDR CAR CDR Return the car of a cons cell: Return the cdr of a cons cell: (car cell) (cdr cell) the car (first) of cell the cdr (rest) of cell (car ’(α . β)) α (cdr ’(α . β)) β Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 29 / 58 Symbolic Computing List Manipulation Example: CAR / CDR (car ’(x . y)) x (cdr ’(x . y)) y (car ’(xyz)) x (cdr ’(xyz)) NIL y z Dantam (Mines CSCI-561) L02: Symbolic Computation and Common Lisp (Pre Lecture) Fall 2021 30 / 58 Symbolic Computing List Manipulation List Template Syntax Backquote (‘): Create a template ◮ ‘(x0 ..
Load more

Recommended publications
  • Introduction to Programming in Lisp
    Introduction to Programming in Lisp Supplementary handout for 4th Year AI lectures · D W Murray · Hilary 1991 1 Background There are two widely used languages for AI, viz. Lisp and Prolog. The latter is the language for Logic Programming, but much of the remainder of the work is programmed in Lisp. Lisp is the general language for AI because it allows us to manipulate symbols and ideas in a commonsense manner. Lisp is an acronym for List Processing, a reference to the basic syntax of the language and aim of the language. The earliest list processing language was in fact IPL developed in the mid 1950’s by Simon, Newell and Shaw. Lisp itself was conceived by John McCarthy and students in the late 1950’s for use in the newly-named field of artificial intelligence. It caught on quickly in MIT’s AI Project, was implemented on the IBM 704 and by 1962 to spread through other AI groups. AI is still the largest application area for the language, but the removal of many of the flaws of early versions of the language have resulted in its gaining somewhat wider acceptance. One snag with Lisp is that although it started out as a very pure language based on mathematic logic, practical pressures mean that it has grown. There were many dialects which threaten the unity of the language, but recently there was a concerted effort to develop a more standard Lisp, viz. Common Lisp. Other Lisps you may hear of are FranzLisp, MacLisp, InterLisp, Cambridge Lisp, Le Lisp, ... Some good things about Lisp are: • Lisp is an early example of an interpreted language (though it can be compiled).
    [Show full text]
  • An Implementation of Python for Racket
    An Implementation of Python for Racket Pedro Palma Ramos António Menezes Leitão INESC-ID, Instituto Superior Técnico, INESC-ID, Instituto Superior Técnico, Universidade de Lisboa Universidade de Lisboa Rua Alves Redol 9 Rua Alves Redol 9 Lisboa, Portugal Lisboa, Portugal [email protected] [email protected] ABSTRACT Keywords Racket is a descendent of Scheme that is widely used as a Python; Racket; Language implementations; Compilers first language for teaching computer science. To this end, Racket provides DrRacket, a simple but pedagogic IDE. On the other hand, Python is becoming increasingly popular 1. INTRODUCTION in a variety of areas, most notably among novice program- The Racket programming language is a descendent of Scheme, mers. This paper presents an implementation of Python a language that is well-known for its use in introductory for Racket which allows programmers to use DrRacket with programming courses. Racket comes with DrRacket, a ped- Python code, as well as adding Python support for other Dr- agogic IDE [2], used in many schools around the world, as Racket based tools. Our implementation also allows Racket it provides a simple and straightforward interface aimed at programs to take advantage of Python libraries, thus signif- inexperienced programmers. Racket provides different lan- icantly enlarging the number of usable libraries in Racket. guage levels, each one supporting more advanced features, that are used in different phases of the courses, allowing Our proposed solution involves compiling Python code into students to benefit from a smoother learning curve. Fur- semantically equivalent Racket source code. For the run- thermore, Racket and DrRacket support the development of time implementation, we present two different strategies: additional programming languages [13].
    [Show full text]
  • The Machine That Builds Itself: How the Strengths of Lisp Family
    Khomtchouk et al. OPINION NOTE The Machine that Builds Itself: How the Strengths of Lisp Family Languages Facilitate Building Complex and Flexible Bioinformatic Models Bohdan B. Khomtchouk1*, Edmund Weitz2 and Claes Wahlestedt1 *Correspondence: [email protected] Abstract 1Center for Therapeutic Innovation and Department of We address the need for expanding the presence of the Lisp family of Psychiatry and Behavioral programming languages in bioinformatics and computational biology research. Sciences, University of Miami Languages of this family, like Common Lisp, Scheme, or Clojure, facilitate the Miller School of Medicine, 1120 NW 14th ST, Miami, FL, USA creation of powerful and flexible software models that are required for complex 33136 and rapidly evolving domains like biology. We will point out several important key Full list of author information is features that distinguish languages of the Lisp family from other programming available at the end of the article languages and we will explain how these features can aid researchers in becoming more productive and creating better code. We will also show how these features make these languages ideal tools for artificial intelligence and machine learning applications. We will specifically stress the advantages of domain-specific languages (DSL): languages which are specialized to a particular area and thus not only facilitate easier research problem formulation, but also aid in the establishment of standards and best programming practices as applied to the specific research field at hand. DSLs are particularly easy to build in Common Lisp, the most comprehensive Lisp dialect, which is commonly referred to as the “programmable programming language.” We are convinced that Lisp grants programmers unprecedented power to build increasingly sophisticated artificial intelligence systems that may ultimately transform machine learning and AI research in bioinformatics and computational biology.
    [Show full text]
  • 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]
  • IDE User Guide Version 7.1 Copyright and Trademarks Lispworks IDE User Guide (Unix Version) Version 7.1 September 2017 Copyright © 2017 by Lispworks Ltd
    LispWorks® IDE User Guide Version 7.1 Copyright and Trademarks LispWorks IDE User Guide (Unix version) Version 7.1 September 2017 Copyright © 2017 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]
  • Omnipresent and Low-Overhead Application Debugging
    Omnipresent and low-overhead application debugging Robert Strandh [email protected] LaBRI, University of Bordeaux Talence, France ABSTRACT application programmers as opposed to system programmers. The state of the art in application debugging in free Common The difference, in the context of this paper, is that the tech- Lisp implementations leaves much to be desired. In many niques that we suggest are not adapted to debugging the cases, only a backtrace inspector is provided, allowing the system itself, such as the compiler. Instead, throughout this application programmer to examine the control stack when paper, we assume that, as far as the application programmer an unhandled error is signaled. Most such implementations do is concerned, the semantics of the code generated by the not allow the programmer to set breakpoints (unconditional compiler corresponds to that of the source code. or conditional), nor to step the program after it has stopped. In this paper, we are mainly concerned with Common Furthermore, even debugging tools such as tracing or man- Lisp [1] implementations distributed as so-called FLOSS, i.e., ually calling break are typically very limited in that they do \Free, Libre, and Open Source Software". While some such not allow the programmer to trace or break in important sys- implementations are excellent in terms of the quality of the tem functions such as make-instance or shared-initialize, code that the compiler generates, most leave much to be simply because these tools impact all callers, including those desired when it comes to debugging tools available to the of the system itself, such as the compiler.
    [Show full text]
  • Praise for Practical Common Lisp
    Praise for Practical Common Lisp “Finally, a Lisp book for the rest of us. If you want to learn how to write a factorial function, this is not your book. Seibel writes for the practical programmer, emphasizing the engineer/artist over the scientist and subtly and gracefully implying the power of the language while solving understandable real-world problems. “In most chapters, the reading of the chapter feels just like the experience of writing a program, starting with a little understanding and then having that understanding grow, like building the shoulders upon which you can then stand. When Seibel introduced macros as an aside while building a test frame- work, I was shocked at how such a simple example made me really ‘get’ them. Narrative context is extremely powerful, and the technical books that use it are a cut above. Congrats!” —Keith Irwin, Lisp programmer “While learning Lisp, one is often referred to the CL HyperSpec if they do not know what a particular function does; however, I found that I often did not ‘get it’ just by reading the HyperSpec. When I had a problem of this manner, I turned to Practical Common Lisp every single time—it is by far the most readable source on the subject that shows you how to program, not just tells you.” —Philip Haddad, Lisp programmer “With the IT world evolving at an ever-increasing pace, professionals need the most powerful tools available. This is why Common Lisp—the most powerful, flexible, and stable programming language ever—is seeing such a rise in popu- larity.
    [Show full text]
  • PUB DAM Oct 67 CONTRACT N00014-83-6-0148; N00014-83-K-0655 NOTE 63P
    DOCUMENT RESUME ED 290 438 IR 012 986 AUTHOR Cunningham, Robert E.; And Others TITLE Chips: A Tool for Developing Software Interfaces Interactively. INSTITUTION Pittsburgh Univ., Pa. Learning Research and Development Center. SPANS AGENCY Office of Naval Research, Arlington, Va. REPORT NO TR-LEP-4 PUB DAM Oct 67 CONTRACT N00014-83-6-0148; N00014-83-K-0655 NOTE 63p. PUB TYPE Reports - Research/Technical (143) EDRS PRICE MF01/PC03 Plus Postage. DESCRIPTORS *Computer Graphics; *Man Machine Systems; Menu Driven Software; Programing; *Programing Languages IDENTIF7ERS Direct Manipulation Interface' Interface Design Theory; *Learning Research and Development Center; LISP Programing Language; Object Oriented Programing ABSTRACT This report provides a detailed description of Chips, an interactive tool for developing software employing graphical/computer interfaces on Xerox Lisp machines. It is noted that Chips, which is implemented as a collection of customizable classes, provides the programmer with a rich graphical interface for the creation of rich graphical interfaces, and the end-user with classes for modeling the graphical relationships of objects on the screen and maintaining constraints between them. This description of the system is divided into five main sections: () the introduction, which provides background material and a general description of the system; (2) a brief overview of the report; (3) detailed explanations of the major features of Chips;(4) an in-depth discussion of the interactive aspects of the Chips development environment; and (5) an example session using Chips to develop and modify a small portion of an interface. Appended materials include descriptions of four programming techniques that have been sound useful in the development of Chips; descriptions of several systems developed at the Learning Research and Development Centel tsing Chips; and a glossary of key terms used in the report.
    [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]
  • Common Lisp - Viel Mehr Als Nur D¨Amliche Klammern
    Einf¨uhrung Geschichtliches Die Programmiersprache Abschluß Common Lisp - viel mehr als nur d¨amliche Klammern Alexander Schreiber <[email protected]> http://www.thangorodrim.de Chemnitzer Linux-Tage 2005 Greenspun’s Tenth Rule of Programming: “Any sufficiently-complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden slow implementation of half of Common Lisp.” Alexander Schreiber <[email protected]> Common Lisp - viel mehr als nur d¨amliche Klammern 1 / 30 Einf¨uhrung Geschichtliches Die Programmiersprache Abschluß Ubersicht¨ 1 Einf¨uhrung 2 Geschichtliches 3 Die Programmiersprache 4 Abschluß Alexander Schreiber <[email protected]> Common Lisp - viel mehr als nur d¨amliche Klammern 2 / 30 Einf¨uhrung Geschichtliches Die Programmiersprache Abschluß Lisp? Wof¨ur? NASA: Remote Agent (Deep Space 1), Planner (Mars Pathfinder), Viaweb, gekauft von Yahoo f¨ur50 Millionen $, ITA Software: Orbitz engine (Flugticket Planung), Square USA: Production tracking f¨ur“Final Fantasy”, Naughty Dog Software: Crash Bandicoot auf Sony Playstation, AMD & AMI: Chip-Design & Verifizierung, typischerweise komplexe Probleme: Wissensverarbeitung, Expertensysteme, Planungssysteme Alexander Schreiber <[email protected]> Common Lisp - viel mehr als nur d¨amliche Klammern 3 / 30 Einf¨uhrung Geschichtliches Die Programmiersprache Abschluß Lisp? Wof¨ur? NASA: Remote Agent (Deep Space 1), Planner (Mars Pathfinder), Viaweb, gekauft von Yahoo f¨ur50 Millionen $, ITA Software: Orbitz engine (Flugticket Planung), Square USA: Production tracking
    [Show full text]
  • Knowledge Based Engineering: Between AI and CAD
    Advanced Engineering Informatics 26 (2012) 159–179 Contents lists available at SciVerse ScienceDirect Advanced Engineering Informatics journal homepage: www.elsevier.com/locate/aei Knowledge based engineering: Between AI and CAD. Review of a language based technology to support engineering design ⇑ Gianfranco La Rocca Faculty of Aerospace Engineering, Delft University of Technology, Chair of Flight Performance and Propulsion, Kluyverweg 1, 2629HS Delft, The Netherlands article info abstract Article history: Knowledge based engineering (KBE) is a relatively young technology with an enormous potential for Available online 16 March 2012 engineering design applications. Unfortunately the amount of dedicated literature available to date is quite low and dispersed. This has not promoted the diffusion of KBE in the world of industry and acade- Keywords: mia, neither has it contributed to enhancing the level of understanding of its technological fundamentals. Knowledge based engineering The scope of this paper is to offer a broad technological review of KBE in the attempt to fill the current Knowledge engineering information gap. The artificial intelligence roots of KBE are briefly discussed and the main differences and Engineering design similarities with respect to classical knowledge based systems and modern general purpose CAD systems Generative design highlighted. The programming approach, which is a distinctive aspect of state-of-the-art KBE systems, is Knowledge based design Rule based design discussed in detail, to illustrate its effectiveness in capturing and re-using engineering knowledge to automate large portions of the design process. The evolution and trends of KBE systems are investigated and, to conclude, a list of recommendations and expectations for the KBE systems of the future is provided.
    [Show full text]
  • Proceedings of the 8Th European Lisp Symposium Goldsmiths, University of London, April 20-21, 2015 Julian Padget (Ed.) Sponsors
    Proceedings of the 8th European Lisp Symposium Goldsmiths, University of London, April 20-21, 2015 Julian Padget (ed.) Sponsors We gratefully acknowledge the support given to the 8th European Lisp Symposium by the following sponsors: WWWLISPWORKSCOM i Organization Programme Committee Julian Padget – University of Bath, UK (chair) Giuseppe Attardi — University of Pisa, Italy Sacha Chua — Toronto, Canada Stephen Eglen — University of Cambridge, UK Marc Feeley — University of Montreal, Canada Matthew Flatt — University of Utah, USA Rainer Joswig — Hamburg, Germany Nick Levine — RavenPack, Spain Henry Lieberman — MIT, USA Christian Queinnec — University Pierre et Marie Curie, Paris 6, France Robert Strandh — University of Bordeaux, France Edmund Weitz — University of Applied Sciences, Hamburg, Germany Local Organization Christophe Rhodes – Goldsmiths, University of London, UK (chair) Richard Lewis – Goldsmiths, University of London, UK Shivi Hotwani – Goldsmiths, University of London, UK Didier Verna – EPITA Research and Development Laboratory, France ii Contents Acknowledgments i Messages from the chairs v Invited contributions Quicklisp: On Beyond Beta 2 Zach Beane µKanren: Running the Little Things Backwards 3 Bodil Stokke Escaping the Heap 4 Ahmon Dancy Unwanted Memory Retention 5 Martin Cracauer Peer-reviewed papers Efficient Applicative Programming Environments for Computer Vision Applications 7 Benjamin Seppke and Leonie Dreschler-Fischer Keyboard? How quaint. Visual Dataflow Implemented in Lisp 15 Donald Fisk P2R: Implementation of
    [Show full text]