Big Bang. Designing a Statically Typed Scripting Language. Pottayil Harisanker Menon, Zachary Palmer, Scott F. Smith, Alexander Rozenshteyn
|
|
|
- Myra Gibbs
- 5 years ago
- Views:
Transcription
1 Big Bang Designing a Statically Typed Scripting Language Pottayil Harisanker Menon, Zachary Palmer, Scott F. Smith, Alexander Rozenshteyn The Johns Hopkins University June 11, 2012
2 Scripting Languages! Terse! Flexible! Easy to learn! Amenable to rapid development
3 Scripting Languages! Terse! Flexible! Easy to learn! Amenable to rapid development % Dynamically typed
4 Advantages of Static Typing Performance Debugging Programmer understanding
5 Typing Existing Scripting Languages e.g. DRuby, Typed Racket
6 Typing Existing Scripting Languages e.g. DRuby, Typed Racket Existing language features are hard to type
7 Typing Existing Scripting Languages e.g. DRuby, Typed Racket Existing language features are hard to type DRuby does not typecheck the entire Ruby API
8 Typing Existing Scripting Languages e.g. DRuby, Typed Racket Existing language features are hard to type DRuby does not typecheck the entire Ruby API Typechecking runtime metaprogramming is hard
9 Typing Existing Scripting Languages e.g. DRuby, Typed Racket Existing language features are hard to type DRuby does not typecheck the entire Ruby API Typechecking runtime metaprogramming is hard These systems require programmer annotation
10 Typing Existing Scripting Languages e.g. DRuby, Typed Racket Existing language features are hard to type DRuby does not typecheck the entire Ruby API Typechecking runtime metaprogramming is hard These systems require programmer annotation Type annotations reduce terseness
11 Typing Existing Scripting Languages e.g. DRuby, Typed Racket Existing language features are hard to type DRuby does not typecheck the entire Ruby API Typechecking runtime metaprogramming is hard These systems require programmer annotation Type annotations reduce terseness Annotations can be overly restrictive
12 Let s try designing a typed scripting language from scratch
13 Designing a Typed Scripting Language Design type system and execution model concurrently
14 Designing a Typed Scripting Language Design type system and execution model concurrently Be minimalistic: most features are encoded
15 Designing a Typed Scripting Language Design type system and execution model concurrently Be minimalistic: most features are encoded Use static near-equivalents for dynamic patterns
16 Designing a Typed Scripting Language Design type system and execution model concurrently Be minimalistic: most features are encoded Use static near-equivalents for dynamic patterns Infer all types: no type declarations
17 Designing a Typed Scripting Language Design type system and execution model concurrently Be minimalistic: most features are encoded Use static near-equivalents for dynamic patterns Infer all types: no type declarations Use a whole-program typechecking model
18 Designing a Typed Scripting Language Design type system and execution model concurrently Be minimalistic: most features are encoded Use static near-equivalents for dynamic patterns Infer all types: no type declarations Use a whole-program typechecking model Use type information to improve runtime memory layout
19 BigBang by Example
20 BigBang and TinyBang BigBang encodes to a core language
21 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features:
22 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features: Primitives
23 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features: Primitives Labels
24 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features: Primitives Labels Onions
25 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features: Primitives Labels Onions Scapes
26 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features: Primitives Labels Onions Scapes Exceptions
27 BigBang and TinyBang BigBang encodes to a core language TinyBang has very few features: Primitives Labels Onions Scapes Exceptions (and that s all)
28 Labels and Onions Labels simply wrap data `name "Tom"
29 Labels and Onions Labels simply wrap data (polymorphic variants) `name "Tom" ("Tom" `name "Tom")
30 Labels and Onions Labels simply wrap data (polymorphic variants) Onions combine data `name "Tom" & `age 10
31 Labels and Onions Labels simply wrap data (polymorphic variants) Onions combine data Data may be unlabeled (vs. extensible records) `name "Tom" & `age 10 & 3
32 Labels and Onions Labels simply wrap data (polymorphic variants) Onions combine data Data may be unlabeled (vs. extensible records) Onion data is projected by type (1 & () ) + 2 = 3
33 Labels and Onions Labels simply wrap data (polymorphic variants) Onions combine data Data may be unlabeled (vs. extensible records) Onion data is projected by type Onioning is asymmetric (right-precedence) (1 & 4) + 2 = 6
34 Labels and Onions Labels simply wrap data (polymorphic variants) Onions combine data Data may be unlabeled (vs. extensible records) Onion data is projected by type Onioning is asymmetric (right-precedence) Used to encode overriding (1 & 4) + 2 = 6
35 Labels and Onions Labels simply wrap data (polymorphic variants) Onions combine data Data may be unlabeled (vs. extensible records) Onion data is projected by type Onioning is asymmetric (right-precedence) Used to encode overriding Important for type checking (later) (1 & 4) + 2 = 6
36 Scapes Scapes are functions x -> x
37 Scapes Scapes are functions with input patterns `A x & `B y -> x + y
38 Scapes Scapes are functions with input patterns (`A x & `B y -> x + y) (`A 1 & `B 2) = 3
39 Scapes Scapes are functions with input patterns Onions of scapes apply the first matching scape def list = `Hd 4 & `Tl `Nil () in (( `Hd h -> h) & ( `Nil _ -> ())) list = 4
40 Scapes Scapes are functions with input patterns Onions of scapes apply the first matching scape Encodes typecasing def list = `Hd 4 & `Tl `Nil () in (( `Hd h -> h) & ( `Nil _ -> ())) list = def list = `Hd 4 & `Tl `Nil () in list of `Nil _ -> () `Hd h -> h case
41 Scapes Scapes are functions with input patterns Onions of scapes apply the first matching scape Encodes typecasing Refines First-Class Cases [Chae et al. 06] def list = `Hd 4 & `Tl `Nil () in (( `Hd h -> h) & ( `Nil _ -> ())) list = def list = `Hd 4 & `Tl `Nil () in list of `Nil _ -> () `Hd h -> h case
42 Mutation Label contents are mutable def y = `A 2 in (`A x -> x = 5 in y) y = `A 5
43 Mutation Label contents are mutable But onioning is functional extension def x = `A 0 & `B 1 in def y = `B 2 & `C 3 in def z = x & y in x = `A 0 & `B 1
44 Mutation Label contents are mutable But onioning is functional extension def x = `A 0 & `B 1 in def y = `B 2 & `C 3 in def z = x & y in z = `A 0 & `B 2 & `C 3
45 Expressiveness
46 Encoding Self Function self-awareness can be encoded by: Adding a `self match to each pattern x -> x x:`self self -> x
47 Encoding Self Function self-awareness can be encoded by: Adding a `self match to each pattern `A a -> e `A a & `self self -> e
48 Encoding Self Function self-awareness can be encoded by: Adding a `self match to each pattern Adding a `self value to each invocation f e f (e & `self f)
49 Encoding Self def factorial = x: int -> if x == 0 then 1 else self (x -1) * x in self 5 def factorial = x: int & `self self -> if x == 0 then 1 else self (x -1) * x in factorial (5 & `self factorial)
50 Encoding Objects Objects are encoded as onions class Point { int x = 2; int y = 3; int l1() { return x+y; } }
51 Encoding Objects Objects are encoded as onions Each field is a labeled value class Point { int x = 2; int y = 3; int l1() { return x+y; } } `x `y 3 2 &
52 Encoding Objects Objects are encoded as onions Each field is a labeled value Message handler scapes encode methods class Point { int x = 2; int y = 3; int l1() { return x+y; } } `x 2 & `y 3 & ( `l1 () -> self.x+self.y)
53 Encoding Objects Objects are encoded as onions Each field is a labeled value Message handler scapes encode methods class Point { int x = 2; int y = 3; int l1() { return x+y; } } `x 2 & `y 3 & ( `l1 () & `self self -> self.x+self.y)
54 Encoding Objects def o = `x 2 & `y 3 & ( `l1 () & `self self -> self.x + self.y ) in (`x x -> x) o = o.x
55 Encoding Objects def o = `x 2 & `y 3 & ( `l1 () & `self self -> self.x + self.y ) in o ( `l1 () & `self o ) = o.l1 ()
56 Encoding Mixins Inheritance occurs by onion extension def mypoint = `x 2 & `y 3 & ( `l1 () -> self.x + self.y) in def mixinfar = ( `isfar () -> self.l1 () > 26) in def myfpoint = mypoint & mixinfar in myfpoint.isfar ()
57 Encoding Mixins Inheritance occurs by onion extension Mixins are the extension onion def mypoint = `x 2 & `y 3 & ( `l1 () -> self.x + self.y) in def mixinfar = ( `isfar () -> self.l1 () > 26) in def myfpoint = mypoint & mixinfar in myfpoint.isfar ()
58 Encoding Classes Classes are object factories def Point = `new (`x x & `y y) -> `x x & `y y & ( `l1 () -> self.x + self.y) in...
59 Encoding Classes Classes are object factories Subclass factories instantiate and extend def Point = `new (`x x & `y y) -> `x x & `y y & ( `l1 () -> self.x + self.y) in def Point3D = `new (a: `x _ & `y _ & `z z) -> def super = ( Point.new a) in super & `z 0 & ( `l1 () -> super.l1 ()) + self.z) in Point3D ( `new (`x 1 & `y 2 & `z 3))
60 Encoding Overloading Overloading is trivial with scapes def join = (( `x x:int & `y y:int) -> x + y) & (( `x _:unit & `y _:unit) -> ()) in join (`x 1 & `y 2) & join (`x () & `y ())
61 Encoding Overloading Overloading is trivial with scapes Onion extension allows incremental overloading def join = (( `x x:int & `y y:int) -> x + y) & (( `x _:unit & `y _:unit) -> ()) in def x = join (`x 1 & `y 2) & join (`x () & `y ()) in def join = join & (( `x x:int & `y _:unit) -> x + 1) in join (`x 5 & `y ())
62 Encoding Overloading Overloading is trivial with scapes Onion extension allows incremental overloading Default arguments are easy too def inc = a: `x x -> def by = ((_ -> 1) & (`y y -> y)) a in x + by in inc (`x 1 & `y 2) + inc (`x 6)
63 Metaprogramming BigBang uses TinyBang as a core language
64 Metaprogramming BigBang uses TinyBang as a core language BigBang will provide macros for syntax/features
65 Metaprogramming BigBang uses TinyBang as a core language BigBang will provide macros for syntax/features self, class syntax, etc. defined in this way
66 Metaprogramming BigBang uses TinyBang as a core language BigBang will provide macros for syntax/features self, class syntax, etc. defined in this way User extensions can be specified
67 Metaprogramming BigBang uses TinyBang as a core language BigBang will provide macros for syntax/features self, class syntax, etc. defined in this way User extensions can be specified Similar to Racket (Languages as Libraries [Tobin-Hochstadt et al., 2011])
68 Typing
69 Typing Scripting Languages A scripting language s type system must be: 8 Expressive
70 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types
71 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs
72 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible
73 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible
74 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible Sources of type errors must be clear
75 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible Sources of type errors must be clear Intuitive non-local inference
76 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible Sources of type errors must be clear Intuitive non-local inference Z Efficient
77 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible Sources of type errors must be clear Intuitive non-local inference Z Efficient Short compile times for dev. iterations
78 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible Sources of type errors must be clear Intuitive non-local inference Z Efficient Short compile times for dev. iterations 2 Easy to Use
79 Typing Scripting Languages A scripting language s type system must be: 8 Expressive Duck typing, conditional types No arbitrary cutoffs 5 Comprehensible Types should be legible Sources of type errors must be clear Intuitive non-local inference Z Efficient Short compile times for dev. iterations 2 Easy to Use Usable to teach introductory courses
80 For BigBang, we choose: Typing BigBang 8 2 Subtype inference 8 Call-Site Polymorphism 8 5 Path sensitivity 5 2 Flow insensitivity 8 Z Asymmetric concatenation Z Incremental typechecking 8 Expressive 5 Comprehensible Z Efficient 2 Easy to Use
81 8 2 Subtype Inference 2 8 No programmer type declarations
82 8 2 Subtype Inference 2 8 No programmer type declarations Supports duck-typing
83 8 2 Subtype Inference 2 8 No programmer type declarations Supports duck-typing Supports nominal typing (labels as names)
84 8 2 Subtype Inference 2 8 No programmer type declarations Supports duck-typing Supports nominal typing (labels as names) (e.g. `x 1 & `y 2 & Point () )
85 8 Call-Site Polymorphism 8 All functions polymorphic; no let restriction
86 8 Call-Site Polymorphism 8 All functions polymorphic; no let restriction New contour for each non-recursive call site
87 8 Call-Site Polymorphism 8 All functions polymorphic; no let restriction New contour for each non-recursive call site Only one contour for each recursive cycle
88 8 Call-Site Polymorphism 8 All functions polymorphic; no let restriction New contour for each non-recursive call site Only one contour for each recursive cycle A variant of both ncfa and CPA
89 8 Call-Site Polymorphism 8 def f = x -> `A x in def x = f 0 in def y = f () in def z = f (`B 2 & `C 3) in...
90 8 Call-Site Polymorphism 8 def f = x -> `A x in def x = f 0 in def y = f () in def z = f (`B 2 & `C 3) in... x = `A 0 y = `A () z = `A (`B 2 & `C 3)
91 8 5 Path Sensitivity 5 8 Scape application based on pattern match
92 8 5 Path Sensitivity 5 8 Scape application based on pattern match Constraints expanded only if input matches
93 8 5 Path Sensitivity 5 8 Scape application based on pattern match Constraints expanded only if input matches With polymorphism, gives path sensitivity
94 8 5 Path Sensitivity 5 8 Scape application based on pattern match Constraints expanded only if input matches With polymorphism, gives path sensitivity Refines Conditional Types [Aiken et al. 94]
95 8 5 Path Sensitivity 5 8 def f = (`A x -> x) & (`B y -> ()) in f `A 3
96 8 5 Path Sensitivity 5 8 def f = (`A x -> x) & (`B y -> ()) in f `A 3 : int
97 5 2 Flow Insensitivity 2 5 Type of a variable is flow-invariant
98 5 2 Flow Insensitivity 2 5 Type of a variable is flow-invariant Flow sensitivity:
99 5 2 Flow Insensitivity 2 5 Type of a variable is flow-invariant Flow sensitivity: Makes variable types less clear
100 5 2 Flow Insensitivity 2 5 Type of a variable is flow-invariant Flow sensitivity: Makes variable types less clear Brittle to refactoring
101 5 2 Flow Insensitivity 2 5 Type of a variable is flow-invariant Flow sensitivity: Makes variable types less clear Brittle to refactoring Doesn t help that much
102 5 2 Flow Insensitivity 2 5 Type of a variable is flow-invariant Flow sensitivity: Makes variable types less clear Brittle to refactoring Doesn t help that much Could be added later if needed
103 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good
104 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good Examples of asymmetry:
105 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good Examples of asymmetry: Subtyping
106 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good Examples of asymmetry: Subtyping Overriding
107 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good Examples of asymmetry: Subtyping Overriding Multiple inheritance
108 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good Examples of asymmetry: Subtyping Overriding Multiple inheritance Evaluation order
109 8 Z Asymmetric Concatenation Z 8 In PL design, asymmetry can be good Examples of asymmetry: Subtyping Overriding Multiple inheritance Evaluation order Module dependencies
110 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element
111 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element Not based on row typing
112 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element Not based on row typing Only presence information is pushed forward
113 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element Not based on row typing Only presence information is pushed forward Type system can express α has `A int
114 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element Not based on row typing Only presence information is pushed forward Type system can express α has `A int But not α only has `A int
115 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element Not based on row typing Only presence information is pushed forward Type system can express α has `A int But not α only has `A int Upper bounds inferred from usage
116 8 Z Asymmetric Concatenation Z 8 Onion projection prefers rightmost element Not based on row typing Only presence information is pushed forward Type system can express α has `A int But not α only has `A int Upper bounds inferred from usage Monomorphic variant of TinyBang closure is polynomial (vs. previous NP-complete result [Palsberg et al. 03])
117 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast
118 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast Type constraint closure can be slow
119 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast Type constraint closure can be slow Solution:
120 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast Type constraint closure can be slow Solution: Track differences between software versions
121 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast Type constraint closure can be slow Solution: Track differences between software versions Delete constraints for removed code
122 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast Type constraint closure can be slow Solution: Track differences between software versions Delete constraints for removed code Include constraints from new code
123 Z Incremental Typechecking Z For scripts, edit-compile-debug must be fast Type constraint closure can be slow Solution: Track differences between software versions Delete constraints for removed code Include constraints from new code Perform closure again
124 Limitations Typical type system limitations
125 Limitations Typical type system limitations Recursion limits contour creation
126 Limitations Typical type system limitations Recursion limits contour creation Flow-insensitivity
127 Limitations Typical type system limitations Recursion limits contour creation Flow-insensitivity Syntactic limitations
128 Limitations Typical type system limitations Recursion limits contour creation Flow-insensitivity Syntactic limitations No string-to-label functionality
129 Compilation
130 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM)
131 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM) Optimizes layout using type information
132 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM) Optimizes layout using type information No unnecessary boxing
133 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM) Optimizes layout using type information No unnecessary boxing Reduce pointer arithmetic
134 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM) Optimizes layout using type information No unnecessary boxing Reduce pointer arithmetic Definitely no runtime hashing
135 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM) Optimizes layout using type information No unnecessary boxing Reduce pointer arithmetic Definitely no runtime hashing Still path-sensitive across modules
136 Compilation What will we want out of a compiler? Compiles scripts to native binaries (via LLVM) Optimizes layout using type information No unnecessary boxing Reduce pointer arithmetic Definitely no runtime hashing Still path-sensitive across modules How do we get this?
137 Whole-Program Compilation!
138 Whole-Program Compilation Why do we need a whole-program view? No declarations of types or module signatures
139 Whole-Program Compilation Why do we need a whole-program view? No declarations of types or module signatures General layout for extensible data structures is inefficient
140 Whole-Program Compilation Why do we need a whole-program view? No declarations of types or module signatures General layout for extensible data structures is inefficient So we must know what could arrive at each call site
141 Whole-Program Compilation How can we live with ourselves? Intermediate work (constraint sets, etc.) can be stored and reused
142 Whole-Program Compilation How can we live with ourselves? Intermediate work (constraint sets, etc.) can be stored and reused Coding to a module signature is limited; not all interface semantics are typeable
143 Whole-Program Compilation How can we live with ourselves? Intermediate work (constraint sets, etc.) can be stored and reused Coding to a module signature is limited; not all interface semantics are typeable Vast layout optimization potential
144 Whole-Program Compilation How can we live with ourselves? Intermediate work (constraint sets, etc.) can be stored and reused Coding to a module signature is limited; not all interface semantics are typeable Vast layout optimization potential Shared libraries are still possible
145 Layout Standard approach: common layout form (as C++)
146 Layout Standard approach: common layout form (as C++) Existing work handles flexible data structures
147 Layout Standard approach: common layout form (as C++) Existing work handles flexible data structures A Calculus with Polymorphic and Polyvariant Flow Types [Wells et al. 02]
148 Layout Standard approach: common layout form (as C++) Existing work handles flexible data structures A Calculus with Polymorphic and Polyvariant Flow Types [Wells et al. 02] A Polymorphic Record Calculus and Its Compilation [Ohori 95]
149 Layout Standard approach: common layout form (as C++) Existing work handles flexible data structures A Calculus with Polymorphic and Polyvariant Flow Types [Wells et al. 02] A Polymorphic Record Calculus and Its Compilation [Ohori 95] Onions: more flexible, new problems
150 Layout Standard approach: common layout form (as C++) Existing work handles flexible data structures A Calculus with Polymorphic and Polyvariant Flow Types [Wells et al. 02] A Polymorphic Record Calculus and Its Compilation [Ohori 95] Onions: more flexible, new problems Whole-program types will help us!
151 We have: Where Are We? A TinyBang interpreter
152 Where Are We? We have: A TinyBang interpreter A TinyBang type system and soundness proof
153 We have: Where Are We? A TinyBang interpreter A TinyBang type system and soundness proof Effective encodings for language features
154 We have: Where Are We? A TinyBang interpreter A TinyBang type system and soundness proof Effective encodings for language features We need:
155 We have: Where Are We? A TinyBang interpreter A TinyBang type system and soundness proof Effective encodings for language features We need: A TinyBang-to-LLVM compiler
156 We have: Where Are We? A TinyBang interpreter A TinyBang type system and soundness proof Effective encodings for language features We need: A TinyBang-to-LLVM compiler A BigBang metaprogramming system
157 We have: Where Are We? A TinyBang interpreter A TinyBang type system and soundness proof Effective encodings for language features We need: A TinyBang-to-LLVM compiler A BigBang metaprogramming system A layout calculus and optimization tool
158 We have: Where Are We? A TinyBang interpreter A TinyBang type system and soundness proof Effective encodings for language features We need: A TinyBang-to-LLVM compiler A BigBang metaprogramming system A layout calculus and optimization tool...
159 Questions?
Types for Flexible Objects
Types for Flexible Objects Building a Typed Scripting Language Pottayil Harisanker Menon, Zachary Palmer, Alexander Rozenshteyn, Scott F. Smith The Johns Hopkins University November 17th, 2014 2/1 Objective
Types for Flexible Objects
Types for Flexible Objects Pottayil Harisanker Menon Zachary Palmer Alexander Rozenshteyn Scott Smith The Johns Hopkins University {pharisa2, zachary.palmer, scott, arozens1}@jhu.edu Abstract Scripting
Programming Languages (PL)
1 2 3 4 5 6 7 8 9 10 11 Programming Languages (PL) Programming languages are the medium through which programmers precisely describe concepts, formulate algorithms, and reason about solutions. In the course
CS-XXX: Graduate Programming Languages. Lecture 22 Class-Based Object-Oriented Programming. Dan Grossman 2012
CS-XXX: Graduate Programming Languages Lecture 22 Class-Based Object-Oriented Programming Dan Grossman 2012 PL Issues for OOP? OOP lets you: 1. Build some extensible software concisely 2. Exploit an intuitive
Introduction to Programming Using Java (98-388)
Introduction to Programming Using Java (98-388) Understand Java fundamentals Describe the use of main in a Java application Signature of main, why it is static; how to consume an instance of your own class;
An update on XML types
An update on XML types Alain Frisch INRIA Rocquencourt (Cristal project) Links Meeting - Apr. 2005 Plan XML types 1 XML types 2 3 2/24 Plan XML types 1 XML types 2 3 3/24 Claim It is worth studying new
Programming in Scala Second Edition
Programming in Scala Second Edition Martin Odersky, Lex Spoon, Bill Venners artima ARTIMA PRESS WALNUT CREEK, CALIFORNIA Contents Contents List of Figures List of Tables List of Listings Foreword Foreword
CONTENTS. PART 1 Structured Programming 1. 1 Getting started 3. 2 Basic programming elements 17
List of Programs xxv List of Figures xxix List of Tables xxxiii Preface to second version xxxv PART 1 Structured Programming 1 1 Getting started 3 1.1 Programming 3 1.2 Editing source code 5 Source code
Index. object lifetimes, and ownership, use after change by an alias errors, use after drop errors, BTreeMap, 309
A Arithmetic operation floating-point arithmetic, 11 12 integer numbers, 9 11 Arrays, 97 copying, 59 60 creation, 48 elements, 48 empty arrays and vectors, 57 58 executable program, 49 expressions, 48
Outline. Java Models for variables Types and type checking, type safety Interpretation vs. compilation. Reasoning about code. CSCI 2600 Spring
Java Outline Java Models for variables Types and type checking, type safety Interpretation vs. compilation Reasoning about code CSCI 2600 Spring 2017 2 Java Java is a successor to a number of languages,
Don t Believe the Hype. CS152: Programming Languages. Lecture 21 Object-Oriented Programming. Class-based OOP. So what is OOP?
Don t Believe the Hype CS152: Programming Languages Lecture 21 Object-Oriented Programming Dan Grossman Spring 2011 OOP lets you: 1. Build some extensible software concisely 2. Exploit an intuitive analogy
Introduction to Programming Microsoft.NET Applications with Visual Studio 2008 (C#)
Introduction to Programming Microsoft.NET Applications with Visual Studio 2008 (C#) Course Number: 6367A Course Length: 3 Days Course Overview This three-day course will enable students to start designing
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Values and Types We divide the universe of values according to types A type is a set of values and
COS 320. Compiling Techniques
Topic 5: Types COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Types: potential benefits (I) 2 For programmers: help to eliminate common programming mistakes, particularly
Project 5 Due 11:59:59pm Wed, Nov 25, 2015 (no late submissions)
Introduction Project 5 Due 11:59:59pm Wed, Nov 25, 2015 (no late submissions) In this project, you will write a compiler for a programming language called Rube, which is a small objectoriented programming
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
Overview of the Ruby Language. By Ron Haley
Overview of the Ruby Language By Ron Haley Outline Ruby About Ruby Installation Basics Ruby Conventions Arrays and Hashes Symbols Control Structures Regular Expressions Class vs. Module Blocks, Procs,
Implementing Interfaces. Marwan Burelle. July 20, 2012
Implementing marwan.burelle@lse.epita.fr http://www.lse.epita.fr/ July 20, 2012 Outline 1 2 3 4 Quick Overview of System oriented programming language Variant of C with a rationnalized syntax. Syntactic
Types. Type checking. Why Do We Need Type Systems? Types and Operations. What is a type? Consensus
Types Type checking What is a type? The notion varies from language to language Consensus A set of values A set of operations on those values Classes are one instantiation of the modern notion of type
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/3/17
Project 5 Due 11:59:59pm Tuesday, April 25, 2017
Project 5 Due 11:59:59pm Tuesday, April 25, 2017 Introduction In this project, you will write a compiler for a programming language called Rube, which is a small objectoriented programming language with
COMP 181. Agenda. Midterm topics. Today: type checking. Purpose of types. Type errors. Type checking
Agenda COMP 181 Type checking October 21, 2009 Next week OOPSLA: Object-oriented Programming Systems Languages and Applications One of the top PL conferences Monday (Oct 26 th ) In-class midterm Review
Java Training JAVA. Introduction of Java
Java Training Building or rewriting a system completely in Java means starting from the scratch. We engage in the seamless and stable operations of Java technology to deliver innovative and functional
COMPUTER SCIENCE TRIPOS
CST.2011.3.1 COMPUTER SCIENCE TRIPOS Part IB Monday 6 June 2011 1.30 to 4.30 COMPUTER SCIENCE Paper 3 Answer five questions. Submit the answers in five separate bundles, each with its own cover sheet.
CSE 413 Programming Languages & Implementation. Hal Perkins Winter 2019 Ruby Containers, Blocks, and Procs
CSE 413 Programming Languages & Implementation Hal Perkins Winter 2019 Ruby Containers, Blocks, and Procs CSE413 Winter 2019 1 The Plan Ruby container data structures Blocks and control structures (iterators,
Weiss Chapter 1 terminology (parenthesized numbers are page numbers)
Weiss Chapter 1 terminology (parenthesized numbers are page numbers) assignment operators In Java, used to alter the value of a variable. These operators include =, +=, -=, *=, and /=. (9) autoincrement
Overview. Declarative Languages D7012E. Overloading. Overloading Polymorphism Subtyping
Overview Declarative Languages D7012E Lecture 4: The Haskell type system Fredrik Bengtsson / Johan Nordlander Overloading & polymorphism Type classes instances of type classes derived type classes Type
Data Structures (list, dictionary, tuples, sets, strings)
Data Structures (list, dictionary, tuples, sets, strings) Lists are enclosed in brackets: l = [1, 2, "a"] (access by index, is mutable sequence) Tuples are enclosed in parentheses: t = (1, 2, "a") (access
Subtyping. Lecture 13 CS 565 3/27/06
Subtyping Lecture 13 CS 565 3/27/06 Polymorphism Different varieties of polymorphism: Parametric (ML) type variables are abstract, and used to encode the fact that the same term can be used in many different
Overview of OOP. Dr. Zhang COSC 1436 Summer, /18/2017
Overview of OOP Dr. Zhang COSC 1436 Summer, 2017 7/18/2017 Review Data Structures (list, dictionary, tuples, sets, strings) Lists are enclosed in square brackets: l = [1, 2, "a"] (access by index, is mutable
Cunning Plan. One-Slide Summary. Functional Programming. Functional Programming. Introduction to COOL #1. Classroom Object-Oriented Language
Functional Programming Introduction to COOL #1 Cunning Plan Functional Programming Types Pattern Matching Higher-Order Functions Classroom Object-Oriented Language Methods Attributes Inheritance Method
Contents. Figures. Tables. Examples. Foreword. Preface. 1 Basics of Java Programming 1. xix. xxi. xxiii. xxvii. xxix
PGJC4_JSE8_OCA.book Page ix Monday, June 20, 2016 2:31 PM Contents Figures Tables Examples Foreword Preface xix xxi xxiii xxvii xxix 1 Basics of Java Programming 1 1.1 Introduction 2 1.2 Classes 2 Declaring
CS 430 Spring Mike Lam, Professor. Data Types and Type Checking
CS 430 Spring 2015 Mike Lam, Professor Data Types and Type Checking Type Systems Type system Rules about valid types, type compatibility, and how data values can be used Benefits of a robust type system
Unifying Nominal and Structural Ad-Hoc Polymorphism
Unifying Nominal and Structural Ad-Hoc Polymorphism Stephanie Weirich University of Pennsylvania Joint work with Geoff Washburn Ad-hoc polymorphism Define operations that can be used for many types of
Functional Programming. Introduction To Cool
Functional Programming Introduction To Cool #1 Cunning Plan ML Functional Programming Fold Sorting Cool Overview Syntax Objects Methods Types #2 This is my final day... as your... companion... through
Dynamically-typed Languages. David Miller
Dynamically-typed Languages David Miller Dynamically-typed Language Everything is a value No type declarations Examples of dynamically-typed languages APL, Io, JavaScript, Lisp, Lua, Objective-C, Perl,
CSE Programming Languages Final exam - Spring Answer Key
CSE 341 - Programming Languages Final exam - Spring 2018 - Answer Key 1. (8 points) Write a Racket function multicons that takes an item x, a non-negative integer n, and a list xs; and returns a new list
PYTHON CONTENT NOTE: Almost every task is explained with an example
PYTHON CONTENT NOTE: Almost every task is explained with an example Introduction: 1. What is a script and program? 2. Difference between scripting and programming languages? 3. What is Python? 4. Characteristics
CS558 Programming Languages Winter 2013 Lecture 8
OBJECT-ORIENTED PROGRAMMING CS558 Programming Languages Winter 2013 Lecture 8 Object-oriented programs are structured in terms of objects: collections of variables ( fields ) and functions ( methods ).
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e
Part I Basic Concepts 1
Introduction xiii Part I Basic Concepts 1 Chapter 1 Integer Arithmetic 3 1.1 Example Program 3 1.2 Computer Program 4 1.3 Documentation 5 1.4 Input 6 1.5 Assignment Statement 7 1.5.1 Basics of assignment
Project 5 Due 11:59:59pm Tue, Dec 11, 2012
Project 5 Due 11:59:59pm Tue, Dec 11, 2012 Updates Dec 10 - Fixed X.new typos (should have been new X ). Changed error message for instantiation Bot; either the old or new error message is acceptable.
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine.
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine. 2. true / false ML can be compiled. 3. true / false FORTRAN can reasonably be considered
Programming Languages Lecture 15: Recursive Types & Subtyping
CSE 230: Winter 2008 Principles of Programming Languages Lecture 15: Recursive Types & Subtyping Ranjit Jhala UC San Diego News? Formalize first-order type systems Simple types (integers and booleans)
Inheritance and Substitution (Budd chapter 8, 10)
Inheritance and Substitution (Budd chapter 8, 10) 1 2 Plan The meaning of inheritance The syntax used to describe inheritance and overriding The idea of substitution of a child class for a parent The various
SEMANTIC ANALYSIS TYPES AND DECLARATIONS
SEMANTIC ANALYSIS CS 403: Type Checking Stefan D. Bruda Winter 2015 Parsing only verifies that the program consists of tokens arranged in a syntactically valid combination now we move to check whether
WA1278 Introduction to Java Using Eclipse
Lincoln Land Community College Capital City Training Center 130 West Mason Springfield, IL 62702 217-782-7436 www.llcc.edu/cctc WA1278 Introduction to Java Using Eclipse This course introduces the Java
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 10a Andrew Tolmach Portland State University 1994-2017 Object-oriented Programming Programs are structured in terms of objects: collections of variables
CSE 341, Spring 2011, Final Examination 9 June Please do not turn the page until everyone is ready.
CSE 341, Spring 2011, Final Examination 9 June 2011 Please do not turn the page until everyone is ready. Rules: The exam is closed-book, closed-note, except for one side of one 8.5x11in piece of paper.
CSCI-GA Scripting Languages
CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation
Scala : an LLVM-targeted Scala compiler
Scala : an LLVM-targeted Scala compiler Da Liu, UNI: dl2997 Contents 1 Background 1 2 Introduction 1 3 Project Design 1 4 Language Prototype Features 2 4.1 Language Features........................................
Introducing Wybe a language for everyone
Introducing Wybe a language for everyone Peter Schachte joint work with Matthew Giuca The University of Melbourne Department of Computing and Information Systems 4 December 2013 Peter Schachte (Melbourne)
CSE 341, Autumn 2015, Ruby Introduction Summary
CSE 341, Autumn 2015, Ruby Introduction Summary Disclaimer: This lecture summary is not necessarily a complete substitute for atting class, reading the associated code, etc. It is designed to be a useful
FreePascal changes: user documentation
FreePascal changes: user documentation Table of Contents Jochem Berndsen February 2007 1Introduction...1 2Accepted syntax...2 Declarations...2 Statements...3 Class invariants...3 3Semantics...3 Definitions,
Design and Evaluation of Gradual Typing for Python
Design and Evaluation of Gradual Typing for Python Michael M. Vitousek Andrew M. Kent Jeremy G. Siek Jim Baker Indiana University Bloomington Rackspace, Inc. October 21, 2014 1 / 18 Gradual typing def
Dependent Object Types - A foundation for Scala s type system
Dependent Object Types - A foundation for Scala s type system Draft of September 9, 2012 Do Not Distrubute Martin Odersky, Geoffrey Alan Washburn EPFL Abstract. 1 Introduction This paper presents a proposal
Recap: Functions as first-class values
Recap: Functions as first-class values Arguments, return values, bindings What are the benefits? Parameterized, similar functions (e.g. Testers) Creating, (Returning) Functions Iterator, Accumul, Reuse
Featherweight Java. Lecture 12 CS 565 3/18/08
Featherweight Java Lecture 12 CS 565 3/18/08 Objects vs Functions Will start exploring an object model that treats objects and classes as primitives Avoids some of the complexities faced when encoding
Project 6 Due 11:59:59pm Thu, Dec 10, 2015
Project 6 Due 11:59:59pm Thu, Dec 10, 2015 Updates None yet. Introduction In this project, you will add a static type checking system to the Rube programming language. Recall the formal syntax for Rube
Polymorphism. Lecture 19 CS 565 4/17/08
Polymorphism Lecture 19 CS 565 4/17/08 The Limitations of F 1 (simply-typed λ- calculus) In F 1 each function works exactly for one type Example: the identity function id = λx:τ. x : τ τ We need to write
Balancing Cost and Precision of Approximate Type Inference in Python
Thesis for the degree of Master of Science Balancing Cost and Precision of Approximate Type Inference in Python Levin Fritz Supervisor: prof. dr. S. D. Swierstra Daily supervisor: dr. J. Hage Utrecht,
Course Description. Learn To: : Intro to JAVA SE7 and Programming using JAVA SE7. Course Outline ::
Module Title Duration : Intro to JAVA SE7 and Programming using JAVA SE7 : 9 days Course Description The Java SE 7 Fundamentals course was designed to enable students with little or no programming experience
Index COPYRIGHTED MATERIAL
Index COPYRIGHTED MATERIAL Note to the Reader: Throughout this index boldfaced page numbers indicate primary discussions of a topic. Italicized page numbers indicate illustrations. A abstract classes
AP COMPUTER SCIENCE JAVA CONCEPTS IV: RESERVED WORDS
AP COMPUTER SCIENCE JAVA CONCEPTS IV: RESERVED WORDS PAUL L. BAILEY Abstract. This documents amalgamates various descriptions found on the internet, mostly from Oracle or Wikipedia. Very little of this
Program generation for schema-based, typed data access
Program generation for schema-based, typed data access Ralf Lämmel Software Engineer Facebook, London Program generation A use case at Facebook Purpose of generation: typed data access ("O/R mapping" et
CSE341 Spring 2017, Final Examination June 8, 2017
CSE341 Spring 2017, Final Examination June 8, 2017 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, etc. except for both sides of one 8.5x11in piece of paper. Please
Programming Languages
CSE 230: Winter 2008 Principles of Programming Languages Ocaml/HW #3 Q-A Session Push deadline = Mar 10 Session Mon 3pm? Lecture 15: Type Systems Ranjit Jhala UC San Diego Why Typed Languages? Development
Names, Scopes, and Bindings. CSE 307 Principles of Programming Languages Stony Brook University
Names, Scopes, and Bindings CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Names, Scopes, and Bindings Names are identifiers (mnemonic character
CS 240 Final Exam Review
CS 240 Final Exam Review Linux I/O redirection Pipelines Standard commands C++ Pointers How to declare How to use Pointer arithmetic new, delete Memory leaks C++ Parameter Passing modes value pointer reference
Improving Usability of Information Flow Security in Java
Improving Usability of Information Flow Security in Java Mark Thober Joint work with Scott F. Smith Department of Computer Science Johns Hopkins University PLAS 07 1 Motivation Information security is
Week. Lecture Topic day (including assignment/test) 1 st 1 st Introduction to Module 1 st. Practical
Name of faculty: Gaurav Gambhir Discipline: Computer Science Semester: 6 th Subject: CSE 304 N - Essentials of Information Technology Lesson Plan Duration: 15 Weeks (from January, 2018 to April, 2018)
CompuScholar, Inc. 9th - 12th grades
CompuScholar, Inc. Alignment to the College Board AP Computer Science A Standards 9th - 12th grades AP Course Details: Course Title: Grade Level: Standards Link: AP Computer Science A 9th - 12th grades
Names, Scopes, and Bindings. CSE 307 Principles of Programming Languages Stony Brook University
Names, Scopes, and Bindings CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Names, Scopes, and Bindings Names are identifiers (mnemonic character
https://asd-pa.perfplusk12.com/admin/admin_curric_maps_display.aspx?m=5507&c=618&mo=18917&t=191&sy=2012&bl...
Page 1 of 13 Units: - All - Teacher: ProgIIIJavaI, CORE Course: ProgIIIJavaI Year: 2012-13 Intro to Java How is data stored by a computer system? What does a compiler do? What are the advantages of using
JOURNAL OF OBJECT TECHNOLOGY
JOURNAL OF OBJECT TECHNOLOGY Online at http://www.jot.fm. Published by ETH Zurich, Chair of Software Engineering JOT, 2003 Vol. 2, No. 6, November-December 2003 The Theory of Classification Part 9: Inheritance
Semantic Analysis. Lecture 9. February 7, 2018
Semantic Analysis Lecture 9 February 7, 2018 Midterm 1 Compiler Stages 12 / 14 COOL Programming 10 / 12 Regular Languages 26 / 30 Context-free Languages 17 / 21 Parsing 20 / 23 Extra Credit 4 / 6 Average
A Short Summary of Javali
A Short Summary of Javali October 15, 2015 1 Introduction Javali is a simple language based on ideas found in languages like C++ or Java. Its purpose is to serve as the source language for a simple compiler
Instantiation of Template class
Class Templates Templates are like advanced macros. They are useful for building new classes that depend on already existing user defined classes or built-in types. Example: stack of int or stack of double
Project Overview. 1 Introduction. 2 A quick introduction to SOOL
CMSC 22600 Autumn 2016 Compilers for Computer Languages Handout 1 October 6, 2016 Project Overview 1 Introduction The project for the course is to implement a small object-oriented programming language,
CSE341 Spring 2017, Final Examination June 8, 2017
CSE341 Spring 2017, Final Examination June 8, 2017 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, etc. except for both sides of one 8.5x11in piece of paper. Please
Objects as Session-Typed Processes
Objects as Session-Typed Processes Stephanie Balzer and Frank Pfenning Computer Science Department, Carnegie Mellon University AGERE! 2015 The essence of object-orientation 2 The essence of object-orientation
Chapter 3 (part 3) Describing Syntax and Semantics
Chapter 3 (part 3) Describing Syntax and Semantics Chapter 3 Topics Introduction The General Problem of Describing Syntax Formal Methods of Describing Syntax Attribute Grammars Describing the Meanings
Second-Order Type Systems
#1 Second-Order Type Systems Homework 5 Summary Student : 37.9704 Student : 44.4466 ORIGINAL : 50.2442 Student : 50.8275 Student : 50.8633 Student : 50.9181 Student : 52.1347 Student : 52.1633 Student
Type Systems. Pierce Ch. 3, 8, 11, 15 CSE
Type Systems Pierce Ch. 3, 8, 11, 15 CSE 6341 1 A Simple Language ::= true false if then else 0 succ pred iszero Simple untyped expressions Natural numbers encoded as succ succ
JOURNAL OF OBJECT TECHNOLOGY
JOURNAL OF OBJECT TECHNOLOGY Online at www.jot.fm. Published by ETH Zurich, Chair of Software Engineering JOT, 2002 Vol. 1, No. 2, July-August 2002 The Theory of Classification Part 2: The Scratch-Built
How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk
How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk Oscar Callaú, Romain Robbes, Éric Tanter (University of Chile) David Röthlisberger (University of Bern) Proceedings
Java 8 Programming for OO Experienced Developers
www.peaklearningllc.com Java 8 Programming for OO Experienced Developers (5 Days) This course is geared for developers who have prior working knowledge of object-oriented programming languages such as
Method Resolution Approaches. Dynamic Dispatch
Method Resolution Approaches Static - procedural languages (w/o fcn ptrs) Dynamically determined by data values C with function pointers Compile-time analysis can estimate possible callees Dynamically
Inheritance (Chapter 7)
Inheritance (Chapter 7) Prof. Dr. Wolfgang Pree Department of Computer Science University of Salzburg cs.uni-salzburg.at Inheritance the soup of the day?! Inheritance combines three aspects: inheritance
The Substitution Model
The Substitution Model Prof. Clarkson Fall 2017 Today s music: Substitute by The Who Review Previously in 3110: simple interpreter for expression language abstract syntax tree (AST) evaluation based on
Fast Track to Core Java 8 Programming for OO Developers (TT2101-J8) Day(s): 3. Course Code: GK1965. Overview
Fast Track to Core Java 8 Programming for OO Developers (TT2101-J8) Day(s): 3 Course Code: GK1965 Overview Java 8 Essentials for OO Developers is a three-day, fast-paced, quick start to Java 8 training
Multi-paradigm Declarative Languages
Michael Hanus (CAU Kiel) Multi-paradigm Declarative Languages ICLP 2007 1 Multi-paradigm Declarative Languages Michael Hanus Christian-Albrechts-University of Kiel Programming Languages and Compiler Construction
Today. CSE341: Programming Languages. Late Binding in Ruby Multiple Inheritance, Interfaces, Mixins. Ruby instance variables and methods
Today CSE341: Programming Languages Late Binding in Ruby Multiple Inheritance, Interfaces, Mixins Alan Borning Spring 2018 Dynamic dispatch aka late binding aka virtual method calls Call to self.m2() in
Design Principles for a Beginning Programming Language
Design Principles for a Beginning Programming Language John T Minor and Laxmi P Gewali School of Computer Science University of Nevada, Las Vegas Abstract: We consider the issue of designing an appropriate
CSE 12 Abstract Syntax Trees
CSE 12 Abstract Syntax Trees Compilers and Interpreters Parse Trees and Abstract Syntax Trees (AST's) Creating and Evaluating AST's The Table ADT and Symbol Tables 16 Using Algorithms and Data Structures
Lambda Calculus. Variables and Functions. cs3723 1
Lambda Calculus Variables and Functions cs3723 1 Lambda Calculus Mathematical system for functions Computation with functions Captures essence of variable binding Function parameters and substitution Can
Principles of Programming Languages
Principles of Programming Languages www.cs.bgu.ac.il/~ppl172 Lesson 4 - Type Checking Collaboration and Management Dana Fisman 1 Why declare types? Declaring types allows the compiler to detect errors
Informatica 3 Syntax and Semantics
Informatica 3 Syntax and Semantics Marcello Restelli 9/15/07 Laurea in Ingegneria Informatica Politecnico di Milano Introduction Introduction to the concepts of syntax and semantics Binding Variables Routines
The Compiler So Far. CSC 4181 Compiler Construction. Semantic Analysis. Beyond Syntax. Goals of a Semantic Analyzer.
The Compiler So Far CSC 4181 Compiler Construction Scanner - Lexical analysis Detects inputs with illegal tokens e.g.: main 5 (); Parser - Syntactic analysis Detects inputs with ill-formed parse trees
More Untyped Lambda Calculus & Simply Typed Lambda Calculus
Concepts in Programming Languages Recitation 6: More Untyped Lambda Calculus & Simply Typed Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky,