Static Analysis of Dynamically Typed Languages made Easy
|
|
|
- Elinor Hood
- 6 years ago
- Views:
Transcription
1 Static Analysis of Dynamically Typed Languages made Easy Yin Wang School of Informatics and Computing Indiana University
2 Overview Work done as two internships at Google (2009 summer and 2010 summer) Motivation: The Grok Project: static analysis of all code at Google (C++, Java, JavaScript, Python, Sawzall, Protobuf ) Initial goal was not ambitious: Implement IDE- like code- browsing Turns out to be hard for Python
3 Achieved Goals Build high- accuracy semantic indexes Detect and report semantic bugs type errors missing return statement unreachable code
4 Demo Time Go
5 Problems Faced by Static Analysis of Dynamically Typed Languages
6 1. Problems with Dynamic Typing Dynamic typing makes it hard to resolve some names Mostly happen in polymorphic functions def h(x): return x.z
7 1. Problems with Dynamic Typing Dynamic typing makes it hard to resolve some names Mostly happen in polymorphic functions def h(x): return x.z Q: Where is z defined? A: wherever we defined x
8 1. Problems with Dynamic Typing Dynamic typing makes it hard to resolve some names Mostly happen in polymorphic functions def h(x): return x.z Q: What is x? A: Uhh Q: Where is z defined? A: wherever we defined x
9 1. Problems with Dynamic Typing Dynamic typing makes it hard to resolve some names Mostly happen in polymorphic functions def h(x): return x.z Q: What is x? A: Uhh Solution: use a static type system use inter- procedural analysis to infer types Q: Where is z defined? A: wherever we defined x
10 Static Type System for Python Mostly a usual type system, with two extras: union and dict primitive types int, str, float, bool tuple types (int,float), (A, B, C) list types [int], [bool], [(int,bool)] dict types {int => str}, {A => B} class types ClassA, ClassB union types {int str}, {A B C} recursive types #1(int, 1), #2(int - > 2) function types int - > bool, A - > B
11 2. Problems with Control- Flow Graph CFGs are tricky to build for high- order programs Attempts to build CFGs have led to complications and limitations in control- flow analysis Shivers 1988, 1991 build CFG after CPS Might & Shivers 2006,2007 solve problems introduced by CFG Vardoulakis & Shivers 2010,2011 solve problems introduced by CPS def g(f,x): return f(x) def h1(x): return x+1 def h2(x): return x+2
12 2. Problems with Control- Flow Graph Where is the CFG target? CFGs are tricky to build for high- order programs Attempts to build CFGs have led to complications and limitations in control- flow analysis Shivers 1988, 1991 build CFG after CPS Might & Shivers 2006,2007 solve problems introduced by CFG Vardoulakis & Shivers 2010,2011 solve problems introduced by CPS def g(f,x): return f(x) def h1(x): return x+1 def h2(x): return x+2
13 2. Problems with Control- Flow Graph Where is the CFG target? CFGs are tricky to build for high- order programs Attempts to Solution: build CFGs have led to complications and Don t limitations CPS the input in program control- flow analysis Don t try constructing the CFG Use direct- style, recursive abstract interpreter Shivers 1988, 1991 build CFG after CPS Might & Shivers 2006,2007 solve problems introduced by CFG Vardoulakis & Shivers 2010,2011 solve problems introduced by CPS def g(f,x): return f(x) def h1(x): return x+1 def h2(x): return x+2
14 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y
15 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution:
16 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution:
17 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution: create abstract objects at constructor calls
18 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution: create abstract objects at constructor calls
19 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution: create abstract objects at constructor calls Actually change the abstract objects when fields are created
20 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution: create abstract objects at constructor calls Actually change the abstract objects when fields are created
21 3. Problems with Dynamic Field Creation/ Deletion class A: x = 1 obj = A() obj.y = 3 print obj.x, obj.y Solution: create abstract objects at constructor calls Actually change the abstract objects when fields are created Classes are not affect by the change
22 4. Problems with More Powerful Dynamic Features direct operations on dict (e.g. setattr, delattr, ) dynamic object reparenting import hacks eval
23 4. Problems with More Powerful Dynamic Features direct operations on dict (e.g. setattr, delattr, ) dynamic object reparenting import hacks eval Solution: Python Style Guide
24 Overall Structure of Analysis AST node (Expr) Type Env (Env) Stack (Env) Abstract Interpreter (AI) - (Expr,Env,Stk) - > Type Type
25 Overall Structure of Analysis AST node (Expr) Type Env (Env) Stack (Env) direct- style recursive Abstract Interpreter (AI) - (Expr,Env,Stk) - > Type Type
26 Overall Structure of Analysis AST node (Expr) Type Env (Env) Stack (Env) direct- style recursive Abstract Interpreter (AI) - (Expr,Env,Stk) - > Type during execution Global Information Table (GIT) { x@1 :: int, f@12 :: int - > bool, z@23 :: unbound variable } Type
27 Overall Structure of Analysis direct- style (not CPSed) no CFG generated keep it clean (don t record anything on it) AST node (Expr) Type Env (Env) Stack (Env) direct- style recursive Abstract Interpreter (AI) - (Expr,Env,Stk) - > Type during execution Global Information Table (GIT) { x@1 :: int, f@12 :: int - > bool, z@23 :: unbound variable } Type
28 Overall Structure of Analysis direct- style (not CPSed) no CFG generated keep it clean (don t record anything on it) AST node (Expr) Type Env (Env) Stack (Env) direct- style recursive loop detection (using stack) Abstract Interpreter (AI) - (Expr,Env,Stk) - > Type during execution Global Information Table (GIT) { x@1 :: int, f@12 :: int - > bool, z@23 :: unbound variable } Type
29 Actual Code of Main Interpreter
30 Actual Code of Main Interpreter input expression type environment stack of nodes on path (recursion detection)
31 Actual Code of Main Interpreter input expression type environment stack of nodes on path (recursion detection) lookup variable s type reocord type to GIT return a type
32 Actual Code of Main Interpreter input expression type environment stack of nodes on path (recursion detection) lookup variable s type reocord type to GIT return a type record error to GIT
33 Actual Code of Main Interpreter input expression type environment stack of nodes on path (recursion detection) lookup variable s type reocord type to GIT make closures for functions return a type invoke function (closure) record error to GIT
34 Multiple- Worlds Model HardQuestion()? x = 1 y = hello x = false y = 2.3 z = x + y
35 Multiple- Worlds Model HardQuestion()? split world x = 1 y = hello x = false y = 2.3 z = x + y
36 Multiple- Worlds Model HardQuestion()? split world x = 1 y = hello x = false y = 2.3 x : int y : str x : bool y : float z = x + y
37 Multiple- Worlds Model HardQuestion()? split world x = 1 y = hello x = false y = 2.3 x : int y : str x : bool y : float merge world z = x + y
38 Multiple- Worlds Model HardQuestion()? split world x = 1 y = hello x = false y = 2.3 x : int y : str x : bool y : float merge world z = x + y x : { int bool } y : { str float }
39 Multiple- Worlds Model HardQuestion()? split world x = 1 y = hello x = false y = 2.3 Clone the state for backtracing x : int y : str x : bool y : float merge world z = x + y x : { int bool } y : { str float }
40 Recursion Detection (1) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5)
41 Recursion Detection (1) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) Assumption: the same call site with the same argument types always produces the same output type (or nontermination)
42 Recursion Detection (1) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@7, int> return n * fact(n- 1) Assumption: the same call site with the same argument types always produces the same output type (or nontermination)
43 Recursion Detection (1) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@7, int> return n * fact(n- 1) Assumption: the same call site with the same argument types always produces the same output type (or nontermination) fact@7 may return int
44 Recursion Detection (1) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@7, int> return n * fact(n- 1) Assumption: the same call site with the same argument types always produces the same output type (or nontermination) fact@7 may return int < fact@5, int>
45 Recursion Detection (1) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@7, int> return n * fact(n- 1) not on stack not a loop Assumption: the same call site with the same argument types always produces the same output type (or nontermination) fact@7 may return int < fact@5, int>
46 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5)
47 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return n * fact(n- 1)
48 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return n * fact(n- 1) fact@5 may return int
49 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return n * fact(n- 1) fact@5 may return int < fact@5, int>
50 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return n * fact(n- 1) on stack loop detected! fact@5 may return int < fact@5, int>
51 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return unknown type return n * fact(n- 1) on stack loop detected! fact@5 may return int < fact@5, int>
52 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return unknown type return n * fact(n- 1) on stack loop detected! fact@5 may return int return unknown type and unify with int (possible false- negative here) < fact@5, int>
53 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return unknown type return n * fact(n- 1) on stack loop detected! fact@5 may return int return unknown type and unify with int (possible false- negative here) < fact@5, int> Call fact@5 returns int finally Record fact@5 :: int
54 Recursion Detection (2) 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) return 1 n = 0? < fact@5, int> < fact@7, int> return unknown type return n * fact(n- 1) on stack loop detected! Call fact@7 returns int finally Record fact@1:: int - > int fact@5 may return int Call fact@5 returns int finally Record fact@5 :: int return unknown type and unify with int (possible false- negative here) < fact@5, int>
55 Correctness of Recursion Detection Every program is a dynamic circuit 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) Every call site is a conjuction point in the dynamic circuit, because it connects to an instance of a function body The same call site with the same arguments is a unique joint point in the process graph, with a deterministic future If the same <call site, argument type> combination has appear before in the path, there must be a loop
56 Correctness of Recursion Detection Every program is a dynamic circuit 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: 5: return n * fact(n- 1) 6: 7: fact(5) Every call site is a conjuction point in the dynamic circuit, because it connects to an instance of a function body The same call site with the same arguments is a unique joint point in the process graph, with a deterministic future If the same <call site, argument type> combination has appear before in the path, there must be a loop
57 Correctness of Recursion Detection Every program is a dynamic circuit 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: <fact@5, int> 5: return n * fact(n- 1) 6: 7: fact(5) Every call site is a conjuction point in the dynamic circuit, because it connects to an instance of a function body The same call site with the same arguments is a unique joint point in the process graph, with a deterministic future If the same <call site, argument type> combination has appear before in the path, there must be a loop
58 Correctness of Recursion Detection Every program is a dynamic circuit 1: def fact(n): 2: if (n == 0): 3: return 1 4: else: <fact@5, int> 5: return n * fact(n- 1) 6: 7: fact(5) Every call site is a conjuction point in the dynamic circuit, because it connects to an instance of a function body The same call site with the same arguments is a unique joint point in the process graph, with a deterministic future If the same <call site, argument type> combination has appear before in the path, there must be a loop
59 Related Work Similar to control- flow analyses, but much simpler No need to build CFG (as in original CFAs) No need to maintain stack manually (as in CFA2) CFG here is dynamic and implicit (maybe impossible to build statically) Doesn t record any information on the AST Recursive style leads to full utilization of host language Much simpler than type inferencer of JSCompiler (Google s type inference and static checker for JavaScript) JSCompiler also needs type annotations, iirc Very similar to NCI (Near Concrete Interpretation) But using another way to detect recursion
60 Connections to Deeper Theories In essence, the analysis is doing a simple version of supercompilation Similar to technique used by automatic theorem provers such as ACL2 Does not track as much information (only type information is tracked) Termination technique is more efficient (no expensive homeomorphic embedding checks).. but may not be as accurate may cause false- negatives!
61 Limitations Doesn t process bytecode. Needs all source code to be available (except for built- ins which was hard- coded or mocked) Does not track value/range of numbers Does not track heap storage (assume side- effects on heap won t affect typing) May produce false- negatives at recursions Worst- case complexity is high More approximations can be used to improve efficiency (at the cost of reducing accuracy) Error reports are not user- friendly for deep bugs
62 Applicability A general way of type inference/static analysis Can be applied to any programming language More useful for dynamic languages because type annotations of static languages make it a lot easier and more modular There are always trade- offs though
63 Availability 2009 version Jython Indexer (in Java, open- source) modular analysis with unification (similar to HM system) can t resolve some names fast currently used by Google for building code index open- sourced to Jython 2010 version PySonar (in Java, not open- source) inter- procedural analysis can resolve most names can detect deeper semantic bugs slow 2011 version mini- pysonar (in Python, open- source) available from GitHub contains only the essential parts for illustrating the idea
64 Possible Future Work Apply the technique to other (hopefully simpler) languages Publish a paper about the general method Derive other ideas from the same intuition
65 Thank you!
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
Compilers and computer architecture: Semantic analysis
1 / 1 Compilers and computer architecture: Semantic analysis Martin Berger Alex Jeffery October 2018 Recall the function of compilers 2 / 1 3 / 1 Recall the structure of compilers Source program Lexical
Interprocedural Analysis with Data-Dependent Calls. Circularity dilemma. A solution: optimistic iterative analysis. Example
Interprocedural Analysis with Data-Dependent Calls Circularity dilemma In languages with function pointers, first-class functions, or dynamically dispatched messages, callee(s) at call site depend on data
Type Soundness. Type soundness is a theorem of the form If e : τ, then running e never produces an error
Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces an error 1 Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces
Interprocedural Analysis with Data-Dependent Calls. Circularity dilemma. A solution: optimistic iterative analysis. Example
Interprocedural Analysis with Data-Dependent Calls Circularity dilemma In languages with function pointers, first-class functions, or dynamically dispatched messages, callee(s) at call site depend on data
Logic-Flow Analysis of Higher-Order Programs
Logic-Flow Analysis of Higher-Order Programs Matt Might http://matt.might.net/ POPL 2007 Why? Tim Sweeney, POPL 2006 Static array-bounds checking. Example... a[i]... Will 0 i < a.length always hold? 3
Announcements. Working on requirements this week Work on design, implementation. Types. Lecture 17 CS 169. Outline. Java Types
Announcements Types Working on requirements this week Work on design, implementation Lecture 17 CS 169 Prof. Brewer CS 169 Lecture 16 1 Prof. Brewer CS 169 Lecture 16 2 Outline Type concepts Where do types
CSCI 3155: Principles of Programming Languages Exam preparation #1 2007
CSCI 3155: Principles of Programming Languages Exam preparation #1 2007 Exercise 1. Consider the if-then-else construct of Pascal, as in the following example: IF 1 = 2 THEN PRINT X ELSE PRINT Y (a) Assume
Lecture #23: Conversion and Type Inference
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). Last modified: Fri Oct 20 10:46:40 2006 CS164:
Conversion vs. Subtyping. Lecture #23: Conversion and Type Inference. Integer Conversions. Conversions: Implicit vs. Explicit. Object x = "Hello";
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). In Java, this is legal: Object x = "Hello";
Writing Evaluators MIF08. Laure Gonnord
Writing Evaluators MIF08 Laure Gonnord Laure.Gonnord@univ-lyon1.fr Evaluators, what for? Outline 1 Evaluators, what for? 2 Implementation Laure Gonnord (Lyon1/FST) Writing Evaluators 2 / 21 Evaluators,
Syntax and Grammars 1 / 21
Syntax and Grammars 1 / 21 Outline What is a language? Abstract syntax and grammars Abstract syntax vs. concrete syntax Encoding grammars as Haskell data types What is a language? 2 / 21 What is a language?
CMSC 330: Organization of Programming Languages. OCaml Expressions and Functions
CMSC 330: Organization of Programming Languages OCaml Expressions and Functions CMSC330 Spring 2018 1 Lecture Presentation Style Our focus: semantics and idioms for OCaml Semantics is what the language
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
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,
Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End
Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors
Operational Semantics. One-Slide Summary. Lecture Outline
Operational Semantics #1 One-Slide Summary Operational semantics are a precise way of specifying how to evaluate a program. A formal semantics tells you what each expression means. Meaning depends on context:
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures. Dan Grossman Autumn 2018
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures Dan Grossman Autumn 2018 Typical workflow concrete syntax (string) "(fn x => x + x) 4" Parsing Possible errors / warnings
Lecture Outline. COOL operational semantics. Operational Semantics of Cool. Motivation. Notation. The rules. Evaluation Rules So Far.
Lecture Outline Operational Semantics of Cool COOL operational semantics Motivation Adapted from Lectures by Profs. Alex Aiken and George Necula (UCB) Notation The rules CS781(Prasad) L24CG 1 CS781(Prasad)
Compiler Optimisation
Compiler Optimisation 3 Dataflow Analysis Hugh Leather IF 1.18a hleather@inf.ed.ac.uk Institute for Computing Systems Architecture School of Informatics University of Edinburgh 2018 Introduction Optimisations
INF 102 CONCEPTS OF PROG. LANGS FUNCTIONAL COMPOSITION. Instructors: James Jones Copyright Instructors.
INF 102 CONCEPTS OF PROG. LANGS FUNCTIONAL COMPOSITION Instructors: James Jones Copyright Instructors. Topics Recursion Higher-order functions Continuation-Passing Style Monads (take 1) Identity Monad
INF 212 ANALYSIS OF PROG. LANGS FUNCTION COMPOSITION. Instructors: Crista Lopes Copyright Instructors.
INF 212 ANALYSIS OF PROG. LANGS FUNCTION COMPOSITION Instructors: Crista Lopes Copyright Instructors. Topics Recursion Higher-order functions Continuation-Passing Style Monads (take 1) Identity Monad Maybe
Encoding functions in FOL. Where we re at. Ideally, would like an IF stmt. Another example. Solution 1: write your own IF. No built-in IF in Simplify
Where we re at We explored the three standard logics, and compared them along three dimensions expressiveness automation human-friendliness Next we ll look in more detail at FOL we will explore how to
Hard deadline: 3/28/15 1:00pm. Using software development tools like source control. Understanding the environment model and type inference.
CS 3110 Spring 2015 Problem Set 3 Version 0 (last modified March 12, 2015) Soft deadline: 3/26/15 11:59pm Hard deadline: 3/28/15 1:00pm Overview In this assignment you will implement several functions
Lecture Compiler Middle-End
Lecture 16-18 18 Compiler Middle-End Jianwen Zhu Electrical and Computer Engineering University of Toronto Jianwen Zhu 2009 - P. 1 What We Have Done A lot! Compiler Frontend Defining language Generating
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
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
CS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 3a Andrew Tolmach Portland State University 1994-2016 Formal Semantics Goal: rigorous and unambiguous definition in terms of a wellunderstood formalism (e.g.
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
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
(Refer Slide Time: 4:00)
Principles of Programming Languages Dr. S. Arun Kumar Department of Computer Science & Engineering Indian Institute of Technology, Delhi Lecture - 38 Meanings Let us look at abstracts namely functional
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 4a Andrew Tolmach Portland State University 1994-2017 Semantics and Erroneous Programs Important part of language specification is distinguishing valid from
Static Program Analysis Part 9 pointer analysis. Anders Møller & Michael I. Schwartzbach Computer Science, Aarhus University
Static Program Analysis Part 9 pointer analysis Anders Møller & Michael I. Schwartzbach Computer Science, Aarhus University Agenda Introduction to points-to analysis Andersen s analysis Steensgaards s
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
Project 5 Due 11:59:59pm Wed, July 16, 2014
Project 5 Due 11:59:59pm Wed, July 16, 2014 Updates Apr 1. Clarified that built-in methods can t be overridden, and that the evaluation order for send is slightly different than normal method call. Mar
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)
Comp 411 Principles of Programming Languages Lecture 3 Parsing. Corky Cartwright January 11, 2019
Comp 411 Principles of Programming Languages Lecture 3 Parsing Corky Cartwright January 11, 2019 Top Down Parsing What is a context-free grammar (CFG)? A recursive definition of a set of strings; it is
Soot A Java Bytecode Optimization Framework. Sable Research Group School of Computer Science McGill University
Soot A Java Bytecode Optimization Framework Sable Research Group School of Computer Science McGill University Goal Provide a Java framework for optimizing and annotating bytecode provide a set of API s
The role of semantic analysis in a compiler
Semantic Analysis Outline The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors
django-dynamic-db-router Documentation
django-dynamic-db-router Documentation Release 0.1.1 Erik Swanson August 24, 2016 Contents 1 Table of Contents 3 1.1 Installation................................................ 3 1.2 Quickstart................................................
Collage of Static Analysis
Course Outline Collage of Static Analysis 0.5hr: Static Analysis Overview 1.5hr: Static Analysis Design Framework 1.0hr: Static Analysis Engineering Framework 1.0hr: Static Analysis of Multi-Staged Programs
CS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 7a Andrew Tolmach Portland State University 1994-2016 Values and Types We divide the universe of values according to types A type is a set of values and a
Objects CHAPTER 6. FIGURE 1. Concrete syntax for the P 3 subset of Python. (In addition to that of P 2.)
CHAPTER 6 Objects The main ideas for this chapter are: objects and classes: objects are values that bundle together some data (attributes) and some functions (methods). Classes are values that describe
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,
Programs as data Parsing cont d; first-order functional language, type checking
Programs as data Parsing cont d; first-order functional language, type checking Peter Sestoft Monday 2009-09-14 Plan for today Exercises week 2 Parsing: LR versus LL How does an LR parser work Hand-writing
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
Guido van Rossum 9th LASER summer school, Sept. 2012
Guido van Rossum guido@python.org 9th LASER summer school, Sept. 2012 Static analysis for Python is hard There are no good current tools There are a number of lint-like tools Some IDEs have some refactoring
7. Introduction to Denotational Semantics. Oscar Nierstrasz
7. Introduction to Denotational Semantics Oscar Nierstrasz Roadmap > Syntax and Semantics > Semantics of Expressions > Semantics of Assignment > Other Issues References > D. A. Schmidt, Denotational Semantics,
Beyond Blocks: Python Session #1
Beyond Blocks: Session #1 CS10 Spring 2013 Thursday, April 30, 2013 Michael Ball Beyond Blocks : : Session #1 by Michael Ball adapted from Glenn Sugden is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike
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
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
Object Model Comparisons
Object Model Comparisons 1 Languages are designed, just like programs Someone decides what the language is for Someone decides what features it's going to have Can't really understand a language until
The design of a programming language for provably correct programs: success and failure
The design of a programming language for provably correct programs: success and failure Don Sannella Laboratory for Foundations of Computer Science School of Informatics, University of Edinburgh http://homepages.inf.ed.ac.uk/dts
Programs as data first-order functional language type checking
Programs as data first-order functional language type checking Copyright 2013-18, Peter Sestoft and Cesare Tinelli. Created by Cesare Tinelli at the University of Iowa from notes originally developed by
Key components of a lang. Deconstructing OCaml. In OCaml. Units of computation. In Java/Python. In OCaml. Units of computation.
Key components of a lang Deconstructing OCaml What makes up a language Units of computation Types Memory model In OCaml Units of computation In OCaml In Java/Python Expressions that evaluate to values
CS1622. Semantic Analysis. The Compiler So Far. Lecture 15 Semantic Analysis. How to build symbol tables How to use them to find
CS1622 Lecture 15 Semantic Analysis CS 1622 Lecture 15 1 Semantic Analysis How to build symbol tables How to use them to find multiply-declared and undeclared variables. How to perform type checking CS
Types and Type Inference
CS 242 2012 Types and Type Inference Notes modified from John Mitchell and Kathleen Fisher Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on Web!! Outline General discussion of
A First Look at ML. Chapter Five Modern Programming Languages, 2nd ed. 1
A First Look at ML Chapter Five Modern Programming Languages, 2nd ed. 1 ML Meta Language One of the more popular functional languages (which, admittedly, isn t saying much) Edinburgh, 1974, Robin Milner
Python Implementation Strategies. Jeremy Hylton Python / Google
Python Implementation Strategies Jeremy Hylton Python / Google Python language basics High-level language Untyped but safe First-class functions, classes, objects, &c. Garbage collected Simple module system
Lecture Outline. COOL operational semantics. Operational Semantics of Cool. Motivation. Lecture 13. Notation. The rules. Evaluation Rules So Far
Lecture Outline Operational Semantics of Cool Lecture 13 COOL operational semantics Motivation Notation The rules Prof. Aiken CS 143 Lecture 13 1 Prof. Aiken CS 143 Lecture 13 2 Motivation We must specify
CSE 431S Final Review. Washington University Spring 2013
CSE 431S Final Review Washington University Spring 2013 What You Should Know The six stages of a compiler and what each stage does. The input to and output of each compilation stage (especially the back-end).
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
Type Checking and Type Inference
Type Checking and Type Inference Principles of Programming Languages CSE 307 1 Types in Programming Languages 2 Static Type Checking 3 Polymorphic Type Inference Version: 1.8 17:20:56 2014/08/25 Compiled
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
Exceptions & a Taste of Declarative Programming in SQL
Exceptions & a Taste of Declarative Programming in SQL David E. Culler CS8 Computational Structures in Data Science http://inst.eecs.berkeley.edu/~cs88 Lecture 12 April 18, 2016 Computational Concepts
Semantic Processing (Part 2)
Semantic Processing (Part 2) All Projects Due: Fray 12-2-05, Noon Final: Monday, December 5, 2005, 10:15-12:05 Comprehensive 1 Recursive Type Definitions MyRec is record f1: integer; f2: array of MyRec;
Overloading, Type Classes, and Algebraic Datatypes
Overloading, Type Classes, and Algebraic Datatypes Delivered by Michael Pellauer Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. September 28, 2006 September 28, 2006 http://www.csg.csail.mit.edu/6.827
Types and Type Inference
Types and Type Inference Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Reading: Concepts in Programming Languages, Revised Chapter 6 - handout on the course homepage Outline General discussion
Compilers. Type checking. Yannis Smaragdakis, U. Athens (original slides by Sam
Compilers Type checking Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Summary of parsing Parsing A solid foundation: context-free grammars A simple parser: LL(1) A more powerful parser:
Introduction to Functional Programming in Haskell 1 / 56
Introduction to Functional Programming in Haskell 1 / 56 Outline Why learn functional programming? The essence of functional programming What is a function? Equational reasoning First-order vs. higher-order
Discussion 12 The MCE (solutions)
Discussion 12 The MCE (solutions) ;;;;METACIRCULAR EVALUATOR FROM CHAPTER 4 (SECTIONS 4.1.1-4.1.4) of ;;;; STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS ;;;from section 4.1.4 -- must precede def of
CS153: Compilers Lecture 14: Type Checking
CS153: Compilers Lecture 14: Type Checking Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Project 4 out Due Thursday Oct 25 (7 days) Project 5 out Due Tuesday Nov 13 (26 days) Project
Values (a.k.a. data) representation. Advanced Compiler Construction Michel Schinz
Values (a.k.a. data) representation Advanced Compiler Construction Michel Schinz 2016 03 10 The problem Values representation A compiler must have a way of representing the values of the source language
Values (a.k.a. data) representation. The problem. Values representation. The problem. Advanced Compiler Construction Michel Schinz
Values (a.k.a. data) representation The problem Advanced Compiler Construction Michel Schinz 2016 03 10 1 2 Values representation The problem A compiler must have a way of representing the values of the
CSCE 314 Programming Languages. Type System
CSCE 314 Programming Languages Type System Dr. Hyunyoung Lee 1 Names Names refer to different kinds of entities in programs, such as variables, functions, classes, templates, modules,.... Names can be
Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler so far
Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Statically vs. Dynamically typed languages
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,
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
CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11
CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11 CS 536 Spring 2015 1 Handling Overloaded Declarations Two approaches are popular: 1. Create a single symbol table
Verified compilers. Guest lecture for Compiler Construction, Spring Magnus Myréen. Chalmers University of Technology
Guest lecture for Compiler Construction, Spring 2015 Verified compilers Magnus Myréen Chalmers University of Technology Mentions joint work with Ramana Kumar, Michael Norrish, Scott Owens and many more
A Practical Optional Type System for Clojure. Ambrose Bonnaire-Sergeant
A Practical Optional Type System for Clojure Ambrose Bonnaire-Sergeant Statically typed vs. Dynamically typed Traditional distinction Dynamically typed Statically typed eg. Java, C, Haskell eg. Javascript,
Operational Semantics of Cool
Operational Semantics of Cool Key Concepts semantics: the meaning of a program, what does program do? how the code is executed? operational semantics: high level code generation steps of calculating values
CA Compiler Construction
CA4003 - Compiler Construction Semantic Analysis David Sinclair Semantic Actions A compiler has to do more than just recognise if a sequence of characters forms a valid sentence in the language. It must
CS558 Programming Languages
CS558 Programming Languages Fall 2017 Lecture 3a Andrew Tolmach Portland State University 1994-2017 Binding, Scope, Storage Part of being a high-level language is letting the programmer name things: variables
Typical workflow. CSE341: Programming Languages. Lecture 17 Implementing Languages Including Closures. Reality more complicated
Typical workflow concrete synta (string) "(fn => + ) 4" Parsing CSE341: Programming Languages abstract synta (tree) Lecture 17 Implementing Languages Including Closures Function Constant + 4 Var Var Type
Intrinsically Typed Reflection of a Gallina Subset Supporting Dependent Types for Non-structural Recursion of Coq
Intrinsically Typed Reflection of a Gallina Subset Supporting Dependent Types for Non-structural Recursion of Coq Akira Tanaka National Institute of Advanced Industrial Science and Technology (AIST) 2018-11-21
OOPLs - call graph construction. Example executed calls
OOPLs - call graph construction Compile-time analysis of reference variables and fields Problem: how to resolve virtual function calls? Need to determine to which objects (or types of objects) a reference
CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.
CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:
Type Inference. Prof. Clarkson Fall Today s music: Cool, Calm, and Collected by The Rolling Stones
Type Inference Prof. Clarkson Fall 2016 Today s music: Cool, Calm, and Collected by The Rolling Stones Review Previously in 3110: Interpreters: ASTs, evaluation, parsing Formal syntax Formal semantics
Semantic Processing (Part 2)
Semantic Processing (Part 2) All Projects Due: Fray 12-2-05, Noon Final: Monday, December 5, 2005, 10:15-12:05 Comprehensive 1 Recursive Type Definitions type MyRec is record f1: integer; f2: array of
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Operational Semantics CMSC 330 Summer 2018 1 Formal Semantics of a Prog. Lang. Mathematical description of the meaning of programs written in that language
Lecture #12: Quick: Exceptions and SQL
UC Berkeley EECS Adj. Assistant Prof. Dr. Gerald Friedland Computational Structures in Data Science Lecture #12: Quick: Exceptions and SQL Administrivia Open Project: Starts Monday! Creative data task
CSE 341: Programming Languages
CSE 341: Programming Languages Winter 2005 Lecture 17 varargs and apply, implementing higher-order functions CSE341 Winter 2005, Lecture 17 1 Today: Some easy Scheme odds and ends Implementing higher-order
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.
Outline. Introduction Concepts and terminology The case for static typing. Implementing a static type system Basic typing relations Adding context
Types 1 / 15 Outline Introduction Concepts and terminology The case for static typing Implementing a static type system Basic typing relations Adding context 2 / 15 Types and type errors Type: a set of
CS61A Lecture 38. Robert Huang UC Berkeley April 17, 2013
CS61A Lecture 38 Robert Huang UC Berkeley April 17, 2013 Announcements HW12 due Wednesday Scheme project, contest out Review: Program Generator A computer program is just a sequence of bits It is possible
Project 4 Due 11:59:59pm Thu, May 10, 2012
Project 4 Due 11:59:59pm Thu, May 10, 2012 Updates Apr 30. Moved print() method from Object to String. Apr 27. Added a missing case to assembler.ml/build constants to handle constant arguments to Cmp.
CS-XXX: Graduate Programming Languages. Lecture 9 Simply Typed Lambda Calculus. Dan Grossman 2012
CS-XXX: Graduate Programming Languages Lecture 9 Simply Typed Lambda Calculus Dan Grossman 2012 Types Major new topic worthy of several lectures: Type systems Continue to use (CBV) Lambda Caluclus as our
Test I Solutions MASSACHUSETTS INSTITUTE OF TECHNOLOGY Spring Department of Electrical Engineering and Computer Science
Department of Electrical Engineering and Computer Science MASSACHUSETTS INSTITUTE OF TECHNOLOGY 6.035 Spring 2013 Test I Solutions Mean 83 Median 87 Std. dev 13.8203 14 12 10 8 6 4 2 0 0 10 20 30 40 50
Simon Peyton Jones Microsoft Research August 2013
Simon Peyton Jones Microsoft Research August 2013 reverse :: a. [a] -> [a] xs :: [Bool] foo :: [Bool] foo = reverse xs Instantiate reverse with a unification variable, standing for an as-yet-unknown type.