TYPES OF PROGRAMMING LANGUAGES
|
|
|
- Sheryl Waters
- 5 years ago
- Views:
Transcription
1 TYPES OF PROGRAMMING LANGUAGES PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/30
2 REASONS TO CHOOSE A PARTICULAR PROGRAMMING LANGUAGE 2/30
3 REASONS TO CHOOSE A PARTICULAR PROGRAMMING LANGUAGE Easy to express complex ideas Easy to control exactly how the computation is carried out Rich set of data types Extensive (standard) library Active, friendly community Was used for this project before I joined Good compiler support Open-source 2/30
4 WHY ARE THERE SO MANY PROGRAMMING LANGUAGES? 3/30
5 WHY ARE THERE SO MANY PROGRAMMING LANGUAGES? Trade-off between features Speed vs expressiveness/elegance Speed, type safety vs rapid development 3/30
6 WHY ARE THERE SO MANY PROGRAMMING LANGUAGES? Trade-off between features Speed vs expressiveness/elegance Speed, type safety vs rapid development Tinkering with programming languages is fun and then they sometimes get adopted. 3/30
7 WHY ARE THERE SO MANY PROGRAMMING LANGUAGES? Trade-off between features Speed vs expressiveness/elegance Speed, type safety vs rapid development Tinkering with programming languages is fun and then they sometimes get adopted. Corporate pressure 3/30
8 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Special-purpose programming language: 4/30
9 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: 4/30
10 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete 4/30
11 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Examples: Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete 4/30
12 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Examples: C, C++, Java, Python, Ruby Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete 4/30
13 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete 4/30
14 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete 4/30
15 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete 4/30
16 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Examples: 4/30
17 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Examples: (La)TeX, HTML/XML, XSLT 4/30
18 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Examples: (La)TeX, HTML/XML, XSLT R, Matlab 4/30
19 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Examples: (La)TeX, HTML/XML, XSLT R, Matlab sed, awk 4/30
20 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Examples: (La)TeX, HTML/XML, XSLT R, Matlab sed, awk 4/30
21 GENERAL PURPOSE VS SPECIAL PURPOSE General-purpose programming language: Designed to express arbitrary computations Turing-complete Special-purpose programming language: Designed to make it easy to express certain types of programs May not be Turing-complete Examples: C, C++, Java, Python, Ruby Haskell, Scheme, Prolog Lua, Tcl/Tk Examples: (La)TeX, HTML/XML, XSLT R, Matlab sed, awk 4/30
22 TYPES OF PROGRAMMING LANGUAGES 5/30
23 TYPES OF PROGRAMMING LANGUAGES C++ Python Ruby Java Objective C Swift 5/30
24 TYPES OF PROGRAMMING LANGUAGES Imperative Object-oriented C++ Python Ruby Java Objective C Swift 5/30
25 TYPES OF PROGRAMMING LANGUAGES Imperative Object-oriented C Pascal Modula Ada Fortran C++ Python Ruby Java Objective C Swift 5/30
26 TYPES OF PROGRAMMING LANGUAGES Concatenative Imperative Object-oriented Postscript Forth Factor C Pascal Modula Ada Fortran C++ Python Ruby Java Objective C Swift 5/30
27 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript Forth Factor C Pascal Modula Ada Fortran C++ Python Ruby Java Objective C Swift 5/30
28 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript C C++ Haskell Forth Pascal Python Factor Modula Ruby Ada Java Fortran Objective C Swift 5/30
29 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript C C++ Lisp Scheme Haskell Forth Pascal Python ML Factor Modula Ruby Ada Java Fortran Objective C Swift 5/30
30 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript C C++ Lisp Scala Scheme Haskell Forth Pascal Python ML Factor Modula Ruby Ada Java Fortran Objective C Swift 5/30
31 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript C C++ Lisp Scala Scheme Haskell Prolog Forth Pascal Python ML Hilog Factor Modula Ruby Ada Java Fortran Objective C Swift 5/30
32 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript C C++ Lisp Scala Scheme Haskell Prolog Forth Pascal Python ML Hilog Factor Modula Ruby Ada Java Fortran Objective C Swift 5/30
33 TYPES OF PROGRAMMING LANGUAGES Declarative Concatenative Imperative Object-oriented Functional Logic Postscript C C++ Lisp Scala Scheme Haskell Prolog Forth Pascal Python ML Hilog Factor Modula Ruby Ada Java Fortran Objective C Swift 5/30
34 THE LANGUAGES I USE C++ C When I need performance When I feel nostalgic Haskell When I want to have fun and write elegant code that I trust Python Scala Java When I need to write a prototype quickly When I m told to use Java Never Prolog When I want to solve puzzles 6/30
35 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Declarative programming: 7/30
36 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Declarative programming: 7/30
37 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Declarative programming: Focus on telling the computer what to do, not how to do it 7/30
38 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Declarative programming: Focus on telling the computer what to do, not how to do it 7/30
39 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Declarative programming: Focus on telling the computer what to do, not how to do it More high-level, elegant, expressive 7/30
40 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Declarative programming: Focus on telling the computer what to do, not how to do it More high-level, elegant, expressive Need to include evaluation engine in run-time system 7/30
41 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Declarative programming: Focus on telling the computer what to do, not how to do it More high-level, elegant, expressive Need to include evaluation engine in run-time system Can come with performance penalties 7/30
42 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Difficult to analyze/ automatically optimize Declarative programming: Focus on telling the computer what to do, not how to do it More high-level, elegant, expressive Need to include evaluation engine in run-time system Can come with performance penalties 7/30
43 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Difficult to analyze/ automatically optimize Declarative programming: Focus on telling the computer what to do, not how to do it More high-level, elegant, expressive Need to include evaluation engine in run-time system Can come with performance penalties Easier to analyze/automatically optimize/parallelize 7/30
44 IMPERATIVE VS DECLARATIVE PROGRAMMING Imperative programming: Focus on telling the computer exactly which steps to execute Close to the machine Difficult to analyze/ automatically optimize Functions called for Return values Side effects Declarative programming: Focus on telling the computer what to do, not how to do it More high-level, elegant, expressive Need to include evaluation engine in run-time system Can come with performance penalties Easier to analyze/automatically optimize/parallelize 7/30
45 SIDE EFFECTS Variable updates, I/O (disk, screen, keyboard, network, ) 8/30
46 SIDE EFFECTS Variable updates, I/O (disk, screen, keyboard, network, ) are evil: Source of 90% of all software bugs 8/30
47 SIDE EFFECTS Variable updates, I/O (disk, screen, keyboard, network, ) are evil: Source of 90% of all software bugs are the only reason we compute at all: Taking input and communicating results requires side effects. 8/30
48 FUNCTIONAL PROGRAMMING 9/30
49 FUNCTIONAL PROGRAMMING Functions have no side effects 9/30
50 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined 9/30
51 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects 9/30
52 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects Can express imperative computations elegantly! 9/30
53 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects Can express imperative computations elegantly! Pros: Cons: 9/30
54 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects Can express imperative computations elegantly! Pros: Easier to analyze/optimize Cons: 9/30
55 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects Can express imperative computations elegantly! Pros: Easier to analyze/optimize No specified execution order easy to parallelize Cons: 9/30
56 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects Can express imperative computations elegantly! Pros: Easier to analyze/optimize No specified execution order easy to parallelize Cons: Can be less efficient than well-designed imperative code 9/30
57 FUNCTIONAL PROGRAMMING Functions have no side effects Variables are immutable once defined Functions are first-class objects Can express imperative computations elegantly! Pros: Easier to analyze/optimize No specified execution order easy to parallelize Cons: Can be less efficient than well-designed imperative code Some imperative data structures are inherently more efficient than their purely functional counterparts 9/30
58 LOGIC PROGRAMMING 10/30
59 LOGIC PROGRAMMING General program structure: Database of facts, represented as logical predicates Rules for deducing new facts from known facts Execution driven by queries whether certain facts are true 10/30
60 LOGIC PROGRAMMING General program structure: Database of facts, represented as logical predicates Rules for deducing new facts from known facts Execution driven by queries whether certain facts are true Runtime system: Engine to perform the deduction process efficiently 10/30
61 LOGIC PROGRAMMING General program structure: Database of facts, represented as logical predicates Rules for deducing new facts from known facts Execution driven by queries whether certain facts are true Runtime system: Engine to perform the deduction process efficiently Pros: Cons: 10/30
62 LOGIC PROGRAMMING General program structure: Database of facts, represented as logical predicates Rules for deducing new facts from known facts Execution driven by queries whether certain facts are true Runtime system: Engine to perform the deduction process efficiently Pros: Even higher abstraction than functional programming Cons: 10/30
63 LOGIC PROGRAMMING General program structure: Database of facts, represented as logical predicates Rules for deducing new facts from known facts Execution driven by queries whether certain facts are true Runtime system: Engine to perform the deduction process efficiently Pros: Even higher abstraction than functional programming In theory, no need to worry about execution details at all Cons: 10/30
64 LOGIC PROGRAMMING General program structure: Database of facts, represented as logical predicates Rules for deducing new facts from known facts Execution driven by queries whether certain facts are true Runtime system: Engine to perform the deduction process efficiently Pros: Even higher abstraction than functional programming In theory, no need to worry about execution details at all Cons: In practice, need to understand execution details enough to Avoid infinite loops in deduction Obtain efficient programs 10/30
65 INTERMISSION: HASKELL AND PROLOG TUTORIALS 11/30
66 AN EXAMPLE WHERE FUNCTIONAL PROGRAMMING SHINES: MERGE SORT (1) C++: template <typename It> void merge_sort(const It &begin, const It &end) { auto n = end - begin; if (n < 2) return; auto mid = begin + n / 2; merge_sort(begin, mid); merge_sort(mid, end); std::vector<std::iterator_traits<it>::value_type> left(begin, mid); std::vector<std::iterator_traits<it>::value_type> right(mid, end); merge(left, right, begin); } 12/30
67 AN EXAMPLE WHERE FUNCTIONAL PROGRAMMING SHINES: MERGE SORT (2) template <typename It> void merge( const std::vector<std::iterator_traits<it>::value_type> &left, const std::vector<std::iterator_traits<it>::value_type> &right, It out) { auto l = left.begin(), r = right.begin(); while (l!= left.end() && r!= right.end()) { if (*r < *l) *out++ = *r++; else *out++ = *l++; } while (l!= left.end()) *out++ = *l++; while (r!= right.end()) *out++ = *r++; } 13/30
68 AN EXAMPLE WHERE FUNCTIONAL PROGRAMMING SHINES: MERGE SORT (3) Haskell: mergesort :: Ord t => [t] -> [t] mergesort [] = [] mergesort [x] = [x] mergesort xs = merge (mergesort ls) (mergesort rs) where n = length xs (ls, rs) = splitat (n `div` 2) xs merge :: Ord t => [t] -> [t] -> [t] merge [] rs = rs merge ls [] = ls merge ls@(l:ls') rs@(r:rs') r < l = r : merge ls rs' otherwise = l : merge ls' rs 14/30
69 AN EXAMPLE WHERE FUNCTIONAL PROGRAMMING SHINES: MERGE SORT (4) Prolog: list_sorted([], []). list_sorted([x], [X]). list_sorted(list, Sorted) :- list_left_right(list, Left, Right), list_sorted(left, LeftSorted), list_sorted(right, RightSorted), merged_left_right(sorted, LeftSorted, RightSorted). merged_left_right(left, Left, []). merged_left_right([r Right], [], [R Right]). merged_left_right([l Merged], [L Left], [R Right]) :- L #=< R, merged_left_right(merged, Left, [R Right]). merged_left_right([r Merged], [L Left], [R Right]) :- R #< L, merged_left_right(merged, [L Left], Right). 15/30
70 AN EXAMPLE WHERE FUNCTIONAL PROGRAMMING SHINES: MERGE SORT (5) list_left_right(list, Left, Right) :- phrase(parse_half(list, Left), List, Right). parse_half([], []) --> []. parse_half([_], []) --> []. parse_half([_,_ List], [L Left]) --> [L], parse_half(list, Left). 16/30
71 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
72 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
73 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
74 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
75 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
76 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
77 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
78 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
79 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
80 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
81 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
82 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
83 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
84 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (1) Problem: Build a permutation of the integers {0, 1,..., n 1} specified by indicating, for each element, after which element it is to be inserted. Example: Input: Output: /30
85 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } 18/30
86 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } 0 18/30
87 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
88 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
89 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
90 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
91 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
92 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
93 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
94 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
95 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (2) C++: Linear time std::vector<int> dynamic_permute(const std::vector<int> &refs) { int n = ref.size() + 1; std::list<int> seq; std::vector<std::list<int>::iterator> list_nodes(n); list_nodes[0] = seq.insert(seq.end(), 0); for (int i = 1; i < n; ++i) list_nodes[i] = seq.insert(next(list_nodes[ref[i]]), i); return std::vector<int>(seq.begin(), seq.end()); } /30
96 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (3) Doing this without mutation: /30
97 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (3) Doing this without mutation: /30
98 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (3) Doing this without mutation: /30
99 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (3) Doing this without mutation: /30
100 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (3) Doing this without mutation: When updating any node in a functional data structure, all nodes with a path of pointers to it need to be replaced too. 19/30
101 AN EXAMPLE WHERE IMPERATIVE PROGRAMMING SHINES: DYNAMIC DATA STRUCTURES (3) Doing this without mutation: When updating any node in a functional data structure, all nodes with a path of pointers to it need to be replaced too. This makes standard pointer-based data structures difficult/impossible to implement functionally. 19/30
102 WHAT ABOUT TRADITIONAL PERMUTING? (1) Problem: Given a list of elements, each annotated with its desired position in the output list, build an array storing each element in the desired position. Example: Input: Output: (2, a) (0, b) (3, c) (1, e) (4, d) b e a c d 20/30
103 WHAT ABOUT TRADITIONAL PERMUTING? (2) C++: template <typename T> std::vector<t> permute( const std::vector<std::pair<int, T>> &input) { std::vector<t> output(input.size()); for (auto &item : input) output[item.first] = item.second; return output; } 21/30
104 WHAT ABOUT TRADITIONAL PERMUTING? (2) C++: template <typename T> std::vector<t> permute( const std::vector<std::pair<int, T>> &input) { std::vector<t> output(input.size()); for (auto &item : input) output[item.first] = item.second; return output; } Haskell: permute :: [(Int, t)] -> [t] permute xs = elems (array (0, len xs - 1) xs) 21/30
105 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (1) Sudoku 22/30
106 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (2) Prolog: sudoku(rows) :- transpose(rows, Columns), rows_blocks(rows, Blocks), append([rows, Columns, Blocks], Sets), maplist(permutation([1, 2, 3, 4, 5, 6, 7, 8, 9]), Sets). 23/30
107 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (2) Prolog: sudoku(rows) :- transpose(rows, Columns), rows_blocks(rows, Blocks), append([rows, Columns, Blocks], Sets), maplist(permutation([1, 2, 3, 4, 5, 6, 7, 8, 9]), Sets). rows_blocks([], []). rows_blocks([r1,r2,r3 Rows], [B1,B2,B3 Blocks]) :- rows3_blocks3([r1,r2,r3], [B1,B2,B3]). 23/30
108 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (2) Prolog: sudoku(rows) :- transpose(rows, Columns), rows_blocks(rows, Blocks), append([rows, Columns, Blocks], Sets), maplist(permutation([1, 2, 3, 4, 5, 6, 7, 8, 9]), Sets). rows_blocks([], []). rows_blocks([r1,r2,r3 Rows], [B1,B2,B3 Blocks]) :- rows3_blocks3([r1,r2,r3], [B1,B2,B3]). rows3_blocks3([[r11,r12,r13 R1], [R21,R22,R23 R2], [R31,R32,R33 R3]], [[R11,R12,R13,R21,R22,R23,R31,R32,R33 Bs]) :- rows3_blocks3([r1,r2,r3], Bs). 23/30
109 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (2) Prolog: Elegant but (ridiculously) slow sudoku(rows) :- transpose(rows, Columns), rows_blocks(rows, Blocks), append([rows, Columns, Blocks], Sets), maplist(permutation([1, 2, 3, 4, 5, 6, 7, 8, 9]), Sets). rows_blocks([], []). rows_blocks([r1,r2,r3 Rows], [B1,B2,B3 Blocks]) :- rows3_blocks3([r1,r2,r3], [B1,B2,B3]). rows3_blocks3([[r11,r12,r13 R1], [R21,R22,R23 R2], [R31,R32,R33 R3]], [[R11,R12,R13,R21,R22,R23,R31,R32,R33 Bs]) :- rows3_blocks3([r1,r2,r3], Bs). 23/30
110 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (3) Prolog: Elegant and fast sudoku(rows) :- transpose(rows, Columns), append(rows, Vs), Vs ins 1..9, maplist(all_distinct, Rows), maplist(all_distinct, Columns), Rows = [As,Bs,Cs,Ds,Es,Fs,Gs,Hs,Is], blocks(as,bs,cs), blocks(ds,es,fs), blocks(gs,hs,is), label(vs). 24/30
111 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (3) Prolog: Elegant and fast sudoku(rows) :- transpose(rows, Columns), append(rows, Vs), Vs ins 1..9, maplist(all_distinct, Rows), maplist(all_distinct, Columns), Rows = [As,Bs,Cs,Ds,Es,Fs,Gs,Hs,Is], blocks(as,bs,cs), blocks(ds,es,fs), blocks(gs,hs,is), label(vs). blocks([], [], []). blocks([a1,a2,a3 As], [B1,B2,B3 Bs], [C1,C2,C3 Cs]) :- all_distinct([a1,a2,a3,b1,b2,b3,c1,c2,c3]), blocks(as,bs,cs). 24/30
112 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (3) Prolog: Elegant and fast sudoku(rows) :- transpose(rows, Columns), append(rows, Vs), Vs ins 1..9, maplist(all_distinct, Rows), maplist(all_distinct, Columns), Rows = [As,Bs,Cs,Ds,Es,Fs,Gs,Hs,Is], blocks(as,bs,cs), blocks(ds,es,fs), blocks(gs,hs,is), label(vs). blocks([], [], []). blocks([a1,a2,a3 As], [B1,B2,B3 Bs], [C1,C2,C3 Cs]) :- all_distinct([a1,a2,a3,b1,b2,b3,c1,c2,c3]), blocks(as,bs,cs). What s different? 24/30
113 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (3) Prolog: Elegant and fast sudoku(rows) :- transpose(rows, Columns), append(rows, Vs), Vs ins 1..9, maplist(all_distinct, Rows), maplist(all_distinct, Columns), Rows = [As,Bs,Cs,Ds,Es,Fs,Gs,Hs,Is], blocks(as,bs,cs), blocks(ds,es,fs), blocks(gs,hs,is), label(vs). blocks([], [], []). blocks([a1,a2,a3 As], [B1,B2,B3 Bs], [C1,C2,C3 Cs]) :- all_distinct([a1,a2,a3,b1,b2,b3,c1,c2,c3]), blocks(as,bs,cs). What s different? This uses efficient constraint propagation. 24/30
114 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (4) Prolog: 12 LOC Instantaneous answer SWI Prolog Free, well maintained, feature-rich, ISO compliant Much slower than SICSTUS Prolog (commercial) 25/30
115 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (4) Prolog: 12 LOC Instantaneous answer SWI Prolog Free, well maintained, feature-rich, ISO compliant Much slower than SICSTUS Prolog (commercial) Python: SAT solver (250 LOC) Encode puzzle as CNF (100 LOC) Instantaneous answer Could get faster if Implemented in C++ Using state-of-the-art SAT solver 25/30
116 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (5) Binary Puzzle No two identical rows/columns #0s = #1s in each row/column No three consecutive 0s or 1s in any row or column 26/30
117 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (6) binary(rows) :- append(rows, Vs), Vs ins 0..1, transpose(rows, Columns), maplist(no_triplets, Rows), maplist(no_triplets, Columns), maplist(zero_one_balance, Rows), maplist(zero_one_balance, Columns), phrase(pairs(rows), Row_Pairs), phrase(pairs(columns), Column_Pairs), maplist(not_same, Row_Pairs), maplist(not_same, Column_Pairs), label(vs). 27/30
118 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (6) binary(rows) :- append(rows, Vs), Vs ins 0..1, transpose(rows, Columns), maplist(no_triplets, Rows), maplist(no_triplets, Columns), maplist(zero_one_balance, Rows), maplist(zero_one_balance, Columns), phrase(pairs(rows), Row_Pairs), phrase(pairs(columns), Column_Pairs), maplist(not_same, Row_Pairs), maplist(not_same, Column_Pairs), label(vs). no_triplets(list) :- length(list,l), L < 3. no_triplets([a,b,c List]) :- A+B+C #> 0, A+B+C #< 3, no_triplets([b,c List]). 27/30
119 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (6) binary(rows) :- append(rows, Vs), Vs ins 0..1, transpose(rows, Columns), maplist(no_triplets, Rows), maplist(no_triplets, Columns), maplist(zero_one_balance, Rows), maplist(zero_one_balance, Columns), phrase(pairs(rows), Row_Pairs), phrase(pairs(columns), Column_Pairs), maplist(not_same, Row_Pairs), maplist(not_same, Column_Pairs), label(vs). zero_one_balance(list) :- length(list,l), Half is L // 2, sum(list, #= Half). no_triplets(list) :- length(list,l), L < 3. no_triplets([a,b,c List]) :- A+B+C #> 0, A+B+C #< 3, no_triplets([b,c List]). 27/30
120 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (6) binary(rows) :- append(rows, Vs), Vs ins 0..1, transpose(rows, Columns), maplist(no_triplets, Rows), maplist(no_triplets, Columns), maplist(zero_one_balance, Rows), maplist(zero_one_balance, Columns), phrase(pairs(rows), Row_Pairs), phrase(pairs(columns), Column_Pairs), maplist(not_same, Row_Pairs), maplist(not_same, Column_Pairs), label(vs). zero_one_balance(list) :- length(list,l), Half is L // 2, sum(list, #= Half). not_same((list1,list2) :- maplist(diff, List1, List2, Diffs), sum(diffs, #>, 0). diff(a, B, Diff) :- Diff #<==> A #\= B. no_triplets(list) :- length(list,l), L < 3. no_triplets([a,b,c List]) :- A+B+C #> 0, A+B+C #< 3, no_triplets([b,c List]). 27/30
121 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (6) binary(rows) :- append(rows, Vs), Vs ins 0..1, transpose(rows, Columns), maplist(no_triplets, Rows), maplist(no_triplets, Columns), maplist(zero_one_balance, Rows), maplist(zero_one_balance, Columns), phrase(pairs(rows), Row_Pairs), phrase(pairs(columns), Column_Pairs), maplist(not_same, Row_Pairs), maplist(not_same, Column_Pairs), label(vs). no_triplets(list) :- length(list,l), L < 3. no_triplets([a,b,c List]) :- A+B+C #> 0, A+B+C #< 3, no_triplets([b,c List]). zero_one_balance(list) :- length(list,l), Half is L // 2, sum(list, #= Half). not_same((list1,list2) :- maplist(diff, List1, List2, Diffs), sum(diffs, #>, 0). diff(a, B, Diff) :- Diff #<==> A #\= B. pairs([_]) --> []. pairs([x List]) --> pairs_(x, List), pairs(list). pairs_(_, []) --> []. pairs_(x, [Y List]) --> [(X,Y)], pairs_(x,list). 27/30
122 AN EXAMPLE WHERE LOGIC PROGRAMMING SHINES: CONSTRAINT SATISFACTION (7) Prolog: 31 LOC Around 7 secs to solve SWI Prolog Free, well maintained, feature-rich, ISO compliant Much slower than SICSTUS Prolog (commercial) Python: SAT solver (250 LOC) Encode puzzle as CNF (150 LOC) Around 70 secs to solve Could get faster if Implemented in C++ Using state-of-the-art SAT solver 28/30
123 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want 29/30
124 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? 29/30
125 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions 29/30
126 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ 29/30
127 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala 29/30
128 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell 29/30
129 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell Prolog 29/30
130 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell Prolog Trust me, I know what I m doing Strict compile-time checks 29/30
131 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell Prolog Trust me, I know what I m doing Strict compile-time checks C++, Java 29/30
132 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell Prolog Trust me, I know what I m doing Strict compile-time checks Python, Ruby C++, Java 29/30
133 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell Prolog Trust me, I know what I m doing Strict compile-time checks Python, Ruby C++, Java Haskell 29/30
134 EXPRESSIVENESS OF PROGRAMMING LANGUAGES We want expressive programming languages that make programming easy: Concise Help to avoid common bugs Help to express exactly what we want What do we want exactly? Fine-grained control High-level abstractions C++ Python, Ruby, Java, Scala Haskell Prolog Trust me, I know what I m doing Strict compile-time checks Python, Ruby C++, Java Scala Haskell 29/30
135 SUMMARY Programming languages are the tools we use to express computations. 30/30
136 SUMMARY Programming languages are the tools we use to express computations. Different programming languages may be better for different jobs. 30/30
137 SUMMARY Programming languages are the tools we use to express computations. Different programming languages may be better for different jobs. Be eager to explore new programming languages! Outside your comfort zone! It s fun. It makes you a better programmer, even in your favourite language. Your favourite language may change. 30/30
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
INTRODUCTION TO HASKELL
INTRODUCTION TO HASKELL PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/81 HASKELL: A PURELY FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be
Software System Design and Implementation
Software System Design and Implementation Property-based Testing Gabriele Keller The University of New South Wales School of Computer Science and Engineering Sydney, Australia COMP3141 17s1 Testing in
Concepts in Programming Languages
Concepts in Programming Languages Marcelo Fiore Computer Laboratory University of Cambridge 2012 2013 (Easter Term) 1 Practicalities Course web page: with lecture
! Broaden your language horizons. ! Study how languages are implemented. ! Study how languages are described / specified
Course Goal CMSC 330: Organization of Programming Languages Introduction Instructors: Mike Hicks, Chau-Wen Tseng TAs: Srividya Ramaswamy, Eylul Dogruel, Khoa Doan Learn how programming languages work!
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
Topic I. Introduction and motivation References: Chapter 1 of Concepts in programming languages by J. C. Mitchell. CUP, 2003.
Topic I Introduction and motivation References: Chapter 1 of Concepts in programming languages by J. C. Mitchell. CUP, 2003. Chapter 1 of Programming languages: Design and implementation (3RD EDITION)
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
Com S 541. Programming Languages I
Programming Languages I Lecturer: TA: Markus Lumpe Department of Computer Science 113 Atanasoff Hall http://www.cs.iastate.edu/~lumpe/coms541.html TR 12:40-2, W 5 Pramod Bhanu Rama Rao Office hours: TR
CSC 326H1F, Fall Programming Languages. What languages do you know? Instructor: Ali Juma. A survey of counted loops: FORTRAN
What languages do you know? CSC 326H1F, Programming Languages The usual suspects: C, C++, Java fine languages nearly the same Perhaps you've also learned some others? assembler Basic, Visual Basic, Turing,
! Broaden your language horizons! Different programming languages! Different language features and tradeoffs. ! Study how languages are implemented
Course Goal CMSC 330: Organization of Programming Languages Introduction Learn how programming languages work Broaden your language horizons! Different programming languages! Different language features
Functional Programming and Haskell
Functional Programming and Haskell Tim Dawborn University of Sydney, Australia School of Information Technologies Tim Dawborn Functional Programming and Haskell 1/22 What are Programming Paradigms? A programming
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
Programming (ERIM) Lecture 1: Introduction to programming paradigms and typing systems. Tommi Tervonen
Programming (ERIM) Lecture 1: Introduction to programming paradigms and typing systems Tommi Tervonen Econometric Institute, Erasmus School of Economics Course learning objectives After this course, you
Languages october 22, 2017 Éric Lévénez <http://www.levenez.com/lang/> FORTRAN III end-1958 FORTRAN II FORTRAN I october 1956
1954 1957 FORTRAN november 1954 FORTRAN I october 1956 FORTRAN II 1957 FORTRAN III end-1958 B-O 1957 Flow-Matic 1958 COBOL 1959 JOVIAL 1959 IAL 1958 ALGOL 58 1958 Lisp 1958 Lisp 1 1959 Languages october
CS 242. Fundamentals. Reading: See last slide
CS 242 Fundamentals Reading: See last slide Syntax and Semantics of Programs Syntax The symbols used to write a program Semantics The actions that occur when a program is executed Programming language
Programming (Econometrics)
Programming (Econometrics) Lecture 1: Introduction Tommi Tervonen Econometric Institute, Erasmus University Rotterdam Course learning objectives After this course, you should be able to: Program econometrical
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
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
Seminar on Languages for Scientific Computing Aachen, 6 Feb Navid Abbaszadeh.
Scientific Computing Aachen, 6 Feb 2014 navid.abbaszadeh@rwth-aachen.de Overview Trends Introduction Paradigms, Data Structures, Syntax Compilation & Execution Concurrency Model Reference Types Performance
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
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,
Types II. Hwansoo Han
Types II Hwansoo Han Arrays Most common and important composite data types Homogeneous elements, unlike records Fortran77 requires element type be scalar Elements can be any type (Fortran90, etc.) A mapping
Programming Languages
Programming Languages Tevfik Koşar Lecture - XVIII March 23 rd, 2006 1 Roadmap Arrays Pointers Lists Files and I/O 2 1 Arrays Two layout strategies for arrays Contiguous elements Row pointers Row pointers
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,
Lecture 8: Summary of Haskell course + Type Level Programming
Lecture 8: Summary of Haskell course + Type Level Programming Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense October 31, 2017 Principles from Haskell
Organization of Programming Languages (CSE452) Why are there so many programming languages? What makes a language successful?
Organization of Programming Languages (CSE452) Instructor: Dr. B. Cheng Fall 2004 1 Why are there so many programming languages? Evolution -- we've learned better ways of doing things over time Socio-economic
COP4020 Programming Languages. Compilers and Interpreters Robert van Engelen & Chris Lacher
COP4020 ming Languages Compilers and Interpreters Robert van Engelen & Chris Lacher Overview Common compiler and interpreter configurations Virtual machines Integrated development environments Compiler
General Concepts. Abstraction Computational Paradigms Implementation Application Domains Influence on Success Influences on Design
General Concepts Abstraction Computational Paradigms Implementation Application Domains Influence on Success Influences on Design 1 Abstractions in Programming Languages Abstractions hide details that
Using Scala in CS241
Using Scala in CS241 Winter 2018 Contents 1 Purpose 1 2 Scala 1 3 Basic Syntax 2 4 Tuples, Arrays, Lists and Vectors in Scala 3 5 Binary output in Scala 5 6 Maps 5 7 Option types 5 8 Objects and Classes
Testing. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 2. [Faculty of Science Information and Computing Sciences]
![Testing. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 2. [Faculty of Science Information and Computing Sciences]](/thumbs/89/100566300.jpg "Testing. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 2. [Faculty of Science Information and Computing Sciences]")
Testing Advanced functional programming - Lecture 2 Wouter Swierstra and Alejandro Serrano 1 Program Correctness 2 Testing and correctness When is a program correct? 3 Testing and correctness When is a
Metaprogramming. Concepts of Programming Languages. Alexander Schramm. 2. November Institut für Softwaretechnik und Programmiersprachen
Metaprogramming Concepts of Programming Languages Alexander Schramm Institut für Softwaretechnik und Programmiersprachen 2. November 2015 A. Schramm 2. November 2015 1/39 Table of Contents Introduction
CS 345. Functions. Vitaly Shmatikov. slide 1
CS 345 Functions Vitaly Shmatikov slide 1 Reading Assignment Mitchell, Chapter 7 C Reference Manual, Chapters 4 and 9 slide 2 Procedural Abstraction Can be overloaded (e.g., binary +) Procedure is a named
9/7/17. Outline. Name, Scope and Binding. Names. Introduction. Names (continued) Names (continued) In Text: Chapter 5
Outline Name, Scope and Binding In Text: Chapter 5 Names Variable Binding Type bindings, type conversion Storage bindings and lifetime Scope Lifetime vs. Scope Referencing Environments N. Meng, S. Arthur
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
Lecture 1: Course Introduction
Lecture 1: Course Introduction CS164: Programming Languages and Compilers P. N. Hilfinger, 787 Soda Spring 2015 Acknowledgement. Portions taken from CS164 notes by G. Necula. Last modified: Wed Jan 21
A Tour of Language Implementation
1 CSCE 314: Programming Languages Dr. Flemming Andersen A Tour of Language Implementation Programming is no minor feat. Prometheus Brings Fire by Heinrich Friedrich Füger. Image source: https://en.wikipedia.org/wiki/prometheus
CSc 372. Comparative Programming Languages. 2 : Functional Programming. Department of Computer Science University of Arizona
1/37 CSc 372 Comparative Programming Languages 2 : Functional Programming Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg 2/37 Programming Paradigms
COSC Software Engineering. Lecture 23: Multilingual and Component Programming
COSC345 2013 Software Engineering Lecture 23: Multilingual and Component Programming Isolation Scale Change Errors These are core issues in Software Engineering Isolation is our main way to deal with them
Harvard-MIT Division of Health Sciences and Technology HST.952: Computing for Biomedical Scientists HST 952. Computing for Biomedical Scientists
Harvard-MIT Division of Health Sciences and Technology HST.952: Computing for Biomedical Scientists HST 952 Computing for Biomedical Scientists Introduction Medical informatics is interdisciplinary, and
Part 20. Sorting and Selection
Part 20 Sorting and Selection CSCI 3110 Code Summer 2015 1 Introduction Here we implement the different sorting algorithms discussed in class: Insertion Sort, Merge Sort, and the various variants of Quick
8/27/17. CS-3304 Introduction. What will you learn? Semester Outline. Websites INTRODUCTION TO PROGRAMMING LANGUAGES
CS-3304 Introduction In Text: Chapter 1 & 2 COURSE DESCRIPTION 2 What will you learn? Survey of programming paradigms, including representative languages Language definition and description methods Overview
9/21/17. Outline. Expression Evaluation and Control Flow. Arithmetic Expressions. Operators. Operators. Notation & Placement
Outline Expression Evaluation and Control Flow In Text: Chapter 6 Notation Operator evaluation order Operand evaluation order Overloaded operators Type conversions Short-circuit evaluation of conditions
More Lambda Calculus and Intro to Type Systems
More Lambda Calculus and Intro to Type Systems Plan Heavy Class Participation Thus, wake up! Lambda Calculus How is it related to real life? Encodings Fixed points Type Systems Overview Static, Dyamic
Discovering Computers 2008
Discovering Computers 2008 Chapter 13 (a) Programming Languages and Program Development 1 Chapter 13 Objectives Differentiate between machine and assembly languages Identify and discuss the purpose of
LECTURE 1. Overview and History
LECTURE 1 Overview and History COURSE OBJECTIVE Our ultimate objective in this course is to provide you with the knowledge and skills necessary to create a new programming language (at least theoretically).
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
COSE212: Programming Languages. Lecture 3 Functional Programming in OCaml
COSE212: Programming Languages Lecture 3 Functional Programming in OCaml Hakjoo Oh 2017 Fall Hakjoo Oh COSE212 2017 Fall, Lecture 3 September 18, 2017 1 / 44 Why learn ML? Learning ML is a good way of
CS 565: Programming Languages. Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106
CS 565: Programming Languages Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106 Administrivia Who am I? Course web page http://www.cs.purdue.edu/homes/peugster/cs565spring08/ Office hours By appointment Main
Tales from the Workshops
Tales from the Workshops Dr Russel Winder email: russel@winder.org.uk twitter: @russel_winder Web: http://www.russel.org.uk 1 Agile is the new black. 2 Aims, goals, objectives 3 Aims, goals, objectives
Functional Programming Principles in Scala. Martin Odersky
Functional Programming Principles in Scala Martin Odersky Programming Paradigms Paradigm: In science, a paradigm describes distinct concepts or thought patterns in some scientific discipline. Main programming
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
Adv. Course in Programming Languages
Department of Computer Science, University of Tsukuba No.3 How to write Code Generator for Power? In your favorite programming language!! C, C++ (with template), C# Fortran Lisp, Scheme, Clojure Java,
Why are there so many programming languages? Why do we have programming languages? What is a language for? What makes a language successful?
Chapter 1 :: Introduction Introduction Programming Language Pragmatics Michael L. Scott Why are there so many programming languages? evolution -- we've learned better ways of doing things over time socio-economic
CS 415 Midterm Exam Spring 2002
CS 415 Midterm Exam Spring 2002 Name KEY Email Address Student ID # Pledge: This exam is closed note, closed book. Good Luck! Score Fortran Algol 60 Compilation Names, Bindings, Scope Functional Programming
Introduction to Engineering Using Robotics Experiments. Dr. Yinong Chen
Introduction to Engineering Using Robotics Experiments Dr. Yinong Chen Outline Historical Perspective Programming Language Generations Programming Language Paradigms Imperative Programming Paradigm Writing
Informal Semantics of Data. semantic specification names (identifiers) attributes binding declarations scope rules visibility
Informal Semantics of Data semantic specification names (identifiers) attributes binding declarations scope rules visibility 1 Ways to Specify Semantics Standards Documents (Language Definition) Language
Weeks 6&7: Procedures and Parameter Passing
CS320 Principles of Programming Languages Weeks 6&7: Procedures and Parameter Passing Jingke Li Portland State University Fall 2017 PSU CS320 Fall 17 Weeks 6&7: Procedures and Parameter Passing 1 / 45
Programming Systems in Artificial Intelligence Functional Programming
Click to add Text Programming Systems in Artificial Intelligence Functional Programming Siegfried Nijssen 8/03/16 Discover thediscover world at the Leiden world University at Leiden University Overview
Software II: Principles of Programming Languages. Why Expressions?
Software II: Principles of Programming Languages Lecture 7 Expressions and Assignment Statements Why Expressions? Expressions are the fundamental means of specifying computations in a programming language
EL2310 Scientific Programming
Lecture 16: STL, C++1y (ramviyas@kth.se) Overview Overview Lecture 16: STL and C++1y Reminders Wrap up C++11 Reminders The help sessions and deadline C++ help session: Fri 24.10.2015, 15:00-17:00, Room
Simply-Typed Lambda Calculus
#1 Simply-Typed Lambda Calculus #2 Back to School What is operational semantics? When would you use contextual (small-step) semantics? What is denotational semantics? What is axiomatic semantics? What
Modern Stored Procedures Using GraalVM
Modern Stored Procedures Using raalvm Oracle Labs Matthias Brantner Safe Harbor Statement The following is intended to outline our general product direction. t is intended
Programming Paradigms
PP 2017/18 Unit 18 Summary of Basic Concepts 1/13 Programming Paradigms Unit 18 Summary of Basic Concepts J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE PP 2017/18 Unit 18
More Lambda Calculus and Intro to Type Systems
More Lambda Calculus and Intro to Type Systems #1 One Slide Summary The lambda calculus is a model of computation or a programming language that is as expressive as a Turing machine. The lambda calculus
Programming Languages Fall 2013
Programming Languages Fall 2013 Lecture 2: types Prof. Liang Huang huang@qc.cs.cuny.edu Recap of Lecture 1 functional programming vs. imperative programming basic Haskell syntax function definition lazy
CSCI-1200 Data Structures Spring 2018 Lecture 7 Order Notation & Basic Recursion
CSCI-1200 Data Structures Spring 2018 Lecture 7 Order Notation & Basic Recursion Review from Lectures 5 & 6 Arrays and pointers, Pointer arithmetic and dereferencing, Types of memory ( automatic, static,
LECTURE 18. Control Flow
LECTURE 18 Control Flow CONTROL FLOW Sequencing: the execution of statements and evaluation of expressions is usually in the order in which they appear in a program text. Selection (or alternation): a
Low-Level Languages. Computer Programs and Programming Languages
Computer Programs and Programming Languages What is a computer program? Set of instructions that directs computer to perform tasks Programming used to write instructions 1 Computer Programs and Programming
Principles in Programming: Orientation & Lecture 1. SWE2004: Principles in Programming Spring 2014 Euiseong Seo
Principles in Programming: Orientation & Lecture 1 1 Course Objectives Introduce various subjects in computer science through puzzles and problems Most problems came from ICPC 2 Textbook Programming Challenges
Data Types. (with Examples In Haskell) COMP 524: Programming Languages Srinivas Krishnan March 22, 2011
Data Types (with Examples In Haskell) COMP 524: Programming Languages Srinivas Krishnan March 22, 2011 Based in part on slides and notes by Bjoern 1 Brandenburg, S. Olivier and A. Block. 1 Data Types Hardware-level:
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
CS 314 Principles of Programming Languages
CS 314 Principles of Programming Languages Lecture 15: Review and Functional Programming Zheng (Eddy) Zhang Rutgers University March 19, 2018 Class Information Midterm exam forum open in Sakai. HW4 and
Scripted Components: Problem. Scripted Components. Problems with Components. Single-Language Assumption. Dr. James A. Bednar
Scripted Components: Problem Scripted Components Dr. James A. Bednar jbednar@inf.ed.ac.uk http://homepages.inf.ed.ac.uk/jbednar (Cf. Reuse-Oriented Development; Sommerville 2004 Chapter 4, 18) A longstanding
Scripted Components Dr. James A. Bednar
Scripted Components Dr. James A. Bednar jbednar@inf.ed.ac.uk http://homepages.inf.ed.ac.uk/jbednar SAPM Spring 2012: Scripted Components 1 Scripted Components: Problem (Cf. Reuse-Oriented Development;
A little bit of history. Jordi Cortadella Department of Computer Science
A little bit of history Jordi Cortadella Department of Computer Science Mechanization Introduction to Programming Dept. CS, UPC 2 Mechanization Introduction to Programming Dept. CS, UPC 3 The old dream
Foundations. Yu Zhang. Acknowledgement: modified from Stanford CS242
Spring 2013 Foundations Yu Zhang Acknowledgement: modified from Stanford CS242 https://courseware.stanford.edu/pg/courses/317431/ Course web site: http://staff.ustc.edu.cn/~yuzhang/fpl Reading Concepts
MIDTERM EXAMINATION - CS130 - Spring 2003
MIDTERM EXAMINATION - CS130 - Spring 2003 Your full name: Your UCSD ID number: This exam is closed book and closed notes Total number of points in this exam: 120 + 10 extra credit This exam counts for
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
Semantic Analysis. How to Ensure Type-Safety. What Are Types? Static vs. Dynamic Typing. Type Checking. Last time: CS412/CS413
CS412/CS413 Introduction to Compilers Tim Teitelbaum Lecture 13: Types and Type-Checking 19 Feb 07 Semantic Analysis Last time: Semantic errors related to scopes Symbol tables Name resolution This lecture:
Lecture 1: Course Introduction
Lecture 1: Course Introduction CS164: Programming Languages and Compilers P. N. Hilfinger, 787 Soda Fall 2013 Acknowledgement. Portions taken from CS164 notes by G. Necula. Last modified: Thu Aug 29 16:03:34
INTRODUCTION PRINCIPLES OF PROGRAMMING LANGUAGES. Norbert Zeh Winter Dalhousie University 1/10
INTRODUCTION PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/10 GOAL OF THIS COURSE 2/10 GOAL OF THIS COURSE Encourage you to become better programmers 2/10 GOAL OF THIS
Storage. Outline. Variables and Updating. Composite Variables. Storables Lifetime : Programming Languages. Course slides - Storage
Storage 1 Variables and Updating Outline Composite Variables Total and selective updating Array variables Storables Lifetime Local and global variables Heap variables Persistent variables Garbage collection
CSc 372 Comparative Programming Languages
CSc 372 Comparative Programming Languages The University of Arizona Fall Semester, 2006 CSc 372, Fall 2006 Introduction Slide 1 CSc 372, Fall 2006 Introduction Slide 2 Introduction Instructor Teaching
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
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
Design & Implementation Overview
P Fall 2017 Outline P 1 2 3 4 5 6 7 P P Ontological commitments P Imperative l Architecture: Memory cells variables Data movement (memory memory, CPU memory) assignment Sequential machine instruction execution
Streams and Evalutation Strategies
Data and Program Structure Streams and Evalutation Strategies Lecture V Ahmed Rezine Linköpings Universitet TDDA69, VT 2014 Lecture 2: Class descriptions - message passing ( define ( make-account balance
Introduction to Functional Programming
A Level Computer Science Introduction to Functional Programming William Marsh School of Electronic Engineering and Computer Science Queen Mary University of London Aims and Claims Flavour of Functional
Outline. Introduction to Programming (in C++) Introduction. First program in C++ Programming examples
Outline Introduction to Programming (in C++) Introduction Programming examples Algorithms, programming languages and computer programs Jordi Cortadella, Ricard Gavaldà, Fernando Orejas Dept. of Computer
Fibonacci in Lisp. Computer Programming: Skills & Concepts (CP1) Programming Languages. Varieties of Programing Language
Fibonacci in Lisp Computer Programming: Skills & Concepts (CP1) Programming Languages (defun fibonacci (n) (if (or (= n 0) (= n 1)) 1 (+ (fibonacci (- n 1)) (fibonacci (- n 2))))) 22nd November 2010 defun-
Lecture 15: Iteration and Recursion
Lecture 15: and Recursion The University of North Carolina at Chapel Hill Spring 2002 Lecture 15: and Recursion Feb 13/15 1 Control Flow Mechanisms Sequencing Textual order, Precedence in Expression Selection
Scope. Chapter Ten Modern Programming Languages 1
Scope Chapter Ten Modern Programming Languages 1 Reusing Names Scope is trivial if you have a unique name for everything: fun square a = a * a; fun double b = b + b; But in modern languages, we often use
cs242 Kathleen Fisher Reading: Concepts in Programming Languages, Chapter 6 Thanks to John Mitchell for some of these slides.
cs242 Kathleen Fisher Reading: Concepts in Programming Languages, Chapter 6 Thanks to John Mitchell for some of these slides. We are looking for homework graders. If you are interested, send mail to cs242cs.stanford.edu
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
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:
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
CS6202: Advanced Topics in Programming Languages and Systems Lecture 0 : Overview
CS6202: Advanced Topics in Programming Languages and Systems Lecture 0 : Overview Advanced Language Features and Foundations Lecturer : Chin Wei Ngan Email : chinwn@comp.nus.edu.sg Office : S15 06-01 CS6202
Example: Haskell algebraic data types (1)
Example: Haskell algebraic data types (1) Type declaration: data Number = Exact Int Inexact Float Set of values: Each Number value consists of a tag, together with either an Integer variant (if the tag