Jatha. Common Lisp in Java. Ola Bini JRuby Core Developer ThoughtWorks Studios.
|
|
|
- Rudolf Long
- 5 years ago
- Views:
Transcription
1 Jatha Common Lisp in Java Ola Bini JRuby Core Developer ThoughtWorks Studios
2 Common Lisp?
3 Common Lisp? ANSI standard
4 Common Lisp? ANSI standard Powerful
5 Common Lisp? ANSI standard Powerful Multiparadigm
6 Common Lisp? ANSI standard Powerful Multiparadigm Procedural
7 Common Lisp? ANSI standard Powerful Multiparadigm Procedural Functional
8 Common Lisp? ANSI standard Powerful Multiparadigm Procedural Functional Object oriented
9 Common Lisp? ANSI standard Powerful Multiparadigm Procedural Functional Object oriented Dynamic and lexical scope
10 Common Lisp? ANSI standard Powerful Multiparadigm Procedural Functional Object oriented Dynamic and lexical scope CLOS: multimethods, method combinations
11 Common Lisp? ANSI standard Powerful Multiparadigm Procedural Functional Object oriented Dynamic and lexical scope CLOS: multimethods, method combinations Macros and reader macros
12 Jatha history
13 Jatha history 1991: In C++
14 Jatha history 1991: In C : Need for GC => Java port
15 Jatha history 1991: In C : Need for GC => Java port 1997: Large subset of CL implemented
16 Jatha history 1991: In C : Need for GC => Java port 1997: Large subset of CL implemented 2002: Was used to port the Algernon rules engine
17 Jatha history 1991: In C : Need for GC => Java port 1997: Large subset of CL implemented 2002: Was used to port the Algernon rules engine 2003: Released as open source
18 Jatha history 1991: In C : Need for GC => Java port 1997: Large subset of CL implemented 2002: Was used to port the Algernon rules engine 2003: Released as open source 2005: Support for macros
19 Jatha history 1991: In C : Need for GC => Java port 1997: Large subset of CL implemented 2002: Was used to port the Algernon rules engine 2003: Released as open source 2005: Support for macros
20 Jatha architecture
21 Jatha architecture Simple, handwritten parser
22 Jatha architecture Simple, handwritten parser No reader macros
23 Jatha architecture Simple, handwritten parser No reader macros Extensible compiler
24 Jatha architecture Simple, handwritten parser No reader macros Extensible compiler Every primitive is a class that executes itself
25 Jatha architecture Simple, handwritten parser No reader macros Extensible compiler Every primitive is a class that executes itself Compiler outputs Lisp values in SECD format
26 Jatha architecture Simple, handwritten parser No reader macros Extensible compiler Every primitive is a class that executes itself Compiler outputs Lisp values in SECD format SECD Machine
27 Jatha architecture Simple, handwritten parser No reader macros Extensible compiler Every primitive is a class that executes itself Compiler outputs Lisp values in SECD format SECD Machine With some extensions to handle CL weirdness
28 Jatha architecture Simple, handwritten parser No reader macros Extensible compiler Every primitive is a class that executes itself Compiler outputs Lisp values in SECD format SECD Machine With some extensions to handle CL weirdness Lisp values all implement gigantic interface with available methods
29 SECD
30 SECD Functional programming language structure
31 SECD Functional programming language structure Peter Landin
32 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation
33 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation Peter Kogge: The Architecture of Symbolic Machines
34 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation Peter Kogge: The Architecture of Symbolic Machines Stack, Environment, Code, Dump
35 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation Peter Kogge: The Architecture of Symbolic Machines Stack, Environment, Code, Dump S is the stack, not used for instruction parameters
36 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation Peter Kogge: The Architecture of Symbolic Machines Stack, Environment, Code, Dump S is the stack, not used for instruction parameters C is the instruction pointer
37 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation Peter Kogge: The Architecture of Symbolic Machines Stack, Environment, Code, Dump S is the stack, not used for instruction parameters C is the instruction pointer E is a list of lists of the environment
38 SECD Functional programming language structure Peter Landin Peter Henderson: Functional Programming: Application and implementation Peter Kogge: The Architecture of Symbolic Machines Stack, Environment, Code, Dump S is the stack, not used for instruction parameters C is the instruction pointer E is a list of lists of the environment D is temporary storage for other registers, return stack
39 SECD instructions
40 SECD instructions NIL: push a nil pointer on the stack
41 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack
42 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack
43 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal
44 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal SEL: takes two list arguments, sets C to one of them based on S
45 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal SEL: takes two list arguments, sets C to one of them based on S the next C is put in D until finished
46 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal SEL: takes two list arguments, sets C to one of them based on S the next C is put in D until finished JOIN: ends a SEL, returning a value from D to C
47 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal SEL: takes two list arguments, sets C to one of them based on S the next C is put in D until finished JOIN: ends a SEL, returning a value from D to C LDF: takes a function argument and constructs a closure
48 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal SEL: takes two list arguments, sets C to one of them based on S the next C is put in D until finished JOIN: ends a SEL, returning a value from D to C LDF: takes a function argument and constructs a closure AP: pops a closure and parameters and applies it
49 SECD instructions NIL: push a nil pointer on the stack LDC: load a constant argument on the stack LD: load a variable value on the stack parameter to LD looks like this: (2. 3), 2 is depth, 3 is ordinal SEL: takes two list arguments, sets C to one of them based on S the next C is put in D until finished JOIN: ends a SEL, returning a value from D to C LDF: takes a function argument and constructs a closure AP: pops a closure and parameters and applies it will save S E C on D and replace them to run the code
50 SECD instructions cntd
51 SECD instructions cntd RET: Pops a return value, restores S E C and push return value
52 SECD instructions cntd RET: Pops a return value, restores S E C and push return value DUM: Pushes a dummy value on environment
53 SECD instructions cntd RET: Pops a return value, restores S E C and push return value DUM: Pushes a dummy value on environment RAP: Recursive apply, like AP
54 SECD instructions cntd RET: Pops a return value, restores S E C and push return value DUM: Pushes a dummy value on environment RAP: Recursive apply, like AP Uses a dummy value to replace environment, for recursive call
55 Jatha SECD extensions
56 Jatha SECD extensions B register: for dynamic bindings
57 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information
58 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms
59 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms LD_GLOBAL op: load a global value, handling dynamic bindings
60 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms LD_GLOBAL op: load a global value, handling dynamic bindings LDCF op: load function from a symbol slot instead of C
61 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms LD_GLOBAL op: load a global value, handling dynamic bindings LDCF op: load function from a symbol slot instead of C LDR op: load &REST arguments
62 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms LD_GLOBAL op: load a global value, handling dynamic bindings LDCF op: load function from a symbol slot instead of C LDR op: load &REST arguments LIS op: handle optional arguments
63 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms LD_GLOBAL op: load a global value, handling dynamic bindings LDCF op: load function from a symbol slot instead of C LDR op: load &REST arguments LIS op: handle optional arguments RTN_IF, RTN_IT ops: conditional return, used for AND, OR
64 Jatha SECD extensions B register: for dynamic bindings X register: like D, for dumping tag information BLK op: handles non-local exit forms LD_GLOBAL op: load a global value, handling dynamic bindings LDCF op: load function from a symbol slot instead of C LDR op: load &REST arguments LIS op: handle optional arguments RTN_IF, RTN_IT ops: conditional return, used for AND, OR SP_BIND, SP_UNBIND ops: binds/unbinds special variables
65 Jatha SECD extensions cntd
66 Jatha SECD extensions cntd T op: pushes T on stack
67 Jatha SECD extensions cntd T op: pushes T on stack TAG_B op: used to implement TAGBODY, pushes tag info to X
68 Jatha SECD extensions cntd T op: pushes T on stack TAG_B op: used to implement TAGBODY, pushes tag info to X TAG_E op: end of TAGBODY, pops X
69 Jatha SECD extensions cntd T op: pushes T on stack TAG_B op: used to implement TAGBODY, pushes tag info to X TAG_E op: end of TAGBODY, pops X
70 Jatha parser
71 Jatha parser Lisp is easy to parse, right?
72 Jatha parser Lisp is easy to parse, right? Well, not that easy...
73 Jatha parser Lisp is easy to parse, right? Well, not that easy... Case sensitivity
74 Jatha parser Lisp is easy to parse, right? Well, not that easy... Case sensitivity Lists (and dotted pairs) Strings (including escapes) Characters Symbols Mixed case symbols (including escapes) Quotes (single, back, splice) Numbers Packages Keywords Reader macros (not fully implemented, though)
75 Jatha parser Lisp is easy to parse, right? Well, not that easy... Case sensitivity Lists (and dotted pairs) Strings (including escapes) Characters Symbols Mixed case symbols (including escapes) Quotes (single, back, splice) Numbers Packages Keywords Reader macros (not fully implemented, though)
76 Compiler
77 Compiler Lisp expression => Lisp expression of op codes
78 Compiler Lisp expression => Lisp expression of op codes &REST AND DEFMACRO DEFUN IF LAMBDA LET LETREC MACRO OR PROGN PRIMITIVE QUOTE SETQ
79 Compiler Lisp expression => Lisp expression of op codes &REST AND DEFMACRO DEFUN IF LAMBDA LET LETREC MACRO OR PROGN PRIMITIVE QUOTE SETQ Indexing of variables
80 Jatha SECD machine
81 Jatha SECD machine No symbolic representation
82 Jatha SECD machine No symbolic representation Instances of SECDop pushed to registers
83 Jatha SECD machine No symbolic representation Instances of SECDop pushed to registers Primitives are just opcodes
84 Jatha SECD machine No symbolic representation Instances of SECDop pushed to registers Primitives are just opcodes Since the bytecode is represented as Lisp
85 Jatha SECD machine No symbolic representation Instances of SECDop pushed to registers Primitives are just opcodes Since the bytecode is represented as Lisp And since primitives are Lisp values, it can just be executed the same
86 Typical primitives
87 Typical primitives + APPEND APPLY APROPOS AREF CAR CDR ATOM ` CONS FUNCALL GO SETF USE-PACKAGE
88 Implementation tidbits
89 Implementation tidbits It s very object oriented
90 Implementation tidbits It s very object oriented No singletons
91 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning
92 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types
93 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types Bytecode is a Lisp list of Lisp symbols and other values
94 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types Bytecode is a Lisp list of Lisp symbols and other values Registers are Lisp lists
95 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types Bytecode is a Lisp list of Lisp symbols and other values Registers are Lisp lists Primitives are Lisp values
96 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types Bytecode is a Lisp list of Lisp symbols and other values Registers are Lisp lists Primitives are Lisp values etc.
97 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types Bytecode is a Lisp list of Lisp symbols and other values Registers are Lisp lists Primitives are Lisp values etc.
98 Implementation tidbits It s very object oriented No singletons Have been this way since the beginning Basically everything is represented using Lisp types Bytecode is a Lisp list of Lisp symbols and other values Registers are Lisp lists Primitives are Lisp values etc.
99 REPL
100 REPL Print current package in prompt
101 REPL Print current package in prompt Read and parse input
102 REPL Print current package in prompt Read and parse input Compile input
103 REPL Print current package in prompt Read and parse input Compile input Execute compiled code
104 REPL Print current package in prompt Read and parse input Compile input Execute compiled code Set *, ** and ***
105 REPL Print current package in prompt Read and parse input Compile input Execute compiled code Set *, ** and *** Print result of execution
106 Demo Jatha in action
107 Major missing features
108 Major missing features Arrays
109 Major missing features Arrays Complex numbers
110 Major missing features Arrays Complex numbers &Optional and &Key arguments
111 Major missing features Arrays Complex numbers &Optional and &Key arguments Lambda functions (partial support)
112 Major missing features Arrays Complex numbers &Optional and &Key arguments Lambda functions (partial support) Good ERROR and CERROR implementations
113 Major missing features Arrays Complex numbers &Optional and &Key arguments Lambda functions (partial support) Good ERROR and CERROR implementations CLOS
114 Major missing features Arrays Complex numbers &Optional and &Key arguments Lambda functions (partial support) Good ERROR and CERROR implementations CLOS Pathnames
115 Major missing features Arrays Complex numbers &Optional and &Key arguments Lambda functions (partial support) Good ERROR and CERROR implementations CLOS Pathnames Read macros
116 Major missing features Arrays Complex numbers &Optional and &Key arguments Lambda functions (partial support) Good ERROR and CERROR implementations CLOS Pathnames Read macros Conditions
117 Future directions
118 Future directions Java integration
119 Future directions Java integration Byte code compilation
120 Future directions Java integration Byte code compilation More CL functions implemented
121 Future directions Java integration Byte code compilation More CL functions implemented LOOP macro
122 Future directions Java integration Byte code compilation More CL functions implemented LOOP macro Full SETF
123 Future directions Java integration Byte code compilation More CL functions implemented LOOP macro Full SETF Look at something like UCW, let that drive implementation
124 Complications
125 Complications Multiple values
126 Complications Multiple values Numerical classes
127 Complications Multiple values Numerical classes SECD not well suited for compilation
128 Complications Multiple values Numerical classes SECD not well suited for compilation Extremely polymorphic call sites
129 Complications Multiple values Numerical classes SECD not well suited for compilation Extremely polymorphic call sites Hard to implement new things since reflection isn t used
130 Complications Multiple values Numerical classes SECD not well suited for compilation Extremely polymorphic call sites Hard to implement new things since reflection isn t used
131 Potential JVM solutions
132 Potential JVM solutions Cheap tuples
133 Potential JVM solutions Cheap tuples Faster reflection
134 Potential JVM solutions Cheap tuples Faster reflection Numerical tower (fast, maybe based on gnu.math)
135 Potential JVM solutions Cheap tuples Faster reflection Numerical tower (fast, maybe based on gnu.math) Interface invocation
136 JVM languages
137 JVM languages Most aren t full implementations
138 JVM languages Most aren t full implementations Usually based on simple interpreters
139 JVM languages Most aren t full implementations Usually based on simple interpreters Or byte code (not JVM) based machines
140 JVM languages Most aren t full implementations Usually based on simple interpreters Or byte code (not JVM) based machines Or pure compilation
141 JVM languages Most aren t full implementations Usually based on simple interpreters Or byte code (not JVM) based machines Or pure compilation Many use reflection
142 JVM languages Most aren t full implementations Usually based on simple interpreters Or byte code (not JVM) based machines Or pure compilation Many use reflection Many use loads of interfaces
143 JVM languages Most aren t full implementations Usually based on simple interpreters Or byte code (not JVM) based machines Or pure compilation Many use reflection Many use loads of interfaces Byte code based solution will not help most of these
144 JVM languages Most aren t full implementations Usually based on simple interpreters Or byte code (not JVM) based machines Or pure compilation Many use reflection Many use loads of interfaces Byte code based solution will not help most of these Method handles have much larger impact
145 Q and A
INF4820. Common Lisp: Closures and Macros
INF4820 Common Lisp: Closures and Macros Erik Velldal University of Oslo Oct. 19, 2010 Erik Velldal INF4820 1 / 22 Topics for Today More Common Lisp A quick reminder: Scope, binding and shadowing Closures
Parsing Scheme (+ (* 2 3) 1) * 1
Parsing Scheme + (+ (* 2 3) 1) * 1 2 3 Compiling Scheme frame + frame halt * 1 3 2 3 2 refer 1 apply * refer apply + Compiling Scheme make-return START make-test make-close make-assign make- pair? yes
Computer Science 21b (Spring Term, 2015) Structure and Interpretation of Computer Programs. Lexical addressing
Computer Science 21b (Spring Term, 2015) Structure and Interpretation of Computer Programs Lexical addressing The difference between a interpreter and a compiler is really two points on a spectrum of possible
Project 2: Scheme Interpreter
Project 2: Scheme Interpreter CSC 4101, Fall 2017 Due: 12 November 2017 For this project, you will implement a simple Scheme interpreter in C++ or Java. Your interpreter should be able to handle the same
Lecture #2 Kenneth W. Flynn RPI CS
Outline Programming in Lisp Lecture #2 Kenneth W. Flynn RPI CS Items from last time Recursion, briefly How to run Lisp I/O, Variables and other miscellany Lists Arrays Other data structures Jin Li lij3@rpi.edu
Symbolic Programming. Dr. Zoran Duric () Symbolic Programming 1/ 89 August 28, / 89
Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic expressions. Symbolic manipulation: you do it all the
FP Foundations, Scheme
FP Foundations, Scheme In Text: Chapter 15 1 Functional Programming -- Prelude We have been discussing imperative languages C/C++, Java, Fortran, Pascal etc. are imperative languages Imperative languages
Lisp Basic Example Test Questions
2009 November 30 Lisp Basic Example Test Questions 1. Assume the following forms have been typed into the interpreter and evaluated in the given sequence. ( defun a ( y ) ( reverse y ) ) ( setq a (1 2
FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 5. LISP: MAKRA, DATOVÁ STRUKTURA ZÁZNAM
FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 5. LISP: MAKRA, DATOVÁ STRUKTURA ZÁZNAM 2011 Jan Janoušek MI-FLP Evropský sociální fond Praha & EU: Investujeme do vaší budoucnosti MACROS Introduction to macro system
INF4820: Algorithms for Artificial Intelligence and Natural Language Processing. More Common Lisp
INF4820: Algorithms for Artificial Intelligence and Natural Language Processing More Common Lisp Stephan Oepen & Murhaf Fares Language Technology Group (LTG) September 6, 2017 Agenda 2 Previously Common
Dispatch techniques and closure representations
Dispatch techniques and closure representations Jan Midtgaard Week 3, Virtual Machines for Programming Languages Aarhus University, Q4-2011 Dispatch techniques Efficient bytecode interpreters (1/2) The
Common LISP-Introduction
Common LISP-Introduction 1. The primary data structure in LISP is called the s-expression (symbolic expression). There are two basic types of s-expressions: atoms and lists. 2. The LISP language is normally
INF4820: Algorithms for Artificial Intelligence and Natural Language Processing. Common Lisp Fundamentals
INF4820: Algorithms for Artificial Intelligence and Natural Language Processing Common Lisp Fundamentals Stephan Oepen & Murhaf Fares Language Technology Group (LTG) August 30, 2017 Last Week: What is
A Brief Introduction to Common Lisp
A Brief Introduction to Common Lisp David Gu Schloer Consulting Group david_guru@gty.org.in A Brief History Originally specified in 1958, Lisp is the second-oldest highlevel programming language in widespread
Functional Languages. CSE 307 Principles of Programming Languages Stony Brook University
Functional Languages CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Historical Origins 2 The imperative and functional models grew out of work
Debugging in LISP. trace causes a trace to be printed for a function when it is called
trace causes a trace to be printed for a function when it is called ;;; a function that works like reverse (defun rev (list) (cons (first (last list)) (rev (butlast list)))) USER: (trace rev) ; note trace
Common Lisp. Blake McBride
Contents Common Lisp Blake McBride (blake@mcbride.name) 1 Data Types 2 2 Numeric Hierarchy 3 3 Comments 3 4 List Operations 4 5 Evaluation and Quotes 5 6 String Operations 5 7 Predicates 6 8 Math Predicates
Functional programming with Common Lisp
Functional programming with Common Lisp Dr. C. Constantinides Department of Computer Science and Software Engineering Concordia University Montreal, Canada August 11, 2016 1 / 81 Expressions and functions
Announcements. Today s Menu
Announcements 1 Today s Menu Finish Introduction to ANNs (original material by Dr. Mike Nechyba) > Slides 58-60 > Adjusting the Learning Rate Loose Ends in > Lambda Expressions Review > I/O Functions >
Lambda Calculus and Lambda notation in Lisp II. Based on Prof. Gotshalks notes on Lambda Calculus and Chapter 9 in Wilensky.
λ Calculus Basis Lambda Calculus and Lambda notation in Lisp II Based on Prof. Gotshalks notes on Lambda Calculus and Chapter 9 in Wilensky Mathematical theory for anonymous functions» functions that have
Heap storage. Dynamic allocation and stacks are generally incompatible.
Heap storage Dynamic allocation and stacks are generally incompatible. 1 Stack and heap location Pointer X points to stack storage in procedure Q's activation record that no longer is live (exists) when
11/6/17. Functional programming. FP Foundations, Scheme (2) LISP Data Types. LISP Data Types. LISP Data Types. Scheme. LISP: John McCarthy 1958 MIT
Functional programming FP Foundations, Scheme (2 In Text: Chapter 15 LISP: John McCarthy 1958 MIT List Processing => Symbolic Manipulation First functional programming language Every version after the
Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004
Principles of Programming Languages Topic: Scope and Memory Professor Louis Steinberg Fall 2004 CS 314, LS,BR,LTM: Scope and Memory 1 Review Functions as first-class objects What can you do with an integer?
Principles of Programming Languages 2017W, Functional Programming
Principles of Programming Languages 2017W, Functional Programming Assignment 3: Lisp Machine (16 points) Lisp is a language based on the lambda calculus with strict execution semantics and dynamic typing.
Common LISP Tutorial 1 (Basic)
Common LISP Tutorial 1 (Basic) CLISP Download https://sourceforge.net/projects/clisp/ IPPL Course Materials (UST sir only) Download https://silp.iiita.ac.in/wordpress/?page_id=494 Introduction Lisp (1958)
Symbolic Computation and Common Lisp
Symbolic Computation and Common Lisp Dr. Neil T. Dantam CSCI-56, Colorado School of Mines Fall 28 Dantam (Mines CSCI-56) Lisp Fall 28 / 92 Why? Symbolic Computing: Much of this course deals with processing
Robot Programming with Lisp
4. Functional Programming: Higher-order Functions, Map/Reduce, Lexical Scope Institute for Artificial University of Bremen 9 of November, 2017 Functional Programming Pure functional programming concepts
regsim.scm ~/umb/cs450/ch5.base/ 1 11/11/13
1 File: regsim.scm Register machine simulator from section 5.2 of STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS This file can be loaded into Scheme as a whole. Then you can define and simulate machines
CS 480. Lisp J. Kosecka George Mason University. Lisp Slides
CS 480 Lisp J. Kosecka George Mason University Lisp Slides Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic
CS 360 Programming Languages Interpreters
CS 360 Programming Languages Interpreters Implementing PLs Most of the course is learning fundamental concepts for using and understanding PLs. Syntax vs. semantics vs. idioms. Powerful constructs like
User-defined Functions. Conditional Expressions in Scheme
User-defined Functions The list (lambda (args (body s to a function with (args as its argument list and (body as the function body. No quotes are needed for (args or (body. (lambda (x (+ x 1 s to the increment
CS 275 Name Final Exam Solutions December 16, 2016
CS 275 Name Final Exam Solutions December 16, 2016 You may assume that atom? is a primitive procedure; you don t need to define it. Other helper functions that aren t a standard part of Scheme you need
CSCI337 Organisation of Programming Languages LISP
Organisation of Programming Languages LISP Getting Started Starting Common Lisp $ clisp i i i i i i i ooooo o ooooooo ooooo ooooo I I I I I I I 8 8 8 8 8 o 8 8 I \ `+' / I 8 8 8 8 8 8 \ `-+-' / 8 8 8 ooooo
A Quick Introduction to Common Lisp
CSC 244/444 Notes last updated ug. 30, 2016 Quick Introduction to Common Lisp Lisp is a functional language well-suited to symbolic I, based on the λ-calculus and with list structures as a very flexible
Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp.
Overview Announcement Announcement Lisp Basics CMUCL to be available on sun.cs. You may use GNU Common List (GCL http://www.gnu.org/software/gcl/ which is available on most Linux platforms. There is also
COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen
COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts
Homework #2. Source code with description. Tzewen Wang ECE578 Winter 2005
Tzewen Wang ECE578 Winter 2005 Source code with description Homework #2 Homework 2 Tzewen Wang ECE578 Winter 2005 In addition to the symbols for obstacle and corridor in a labyrinth, five more symbols
A little bit of Lisp
B.Y. Choueiry 1 Instructor s notes #3 A little bit of Lisp Introduction to Artificial Intelligence CSCE 476-876, Fall 2017 www.cse.unl.edu/~choueiry/f17-476-876 Read LWH: Chapters 1, 2, 3, and 4. Every
UMBC CMSC 331 Final Exam
UMBC CMSC 331 Final Exam Name: UMBC Username: You have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points for answers that are needlessly wordy
A LISP Interpreter in ML
UNIVERSITY OF OSLO Department of Informatics A LISP Interpreter in ML Mandatory Assignment 1 INF3110 September 21, 2009 Contents 1 1 Introduction The purpose of this assignment is to write an interpreter,
Structure Programming in Lisp. Shared Structure. Tailp. Shared Structure. Top-Level List Structure
Structure 66-2210-01 Programming in Lisp Lecture 6 - Structure; ase Study: locks World Lisp's use of pointers Let you put any value anywhere Details are taken care of by the Lisp interpreter What goes
CMSC 331 Final Exam Section 0201 December 18, 2000
CMSC 331 Final Exam Section 0201 December 18, 2000 Name: Student ID#: You will have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points for
CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)
CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent
Modern Programming Languages. Lecture LISP Programming Language An Introduction
Modern Programming Languages Lecture 18-21 LISP Programming Language An Introduction 72 Functional Programming Paradigm and LISP Functional programming is a style of programming that emphasizes the evaluation
Topic III. LISP : functions, recursion, and lists References: Chapter 3 of Concepts in programming languages by J. C. Mitchell. CUP, 2003.
Topic III LISP : functions, recursion, and lists References: Chapter 3 of Concepts in programming languages by J. C. Mitchell. CUP, 2003. Chapters 5( 4.5) and 13( 1) of Programming languages: Design and
Allegro CL Certification Program
Allegro CL Certification Program Lisp Programming Series Level I Session 1.3.1 David Margolies Manipulating Lists 9/16/2010 1 What is a List? An ordered (possibly empty) collection of things in a particular
SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015
SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,
Allegro CL Certification Program
Allegro CL Certification Program Lisp Programming Series Level I Presented by 1 About David Margolies Manager, Documentation, Franz Inc Been working with Lisp since 1984 dm@franz.com 2 About Franz Inc.
Department of Computer and information Science Norwegian University of Science and Technology
Department of Computer and information Science Norwegian University of Science and Technology http://www.idi.ntnu.no/ A Crash Course in LISP MNFIT272 2002 Anders Kofod-Petersen anderpe@idi.ntnu.no Introduction
Architecture of LISP Machines. Kshitij Sudan March 6, 2008
Architecture of LISP Machines Kshitij Sudan March 6, 2008 A Short History Lesson Alonzo Church and Stephen Kleene (1930) λ Calculus ( to cleanly define "computable functions" ) John McCarthy (late 60 s)
Lisp. Versions of LISP
Lisp Versions of LISP Lisp is an old language with many variants Lisp is alive and well today Most modern versions are based on Common Lisp LispWorks is based on Common Lisp Scheme is one of the major
JVM ByteCode Interpreter
JVM ByteCode Interpreter written in Haskell (In under 1000 Lines of Code) By Louis Jenkins Presentation Schedule ( 15 Minutes) Discuss and Run the Virtual Machine first
19 Machine Learning in Lisp
19 Machine Learning in Lisp Chapter Objectives Chapter Contents ID3 algorithm and inducing decision trees from lists of examples. A basic Lisp implementation of ID3 Demonstration on a simple credit assessment
Parsing INI Files in Lisp
Parsing INI Files in Lisp Gene Michael Stover created Sunday, 2005 February 20 updated Sunday, 2005 February 20 Copyright c 2005 Gene Michael Stover. All rights reserved. Permission to copy, store, & view
April 2 to April 4, 2018
MORE SCHEME COMPUTER SCIENCE MENTORS 61A April 2 to April 4, 2018 1 Scheme 1. What will Scheme output? Draw box-and-pointer diagrams to help determine this. (a) (cons (cons 1 nil) (cons 2 (cons (cons 3
Introduction to Functional Programming and basic Lisp
Introduction to Functional Programming and basic Lisp Based on Slides by Yves Lespérance & Peter Roosen-Runge 1 Functional vs Declarative Programming declarative programming uses logical statements to
FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 4. LISP: PROMĚNNÉ, DALŠÍ VLASTNOSTI FUNKCÍ, BLOKY, MAPOVACÍ FUNKCIONÁLY, ITERAČNÍ CYKLY,
FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 4. LISP: PROMĚNNÉ, DALŠÍ VLASTNOSTI FUNKCÍ, BLOKY, MAPOVACÍ FUNKCIONÁLY, ITERAČNÍ CYKLY, 2011 Jan Janoušek MI-FLP Evropský sociální fond Praha & EU: Investujeme do vaší
Functional programming techniques
Functional programming techniques o Currying o Continuations o Streams. Lazy evaluation Currying o Haskell B. Curry. o Second-order programming: o Functions that return other functions. o Example: A two-arguments
WELCOME TO PERL = Tuesday, June 4, 13
WELCOME TO PERL11 5 + 6 = 11 http://perl11.org/ Stavanger 2012 Moose + p5-mop Workshop Text Preikestolen Will Braswell Ingy döt net Austin 2012 PERL 11 5 + 6 = 11 perl11.org Will Braswell, Ingy döt net,
Tizen/Artik IoT Lecture Chapter 3. JerryScript Parser & VM
1 Tizen/Artik IoT Lecture Chapter 3. JerryScript Parser & VM Sungkyunkwan University Contents JerryScript Execution Flow JerryScript Parser Execution Flow Lexing Parsing Compact Bytecode (CBC) JerryScript
Artificial Intelligence Programming
Artificial Intelligence Programming Rob St. Amant Department of Computer Science North Carolina State University Lisp basics NC State University 2 / 99 Why Lisp? Some recent Lisp success stories include
CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018
CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018 Taken from assignments by Profs. Carl Offner and Ethan Bolker Part 1 - Modifying The Metacircular Evaluator
Fifth Generation CS 4100 LISP. What do we need? Example LISP Program 11/13/13. Chapter 9: List Processing: LISP. Central Idea: Function Application
Fifth Generation CS 4100 LISP From Principles of Programming Languages: Design, Evaluation, and Implementation (Third Edition, by Bruce J. MacLennan, Chapters 9, 10, 11, and based on slides by Istvan Jonyer
Project 1: Scheme Pretty-Printer
Project 1: Scheme Pretty-Printer CSC 4101, Fall 2017 Due: 7 October 2017 For this programming assignment, you will implement a pretty-printer for a subset of Scheme in either C++ or Java. The code should
CS 61A Discussion 8: Scheme. March 23, 2017
CS 61A Discussion 8: Scheme March 23, 2017 Announcements Ants is due today. Finish it! Also turn it in! HW 6 is due tomorrow. Finish it! Also turn it in! HW party today from 6:30-8:30p in 247 Cory. Midterm
CMSC 331 Final Exam Section 0201 December 18, 2000
CMSC 331 Final Exam Section 0201 December 18, 2000 Name: nswers Student ID#: You will have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points
The Art of Lisp Programming
The Art of Lisp Programming Robin Jones Clive Maynard Ian Stewart The Art of Lisp Programming With 12 Illustrations Springer-Verlag London Berlin Heidelberg N ew York Paris Tokyo Hong Kong Robin Jones
Run-time Environments
Run-time Environments Status We have so far covered the front-end phases Lexical analysis Parsing Semantic analysis Next come the back-end phases Code generation Optimization Register allocation Instruction
Run-time Environments
Run-time Environments Status We have so far covered the front-end phases Lexical analysis Parsing Semantic analysis Next come the back-end phases Code generation Optimization Register allocation Instruction
Object Oriented Programming (OOP)
Object Oriented Programming (OOP) o New programming paradigm o Actions Objects o Objects Actions o Object-oriented = Objects + Classes + Inheritance Imperative programming o OOP (Object-Oriented Programming)
A Genetic Algorithm Implementation
A Genetic Algorithm Implementation Roy M. Turner (rturner@maine.edu) Spring 2017 Contents 1 Introduction 3 2 Header information 3 3 Class definitions 3 3.1 Individual..........................................
UMBC CMSC 331 Final Exam Section 0101 December 17, 2002
0 / 0 1 / 20 UMBC CMSC 331 Final Exam Section 0101 December 17, 2002 Name: Student ID#: 2 / 25 3 / 20 4 / 25 5 / 20 6 /40 7 /40 You will have two hours to complete this closed book exam. We reserve the
LECTURE 16. Functional Programming
LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative
(defmacro while (condition &body body) `(iterate loop () (if,condition (loop)))))
; PARCIL - A Parser for C syntax In Lisp version 0.1a copyright (c) 1992 by Erann Gat, all rights reserved This program is free software; you can redistribute it and/or modify it under the terms of the
Symbols are more than variables. Symbols and Property Lists. Symbols are more than variables. Symbols are more than variables.
Symbols are more than variables So far we have been looking at symbols as if they were variables Symbols and Property Lists Based on Chapter 7 in Wilensky + Prof. Gotshalks notes on symbols > ( setq x
Allegro CL Certification Program
Allegro CL Certification Program Lisp Programming Series Level I Review David Margolies 1 Summary 1 A lisp session contains a large number of objects which is typically increased by user-created lisp objects
Summer 2017 Discussion 10: July 25, Introduction. 2 Primitives and Define
CS 6A Scheme Summer 207 Discussion 0: July 25, 207 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,
Implementing Symmetric Multiprocessing in LispWorks
Implementing Symmetric Multiprocessing in LispWorks Making a multithreaded application more multithreaded Martin Simmons, LispWorks Ltd Copyright 2009 LispWorks Ltd Outline Introduction Changes in LispWorks
CIS4/681 { Articial Intelligence 2 > (insert-sort '( )) ( ) 2 More Complicated Recursion So far everything we have dened requires
1 A couple of Functions 1 Let's take another example of a simple lisp function { one that does insertion sort. Let us assume that this sort function takes as input a list of numbers and sorts them in ascending
Every language has its own scoping rules. For example, what is the scope of variable j in this Java program?
Lexical Binding There are two ways a variable can be used in a program: As a declaration As a "reference" or use of the variable Scheme has two kinds of variable "declarations" -- the bindings of a let-expression
Robot Programming with Lisp
2. Imperative Programming Institute for Artificial University of Bremen Lisp the Language LISP LISt Processing language 2 Lisp the Language LISP LISt Processing language (LISP Lots of Irritating Superfluous
Introduction to Lisp
Last update: February 16, 2010 Introduction to Lisp Dana Nau Dana Nau 1 Outline I assume you know enough about computer languages that you can learn new ones quickly, so I ll go pretty fast If I go too
Functional Programming. Pure Functional Programming
Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).
Intro. Scheme Basics. scm> 5 5. scm>
Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if
CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures
CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures Dan Grossman Fall 2014 Hi! I m not Hal J I love this stuff and have taught
CA Compiler Construction
CA4003 - Compiler Construction David Sinclair When procedure A calls procedure B, we name procedure A the caller and procedure B the callee. A Runtime Environment, also called an Activation Record, is
ALISP interpreter in Awk
ALISP interpreter in Awk Roger Rohrbach 1592 Union St., #94 San Francisco, CA 94123 January 3, 1989 ABSTRACT This note describes a simple interpreter for the LISP programming language, written in awk.
Contents in Detail. Who This Book Is For... xx Using Ruby to Test Itself... xx Which Implementation of Ruby?... xxi Overview...
Contents in Detail Foreword by Aaron Patterson xv Acknowledgments xvii Introduction Who This Book Is For................................................ xx Using Ruby to Test Itself.... xx Which Implementation
Why do we need an interpreter? SICP Interpretation part 1. Role of each part of the interpreter. 1. Arithmetic calculator.
.00 SICP Interpretation part Parts of an interpreter Arithmetic calculator Names Conditionals and if Store procedures in the environment Environment as explicit parameter Defining new procedures Why do
Functions and Recursion. Dr. Philip Cannata 1
Functions and Recursion Dr. Philip Cannata 1 10 High Level Languages This Course Java (Object Oriented) Jython in Java Relation ASP RDF (Horn Clause Deduction, Semantic Web) Dr. Philip Cannata 2 let transformation,
Basics of Using Lisp! Gunnar Gotshalks! BLU-1
Basics of Using Lisp BLU-1 Entering Do Lisp work Exiting Getting into and out of Clisp % clisp (bye)» A function with no arguments» CTRL d can also be used Documentation files are in the directory» /cse/local/doc/clisp
Design Issues. Subroutines and Control Abstraction. Subroutines and Control Abstraction. CSC 4101: Programming Languages 1. Textbook, Chapter 8
Subroutines and Control Abstraction Textbook, Chapter 8 1 Subroutines and Control Abstraction Mechanisms for process abstraction Single entry (except FORTRAN, PL/I) Caller is suspended Control returns
Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives
CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme
LFE - a lisp on the Erlang VM
Robert Virding Principle Language Expert at Erlang Solutions Ltd. LFE - a lisp on the Erlang VM What LFE isn t It isn t an implementation of Scheme It isn t an implementation of Common Lisp It isn t an
Names, Bindings, Scopes
Names, Bindings, Scopes Variables In imperative l Language: abstractions of von Neumann machine Variables: abstraction of memory cell or cells Sometimes close to machine (e.g., integers), sometimes not
Lexical vs. Dynamic Scope
Intro Lexical vs. Dynamic Scope where do I point to? Remember in Scheme whenever we call a procedure we pop a frame and point it to where the procedure points to (its defining environment). This is called
Mechanized Operational Semantics
Mechanized Operational Semantics J Strother Moore Department of Computer Sciences University of Texas at Austin Marktoberdorf Summer School 2008 (Lecture 2: An Operational Semantics) 1 M1 An M1 state consists
Test 1 Summer 2014 Multiple Choice. Write your answer to the LEFT of each problem. 5 points each 1. Preprocessor macros are associated with: A. C B.
CSE 3302 Test 1 1. Preprocessor macros are associated with: A. C B. Java C. JavaScript D. Pascal 2. (define x (lambda (y z) (+ y z))) is an example of: A. Applying an anonymous function B. Defining a function
The Procedure Abstraction Part I: Basics
The Procedure Abstraction Part I: Basics Procedure Abstraction Begins Chapter 6 in EAC The compiler must deal with interface between compile time and run time Most of the tricky issues arise in implementing
Recursive Functions of Symbolic Expressions and Their Computation by Machine Part I
Recursive Functions of Symbolic Expressions and Their Computation by Machine Part I by John McCarthy Ik-Soon Kim Winter School 2005 Feb 18, 2005 Overview Interesting paper with By John Mitchell Interesting