Produced by. ICT Skills Summer School. Eamonn de Leastar Department of Computing, Maths & Physics Waterford Institute of Technology
|
|
|
- Sibyl Thomas
- 5 years ago
- Views:
Transcription
1 ICT Skills Summer School Produced b Eamonn de Leastar edeleastar@wit.ie Department of Computing, Maths & Phsics Waterford Institute of Technolog
2 Tping in Programming Languages
3 Language Famil Trees
4 Famil Tree (3) 4
5 Smalltalk Cluster 5
6 Rub, Groov, Java, Scala Cluster 6
7
8 Objective-C Self Scala Groov Swift Go Javascript
9 Paul Grahams Wish List for a Programming Language 1.Conditionals 2.A function tpe 3.Recursion 4.Dnamic tping 5.Garbage collection Lisp programming Language has all of these features (since mid 1960 s) 6.Programs composed of expressions 7.A smbol tpe 8.A notation for code using smbols and trees 9.The whole language there all the time 9
10 Java? 1.Conditionals 2.A function tpe (Java 8 onl) 3.Recursion 4.Dnamic tping 5.Garbage collection 6.Programs composed of expressions 7.A smbol tpe 8.A notation for code using smbols and trees 9.The whole language there all the time 10
11 Groov/Rub/Pthon/Scala/Javascript (from Neal Ford) 1.Conditionals 2.A function tpe 3.Recursion 4.Dnamic tping (+ Tpe Inference) 5.Garbage collection + Metaprogramming 6.Programs composed of expressions 7.A smbol tpe 8.A notation for code using smbols and trees 9.The whole language there all the time 11
12 Groov/Rub/Pthon/Scala/Javascript (from Neal Ford) 1.Conditionals 2.A function tpe 3.Recursion 4.Dnamic tping (+Tpe Inference) 5.Garbage collection + Metaprogramming 6.Programs composed of expressions 7.A smbol tpe 8.A notation for code using smbols and trees 9.The whole language there all the time 12
13 Tping 13
14
15
16 Another Approach to Tpes? Tpe Inference : the compiler draws conclusions about the tpes of variables based on how programmers use those variables. Yields programs that have some of the conciseness of Dnamicall Tped Languages But - decision made at compile time, not at run time More information for static analsis - refactoring tools, complexit analsis. bug checking etc... Haskell, Scala, Swift object InferenceTest1 extends Application val x = * 3 // the tpe of x is Int val = x.tostring() // the tpe of is String def succ(x: Int) = x + 1 // method succ returns Int va 16
17 Pragmatic Languages Pthon Rub Smalltalk Groov Javascript PHP Scala Go Swift C Java C# C++ Objective-C 17
18 Tping Spectrum Dnamic Pthon Rub Smalltalk Groov Javascript PHP Inferred Scala Go Swift C Java C# C++ Objective-C Static Strong Weak 18
19 Java Example (from Jim Weirich) Java algorithm to filter a list of strings Onl printing those shorter than 3 (in this test case). import java.util.arralist; import java.util.list; class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; 19
20 import java.util.arralist; import java.util.list; Groov 1 Also a valid Groov program... class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; 20
21 import java.util.arralist; import java.util.list; Groov 1 Do we need generics? What about semicolons... Should standard libraries be imported? class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; 21
22 Groov 2 class Erase public static void main(string[] args) List names = new ArraList() names.add("ted") names.add("fred") names.add("jed") names.add("ned") Sstem.out.println(names) Erase e = new Erase() List short_names = e.filterlongerthan(names, 3) Sstem.out.println(short_names.size()) for (String s : short_names) Sstem.out.println(s) public List filterlongerthan(liststrings, length) List result = new ArraList(); for (String s : strings) if (s.length() < length + 1) result.add(s) return result 22
23 Groov 2 Do we need the static tpes? Must we alwas have a main method and class definition? class Erase public static void main(string[] args) List names = new ArraList() names.add("ted") names.add("fred") names.add("jed") names.add("ned") Sstem.out.println(names) Erase e = new Erase() List short_names = e.filterlongerthan(names, 3) Sstem.out.println(short_names.size()) for (String s : short_names) Sstem.out.println(s) Consistenc (size or length)? public List filterlongerthan(liststrings, length) List result = new ArraList(); for (String s : strings) if (s.length() < length + 1) result.add(s) return result 23
24 Groov 3 def filterlongerthan(strings, length) List result = new ArraList(); for (String s : strings) if (s.length() < length + 1) result.add(s) return result List names = new ArraList() names.add("ted") names.add("fred") names.add("jed") names.add("ned") Sstem.out.println(names) List short_names = filterlongerthan(names, 3) Sstem.out.println(short_names.size()) for (String s : short_names) Sstem.out.println(s) 24
25 Groov 3 Should we have a special notation for lists? And special facilities for list processing? def filterlongerthan(strings, length) List result = new ArraList(); for (String s : strings) if (s.length() < length + 1) result.add(s) return result List names = new ArraList() names.add("ted") names.add("fred") names.add("jed") names.add("ned") Sstem.out.println(names) List short_names = filterlongerthan(names, 3) Sstem.out.println(short_names.size()) for (String s : short_names) Sstem.out.println(s) 25
26 Groov 4 def filterlongerthan(strings, length) return strings.findall it.size() <= length names = ["Ted", "Fred", "Jed", "Ned"] Sstem.out.println(names) List short_names = filterlongerthan(names, 3) Sstem.out.println(short_names.size()) short_names.each Sstem.out.println(it) 26
27 Groov 4 Method needed an longer? Is there an easier wa to use common methods (e.g. println)? Are brackets alwas needed? def filterlongerthan(strings, length) return strings.findall it.size() <= length names = ["Ted", "Fred", "Jed", "Ned"] Sstem.out.println(names) List short_names = filterlongerthan(names, 3) Sstem.out.println(short_names.size()) short_names.each Sstem.out.println(it) 27
28 Groov 5 names = ["Ted", "Fred", "Jed", "Ned"] println names short_names = names.findallit.size() <= 3 println short_names.size() short_names.each println it 28
29 import java.util.arralist; import java.util.list; class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); names = ["Ted", "Fred", "Jed", "Ned"] println names short_names = names.findallit.size() <= 3 println short_names.size() short_names.each println it Java vs Groov? public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; 29
30 Java Example (again) import java.util.arralist; import java.util.list; class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; 30
31 import Foundation Swift class Erase func main() var names:string[] = String[]() names.append ("ted") names.append ("fred") names.append ("jed") names.append ("ned") println(names) var short_names:string[] = filterlongerthan(names, length:3) for name:string in short_names println (name) func filterlongerthan (strings : String[], length : Int) -> String[] var result:string[] = String[]() for s:string in strings if countelements(s) < length + 1 result.append(s) return result var erase:erase = Erase() erase.main() 31
32 import Foundation Swift Tpe Inference class Erase func main() var names = String[]() names.append ("ted") names.append ("fred") names.append ("jed") names.append ("ned") println(names) var short_names = filterlongerthan(names, length:3) for name in short_names println (name) func filterlongerthan (strings : String[], length : Int) -> String[] var result = String[]() for s in strings if countelements(s) < length + 1 result.append(s) return result var erase = Erase() erase.main() 32
33 Swift import Foundation Literals class Erase func main() var names = ["ted", "fred", "jed", "ned"] var short_names = filterlongerthan(names, length:3) for name in short_names println (name) func filterlongerthan (strings : String[], length : Int) -> String[] var result = String[]() for s in strings if countelements(s) < length + 1 result.append(s) return result var erase = Erase() erase.main() 33
34 Swift Closures import Foundation class Erase func main() var names = ["ted", "fred", "jed", "ned"] var short_names = names.filter countelements($0) < 4 for name in short_names println (name) var erase = Erase() erase.main() 34
35 Swift Final version import Foundation var names = ["ted", "fred", "jed", "ned"] println(names) var short_names = names.filter countelements($0) < 4 println(short_names) 35
36 import java.util.arralist; import java.util.list; class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; names = ["Ted", "Fred", "Jed", "Ned"] println names short_names = names.findallit.size() <= 3 short_names.each println it var names = ["ted", "fred", "jed", "ned"] println(names) var short_names = names.filter countelements($0) < 4 println(short_names) 36
37 Java Example (again) import java.util.arralist; import java.util.list; class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; 37
38 Javascript 'use strict'; class Erase static main () const names = []; names.push('ted'); names.push('fred'); names.push('jed'); names.push('ned'); console.log(names); const e = new Erase(); const short_names = e.filterlongerthan(names, 3); console.log(short_names.length); for (const s of short_names) console.log(s); filterlongerthan(strings, length) const result = []; for (var s of strings) if (s.length < length + 1) result.push(s); return result; ; Erase.main(); 38
39 Javascript Arra Literals 'use strict'; const names = ['Ted', 'Fred', 'Jed', 'Ned']; console.log(names); const short_names = filterlongerthan(names, 3); console.log(short_names.length); console.log (short_names); function filterlongerthan(strings, length) const result = []; for (var s of strings) if (s.length < length + 1) result.push(s); return result; 39
40 Javascript Lambdas 'use strict'; const names = ['Ted', 'Fred', 'Jed', 'Ned']; console.log(names); const short_names = filterlongerthan(names, 3); console.log(short_names.length); console.log (short_names); function filterlongerthan(strings, length) let result = []; result = strings.filter (function (s) return s.length < length + 1; ); return result; 40
41 Javascript Arrow Functions 'use strict'; const names = ['Ted', 'Fred', 'Jed', 'Ned']; console.log(names); const short_names = filterlongerthan(names, 3); console.log(short_names.length); console.log (short_names); function filterlongerthan(strings, length) let result = []; result = strings.filter (s => return s.length < length + 1; ); return result; 41
42 Javascript Final Version 'use strict'; const names = ['Ted', 'Fred', 'Jed', 'Ned']; console.log(names); const short_names = strings.filter (s => return s.length < 4; ); console.log(short_names.length); console.log (short_names); 42
43 Java import java.util.arralist; import java.util.list; class Erase public static void main(string[] args) List<String> names = new ArraList<String>(); names.add("ted"); names.add("fred"); names.add("jed"); names.add("ned"); Sstem.out.println(names); Erase e = new Erase(); List<String> short_names = e.filterlongerthan(names, 3); Sstem.out.println(short_names.size()); for (String s : short_names) Sstem.out.println(s); public List<String> filterlongerthan(list<string> strings, int length) List<String> result = new ArraList<String>(); for (String s : strings) if (s.length() < length + 1) result.add(s); return result; Groov names = ["Ted", "Fred", "Jed", "Ned"] println names short_names = names.findallit.size() <= 3 short_names.each println it Swift var names = ["ted", "fred", "jed", "ned"] println(names) var short_names = names.filter countelements($0) < 4 println(short_names) Javascript 'use strict'; const names = ['Ted', 'Fred', 'Jed', 'Ned']; console.log(names); const short_names = strings.filter (s => return s.length < 4; ); console.log(short_names.length); console.log (short_names); 43
44 Another Shopping List Object-literal sntax for arras and hashes Arra slicing and other intelligent collection operators Perl 5 compatible regular expression literals Destructuring bind (e.g. x, = returntwovalues()) Function literals and first-class, non-broken closures Standard OOP with classes, instances, interfaces, polmorphism, etc. Visibilit quantifiers (public/private/protected) Iterators and generators List comprehensions Namespaces and packages Cross-platform GUI Operator overloading Keword and rest parameters First-class parser and AST support Tpe expressions and staticall checkable semantics Solid string and collection libraries Strings and streams act like collections 44
45 Java Object-literal sntax for arras and hashes Arra slicing and other intelligent collection operators Perl 5 compatible regular expression literals Destructuring bind (e.g. x, = returntwovalues()) Function literals and first-class, non-broken closures Standard OOP with classes, instances, interfaces, polmorphism, etc. Visibilit quantifiers (public/private/protected) Iterators and generators List comprehensions Namespaces and packages Cross-platform GUI Operator overloading Keword and rest parameters First-class parser and AST support Tpe expressions and staticall checkable semantics Solid string and collection libraries Strings and streams act like collections 45
46 Google GO Object-literal sntax for arras and hashes Arra slicing and other intelligent collection operators Perl 5 compatible regular expression literals Destructuring bind (e.g. x, = returntwovalues()) Function literals and first-class, non-broken closures Standard OOP with classes, instances, interfaces, polmorphism, etc. Visibilit quantifiers (public/private/protected) Iterators and generators List comprehensions Namespaces and packages Cross-platform GUI Operator overloading Keword and rest parameters First-class parser and AST support Tpe expressions and staticall checkable semantics Solid string and collection libraries Strings and streams act like collections 46
47 Pthon Object-literal sntax for arras and hashes Arra slicing and other intelligent collection operators Perl 5 compatible regular expression literals Destructuring bind (e.g. x, = returntwovalues()) Function literals and first-class, non-broken closures Standard OOP with classes, instances, interfaces, polmorphism, etc. Visibilit quantifiers (public/private/protected) Iterators and generators List comprehensions Namespaces and packages Cross-platform GUI Operator overloading Keword and rest parameters First-class parser and AST support Tpe expressions and staticall checkable semantics Solid string and collection libraries Strings and streams act like collections 47
48 Javascript (ES6/7 onl) Object-literal sntax for arras and hashes Arra slicing and other intelligent collection operators Perl 5 compatible regular expression literals Destructuring bind (e.g. x, = returntwovalues()) Function literals and first-class, non-broken closures Standard OOP with classes, instances, interfaces, polmorphism, etc. Visibilit quantifiers (public/private/protected)? Iterators and generators List comprehensions Namespaces and packages Cross-platform GUI Operator overloading Keword and rest parameters First-class parser and AST support Tpe expressions and staticall checkable semantics Solid string and collection libraries Strings and streams act like collections 48
49 Except where otherwise noted, this content is licensed under a Creative Commons Attribution-NonCommercial 3.0 License. For more information, please see creativecommons.org/licenses/b-nc/3.0/
Produced by. Design Patterns. MSc in Computer Science. Eamonn de Leastar
Design Patterns MSc in Computer Science Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
Groovy Primer Chris Dail Groovy Primer (March 2010)
Groovy Primer Chris Dail http://chrisdail.com Twitter: @chrisdail What is Groovy? An agile dynamic language for the Java Platform Both dynamically and statically typed Functional programming influence
Produced by. Agile Software Development. Eamonn de Leastar
Agile Software Development Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie Xtend Programming
Xtend Programming Language
Xtend Programming Language Produced by: Eamonn de Leastar (edeleastar@wit.ie) Department of Computing and Mathematics http://www.wit.ie/ Agenda Subtitle Excellent Xtend User Guide (Version 2.6) API Docs
Produced by. Agile Software Development. Eamonn de Leastar
Agile Software Development Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie Xtend Programming
Jussi Riihelä / Jussi Riihelä
28.4.2006 Jussi Riihelä jussi.riihela@nokia.com 1 2006-04-28 / Jussi Riihelä Content Basic facts and motivation Groovy features IDE support and runtime dependencies Criticism 2 2006-04-28 / Jussi Riihelä
Semantics. Names. Binding Time
/24/ CSE 3302 Programming Languages Semantics Chengkai Li, Weimin He Spring Names Names: identif language entities variables, procedures, functions, constants, data tpes, Attributes: properties of names
Semantics (cont.) Symbol Table. Static Scope. Static Scope. Static Scope. CSE 3302 Programming Languages. Static vs. Dynamic Scope
-2-1 CSE 3302 Programming Languages Semantics (cont.) Smbol Table Smbol Table: maintain bindings. Can be viewed as functions that map names to their attributes. Names SmbolTable Attributes Chengkai Li,
Dynamic Languages and Increasing the Quality of. Software and Velocity in the Software Development. Lifecycle. Mark McFadden
Dynamic Languages SDLC 1 Running Head: DYNAMIC LANGUAGES SDLC Dynamic Languages and Increasing the Quality of Software and Velocity in the Software Development Lifecycle. Mark McFadden MBI 630 Systems
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........................................
Announcements. CSCI 334: Principles of Programming Languages. Lecture 19: C++
Announcements CSCI 4: Principles of Programming Languages Lecture 19: C++ HW8 pro tip: the HW7 solutions have a complete, correct implementation of the CPS version of bubble sort in SML. All ou need to
Functional Parsing. Languages for Lunch 10/14/08 James E. Heliotis & Axel T. Schreiner
Functional Parsing Languages for Lunch 10/14/08 James E. Heliotis & Axel T. Schreiner http://www.cs.rit.edu/~ats/talks/mops/talk.pdf why monads? execution sequencing failure handling: preempt, catch stateful
Closures. Mooly Sagiv. Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming
Closures Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming Summary 1. Predictive Parsing 2. Large Step Operational Semantics (Natural) 3. Small Step Operational Semantics
Scala, Your Next Programming Language
Scala, Your Next Programming Language (or if it is good enough for Twitter, it is good enough for me) WORLDCOMP 2011 By Dr. Mark C. Lewis Trinity University Disclaimer I am writing a Scala textbook that
Produced by. Design Patterns. MSc in Communications Software. Eamonn de Leastar
Design Patterns MSc in Communications Software Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
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
SKILL AREA 304: Review Programming Language Concept. Computer Programming (YPG)
SKILL AREA 304: Review Programming Language Concept Computer Programming (YPG) 304.1 Demonstrate an Understanding of Basic of Programming Language 304.1.1 Explain the purpose of computer program 304.1.2
CS 330 Lecture 18. Symbol table. C scope rules. Declarations. Chapter 5 Louden Outline
CS 0 Lecture 8 Chapter 5 Louden Outline The symbol table Static scoping vs dynamic scoping Symbol table Dictionary associates names to attributes In general: hash tables, tree and lists (assignment ) can
Lecture 4 Memory Management
Lecture 4 Memory Management Dr. Wilson Rivera ICOM 4036: Programming Languages Electrical and Computer Engineering Department University of Puerto Rico Some slides adapted from Sebesta s textbook Lecture
CS252 Advanced Programming Language Principles. Prof. Tom Austin San José State University Fall 2013
CS252 Advanced Programming Language Principles Prof. Tom Austin San José State University Fall 2013 What are some programming languages? Why are there so many? Different domains Mobile devices (Objective
Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes,
Chapter 5 Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes, and the Environment Variables
Introduction to Functional Programming in Java 8
1 Introduction to Functional Programming in Java 8 Java 8 is the current version of Java that was released in March, 2014. While there are many new features in Java 8, the core addition is functional programming
G Programming Languages Spring 2010 Lecture 6. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 6 Robert Grimm, New York University 1 Review Last week Function Languages Lambda Calculus SCHEME review 2 Outline Promises, promises, promises Types,
Chapter 9 Subprograms
Chapter 9 Subprograms We now explore the design of subprograms, including parameter-passing methods, local referencing environment, overloaded subprograms, generic subprograms, and the aliasing and problematic
Closures. Mooly Sagiv. Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming
Closures Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming t ::= x x. t t t Call-by-value big-step Operational Semantics terms variable v ::= values abstraction x.
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
Every language has its own scoping rules. For example, what is the scope of variable j in this Java program?
Lexical Binding There are two ways a variable can be used in a program: As a declaration As a "reference" or use of the variable Scheme has two kinds of variable "declarations" -- the bindings of a let-expression
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
CS558 Programming Languages Winter 2018 Lecture 4a. Andrew Tolmach Portland State University
CS558 Programming Languages Winter 2018 Lecture 4a Andrew Tolmach Portland State University 1994-2018 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.
Produced by. Design Patterns. MSc in Communications Software. Eamonn de Leastar
Design Patterns MSc in Communications Software Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
CS558 Programming Languages
CS558 Programming Languages Fall 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Type Inference Some statically typed languages, like ML (and to a lesser extent Scala), offer alternative
CSCI Test 1.Spring 2004 Student Id: Grading: Undergrads, you are responsible for 110 points. Grads: you are responsible for 120 points
1a.Define Programming Language. (3 b. From the point of view of development of software packages, list the kinds of activities that a programming language ought to support. (4 b. List the 3 factors in
G Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 3 Thomas Wies New York University Review Last week Names and Bindings Lifetimes and Allocation Garbage Collection Scope Outline Control Flow Sequencing
Functional Programming Patterns And Their Role Instructions
Functional Programming Patterns And Their Role Instructions In fact, the relabelling function is precisely the same as before! Phil Wadler's Chapter 7 of The Implementation of Functional Programming Languages.
CSCI 3136 Principles of Programming Languages
CSCI 3136 Principles of Programming Languages Summer 2013 Faculty of Computer Science Dalhousie University 1 / 100 CSCI 3136 Principles of Programming Languages Summer 2013 Aminul Islam Faculty of Computer
Classes. Compiling Methods. Code Generation for Objects. Implementing Objects. Methods. Fields
Classes Implementing Objects Components fields/instance variables values differ from to usuall mutable methods values shared b all s of a class usuall immutable component visibilit: public/private/protected
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
SOFTWARE ARCHITECTURE 6. LISP
1 SOFTWARE ARCHITECTURE 6. LISP Tatsuya Hagino hagino@sfc.keio.ac.jp slides URL https://vu5.sfc.keio.ac.jp/sa/ 2 Compiler vs Interpreter Compiler Translate programs into machine languages Compilers are
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of
Produced by. App Development & Modelling. BSc in Applied Computing. Eamonn de Leastar
App Development & Modelling BSc in Applied Computing Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
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
MEAP Edition Manning Early Access Program Get Programming with Java Version 1
MEAP Edition Manning Early Access Program Get Programming with Java Version 1 Copyright 2018 Manning Publications For more information on this and other Manning titles go to www.manning.com welcome First,
Chapter 9. Subprograms
Chapter 9 Subprograms Chapter 9 Topics Introduction Fundamentals of Subprograms Design Issues for Subprograms Local Referencing Environments Parameter-Passing Methods Parameters That Are Subprograms Calling
Names, Bindings, Scopes
Names, Bindings, Scopes Variables In imperative l Language: abstractions of von Neumann machine Variables: abstraction of memory cell or cells Sometimes close to machine (e.g., integers), sometimes not
CS558 Programming Languages
CS558 Programming Languages Winter 2018 Lecture 7b Andrew Tolmach Portland State University 1994-2018 Dynamic Type Checking Static type checking offers the great advantage of catching errors early And
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
Symbolic Computation and Common Lisp
Symbolic Computation and Common Lisp Dr. Neil T. Dantam CSCI-56, Colorado School of Mines Fall 28 Dantam (Mines CSCI-56) Lisp Fall 28 / 92 Why? Symbolic Computing: Much of this course deals with processing
First Programming Language in CS Education The Arguments for Scala
First Programming Language in CS Education The Arguments for Scala WORLDCOMP 2011 By Dr. Mark C. Lewis Trinity University Disclaimer I am writing a Scala textbook that is under contract with CRC Press.
Produced by. Design Patterns. MSc Computer Science. Eamonn de Leastar
Design Patterns MSc Computer Science Produced by Eamonn de Leastar (edeleastar@wit.ie)! Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
Java, Dynamic Languages and DSL. Lee Chuk Munn Staff Engineer Sun Microsystems
Java, Dynamic Languages and DSL Lee Chuk Munn Staff Engineer Sun Microsystems 1 Objective How to Script Enable Your Application Agenda Scripting and Java JSR-223 Overview Groovy Language Scripting Groovy
Chapter 5. Names, Bindings, and Scopes
Chapter 5 Names, Bindings, and Scopes Chapter 5 Topics Introduction Names Variables The Concept of Binding Scope Scope and Lifetime Referencing Environments Named Constants 1-2 Introduction Imperative
Produced by. Design Patterns. MSc in Computer Science. Eamonn de Leastar
Design Patterns MSc in Computer Science Produced by Eamonn de Leastar (edeleastar@wit.ie)! Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
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
Topics Covered Thus Far. CMSC 330: Organization of Programming Languages. Language Features Covered Thus Far. Programming Languages Revisited
CMSC 330: Organization of Programming Languages Type Systems, Names & Binding Topics Covered Thus Far Programming languages Syntax specification Regular expressions Context free grammars Implementation
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
CS383 PROGRAMMING LANGUAGES. Kenny Q. Zhu Dept. of Computer Science Shanghai Jiao Tong University
CS383 PROGRAMMING LANGUAGES Kenny Q. Zhu Dept. of Computer Science Shanghai Jiao Tong University KENNY Q. ZHU Research Interests: Programming Languages Probabilistic Programming Data Processing Concurrency
Topics Covered Thus Far CMSC 330: Organization of Programming Languages
Topics Covered Thus Far CMSC 330: Organization of Programming Languages Names & Binding, Type Systems Programming languages Ruby Ocaml Lambda calculus Syntax specification Regular expressions Context free
ITT8060 Advanced Programming
ITT8060 Advanced Programming In F# Juhan Ernits Welcome to Advanced Programming (in F#)! Teachers: Juhan Ernits Hendrik Maarand Course web page http://courses.cs.ttu.ee/pages/itt8060 Contact: juhan.ernits@ttu.ee
CS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 4a Andrew Tolmach Portland State University 1994-2016 Pragmatics of Large Values Real machines are very efficient at handling word-size chunks of data (e.g.
Procedures. EOPL3: Section 3.3 PROC and App B: SLLGEN
Procedures EOPL3: Section 3.3 PROC and App B: SLLGEN The PROC language Expression ::= proc (Identifier) Expression AST: proc-exp (var body) Expression ::= (Expression Expression) AST: call-exp (rator rand)
Functions & First Class Function Values
Functions & First Class Function Values PLAI 1st ed Chapter 4, PLAI 2ed Chapter 5 The concept of a function is itself very close to substitution, and to our with form. Consider the following morph 1 {
Object Oriented Languages. Hwansoo Han
Object Oriented Languages Hwansoo Han Object-Oriented Languages An object is an abstract data tpe Encapsulates data, operations and internal state behind a simple, consistent interface. z Data Code Data
Static Semantics. Lecture 15. (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1
Static Semantics Lecture 15 (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1 Current Status Lexical analysis Produces tokens Detects & eliminates illegal tokens Parsing
Principles of Programming Languages, 2
Principles of Programming Languages, 2 Matteo Pradella February 2015 Matteo Pradella Principles of Programming Languages, 2 February 2015 1 / 23 1 Object Oriented Programming (OO) Matteo Pradella Principles
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Type Systems, Names and Binding CMSC 330 - Spring 2013 1 Topics Covered Thus Far! Programming languages Ruby OCaml! Syntax specification Regular expressions
CS152 Programming Language Paradigms Prof. Tom Austin, Fall Syntax & Semantics, and Language Design Criteria
CS152 Programming Language Paradigms Prof. Tom Austin, Fall 2014 Syntax & Semantics, and Language Design Criteria Lab 1 solution (in class) Formally defining a language When we define a language, we need
Produced by. Mobile Application Development. Higher Diploma in Science in Computer Science. Eamonn de Leastar
Mobile Application Development Higher Diploma in Science in Computer Science Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology
Concepts of Programming Languages
Concepts of Programming Languages Lecture 15 - Functional Programming Patrick Donnelly Montana State University Spring 2014 Patrick Donnelly (Montana State University) Concepts of Programming Languages
Where do we go from here?
Where do we go from here? C++ classes and objects, with all the moving parts visible operator overloading templates, STL, standards, Java components, collections, generics language and performance comparisons
JVM ByteCode Interpreter
JVM ByteCode Interpreter written in Haskell (In under 1000 Lines of Code) By Louis Jenkins Presentation Schedule ( 15 Minutes) Discuss and Run the Virtual Machine first
JavaScript: Sort of a Big Deal,
: Sort of a Big Deal, But Sort of Quirky... March 20, 2017 Lisp in C s Clothing (Crockford, 2001) Dynamically Typed: no static type annotations or type checks. C-Like Syntax: curly-braces, for, semicolons,
Static Typing or Dynamic Typing: A Real Issue or a Simple Case of Tribalism
Static Typing or Dynamic Typing: A Real Issue or a Simple Case of Tribalism Dr Russel Winder Concertant LLP russel.winder@concertant.com 2007 Russel Winder 1 Aims and Objectives Survey some of the static
Functional Programming Language Haskell
Functional Programming Language Haskell Mohammed Aslam CIS 24 Prof. Kopec Presentation: 03 Date: 05/05/2003 Haskell is a general purpose, purely functional programming language named after the logician
CSE3322 Programming Languages and Implementation
Monash University School of Computer Science & Software Engineering Exam 2005 CSE3322 Programming Languages and Implementation Total Time Allowed: 3 Hours 1. Reading time is of 10 minutes duration. 2.
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
Java Overview An introduction to the Java Programming Language
Java Overview An introduction to the Java Programming Language Produced by: Eamonn de Leastar (edeleastar@wit.ie) Dr. Siobhan Drohan (sdrohan@wit.ie) Department of Computing and Mathematics http://www.wit.ie/
IA010: Principles of Programming Languages
IA010: Principles of Programming Languages Introduction and course organization Achim Blumensath blumens@fi.muni.cz Faculty of Informatics, Masaryk University, Brno Warm-up: A Quiz What does this program
Lecture content. Course goals. Course Introduction. TDDA69 Data and Program Structure Introduction
Lecture content TDDA69 Data and Program Structure Introduction Cyrille Berger Course Introduction to the different Programming Paradigm The different programming paradigm Why different paradigms? Introduction
Chapter 9. Subprograms
Chapter 9 Subprograms Chapter 9 Topics Introduction Fundamentals of Subprograms Design Issues for Subprograms Local Referencing Environments Parameter-Passing Methods Parameters That Are Subprograms Calling
Chapter 15. Functional Programming Languages
Chapter 15 Functional Programming Languages Copyright 2009 Addison-Wesley. All rights reserved. 1-2 Chapter 15 Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages
Topic 9: Type Checking
Recommended Exercises and Readings Topic 9: Type Checking From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 13.17, 13.18, 13.19, 13.20, 13.21, 13.22 Readings: Chapter 13.5, 13.6 and
Topic 9: Type Checking
Topic 9: Type Checking 1 Recommended Exercises and Readings From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 13.17, 13.18, 13.19, 13.20, 13.21, 13.22 Readings: Chapter 13.5, 13.6
CS Programming Languages: Scala
CS 3101-2 - Programming Languages: Scala Lecture 3: Fun with Functions Daniel Bauer (bauer@cs.columbia.edu) October 29, 2014 Daniel Bauer CS3101-2 Scala - 03 - Fun with Functions 1/37 Contents 1 Defining
Produced by. Agile Software Development. Eamonn de Leastar
Agile Software Development Produced by Eamonn de Leastar (edeleastar@wit.ie) Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie SOLID Principles
G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 4 Robert Grimm, New York University 1 Review Last week Control Structures Selection Loops 2 Outline Subprograms Calling Sequences Parameter Passing
Comp 333: Concepts of Programming Languages Fall 2016
Comp 333: Concepts of Programming Languages Fall 2016 Instructor: Professor Schwartz History Syntax and Semantics Compilers Language Constructs Names, Binding, Scoping, Data Types Expressions, Control
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
low and not larger than high. 18 points
CSE 330 Test 1 (1 point) Spring 015 Multiple Choice. Write your answer to the LEFT of each problem. 3 points each 1. Lisp was invented at: A. IBM B. MIT C. Netscape D. Stanford. In C++, what operator is
CPS 506 Comparative Programming Languages. Programming Language Paradigm
CPS 506 Comparative Programming Languages Functional Programming Language Paradigm Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming
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,
CIS 194: Homework 3. Due Wednesday, February 11, Interpreters. Meet SImPL
CIS 194: Homework 3 Due Wednesday, February 11, 2015 Interpreters An interpreter is a program that takes another program as an input and evaluates it. Many modern languages such as Java 1, Javascript,
Functional Programming Lecture 13: FP in the Real World
Functional Programming Lecture 13: FP in the Real World Viliam Lisý Artificial Intelligence Center Department of Computer Science FEE, Czech Technical University in Prague viliam.lisy@fel.cvut.cz 1 Mixed
Closing the Case for Groovy (and Ruby, and Python)
Closing the Case for Groovy (and Ruby, and Python) Dr Russel Winder Concertant LLP russel.winder@concertant.com 2007 Russel Winder 1 Aims and Objectives Convince people that dynamic typing is not a difficulty,
Expansion statements. Version history. Introduction. Basic usage
Expansion statements Version history Document: P1306R0 Revises: P0589R0 Date: 08 10 2018 Audience: EWG Authors: Andrew Sutton (asutton@uakron.edu) Sam Goodrick (sgoodrick@lock3software.com) Daveed Vandevoorde
The Phases of a Compiler. Course Overview. In Chapter 4. Syntax Analysis. Syntax Analysis. Multi Pass Compiler. PART I: overview material
Course Overview The Phases of a Compiler PART I: overview material Introduction 2 Language processors (tombstone diagrams, bootstrappg) 3 Architecture of a compiler PART II: side a compiler 4 Sntax analsis
Implementing Object-Oriented Languages. Implementing instance variable access. Implementing dynamic dispatching (virtual functions)
Implementing Object-Oriented Languages Implementing instance variable access Ke features: inheritance (possibl multiple) subtping & subtpe polmorphism message passing, dnamic binding, run-time tpe testing
Produced by. Design Patterns. MSc in Computer Science. Eamonn de Leastar
Design Patterns MSc in Computer Science Produced by Eamonn de Leastar (edeleastar@wit.ie)! Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
Notes from a Short Introductory Lecture on Scala (Based on Programming in Scala, 2nd Ed.)
Notes from a Short Introductory Lecture on Scala (Based on Programming in Scala, 2nd Ed.) David Haraburda January 30, 2013 1 Introduction Scala is a multi-paradigm language that runs on the JVM (is totally
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
Programmin Languages/Variables and Storage
Programmin Languages/Variables and Storage Onur Tolga Şehitoğlu Computer Engineering 4 Mart 2007 Outline 1 Storage Array Variables 2 Semantics of Assignment 3 Variable Lifetime Global Lifetime Local Lifetime