Literature
Paulson, chap. 1 (excl. 1.7, 1.8) Paulson, chap. 2:
Value declarations (2.1-2.3) Numbers, characters, strings (2.4-2.6) Pairs, tuples, records (2.7-2.10) The evaluation of expressions (2.11-2.16)
Programming paradigms
Imperative programming Procedural Object-oriented
Functional programming (Logic programming)
Imperative Programming
Basic machine model: Machine has a state (memory, state of devices) State is acted upon by commands (e.g. “move a
byte to some location in memory’’) Programs describe sequences of state changes by
providing simple commands (“assign some value to a variable”) and constructs for composing those.
Procedural programming
Central notion: procedure. Purpose: Code factoring, reuse.
Procedure is a named piece of code (sequence of commands), parameterized by formal arguments.
Procedures can be called (invoked) by referring to their name and providing actual arguments (values) that are assigned to the corresponding formal arguments.
Object-oriented programming
Central concept: object. Purpose: Code factoring, abstraction (safety), reuse.
Encapsulation of data and the operations (procedures) that operate on those data.
Functional programming
Basic model: Machine consists of input ports and output ports. A program describes a function which computes
outputs for given inputs.
Central notions: value (incl. function), referential transparency, compositionality.
Referential transparency
Expression: describes a computation and its result (“value”)
Referential transparency: any computation can be replaced by its value in
any context, without affecting the observable results.
Example
function gcd(m,n: integer): integer; var prevm: integer;begin while m <> 0 do begin prevm := m; m := n mod m; n := prevm end; gcd := nend;
fun gcd (m, n) = if m = 0 then n else gcd (n mod m, m);
Functional programming: Characteristics
Powerful ‘bulk’ data types, e.g. lists, trees. Higher-order functions: functions as values (can be
passed as parameters to and returned from other functions, stored in data structures)
Recursion: Recursively defined functions and types. Pattern matching: convenient access to components
of data structures
Functional programming: Characteristics...
Polymorphism: Flexible and safe reuse of functions with many types of arguments
Safe composition: Support for modular composition.
High-level programming: automatic memory management no low-level data types
Functional Programming: Principles
Orthogonality: No ad-hoc restrictions on how language constructs can be combined.
Rigor: Languages are well-defined; support for rigorous reasoning about behavior of programs
Safety: Static and dynamic checking of safety of operations; careful design of basic types and their operations.
Names, functions and types
Values: Values have no identity, no birth date, no
expiration date, and they can’t change (ever hear of a 5 turning into a 6?); they are unchanging and immortal.
E.g., the string “Susanne”, the number denoted by the Arabic numeral 5, the list of natural numbers from 0 to 5: [0,1,2,3,4,5], etc.
Names, functions and types...
Names: Names refer to things (values, people, etc.) Names can be bound to values in constructs called
declarations. In this fashion we can refer to values by their names. (Q: How many names can a value have?)
Some values have predefined names (constants) that cannot be bound to other values; e.g. 60 is the standard name (“numeral”) for a particular natural number.
NB: Names are not values. Susanne as a name is not the same as the string “Susanne”, which is a value.
Identifiers in SML
Identifiers: Those names that can be bound to values in declarations Alphabetic names (length) Symbolic names (@) Long identifiers (String.sub)
Some identifiers are predefined; that is, they are bound to a value at program startup, but can be bound in a declaration to a new value.
Truth values (“Booleans”) and conditional expressions
Boolean constants: true, false Conditional expressions:if ... then ... else ...
E.g.:fun sign(n) = if n>0 then 1else if n=0 then 0else (* n<0 *) ~1
Pairs, tuples, records
Pairs (2-tuples): e.g.,(5, 8), (“Susanne”, 30)
Tuples (n-tuples): e.g., (5, 8, 9), (“Susanne”, 30, #”a”)
Records (named tuples): e.g., { firstName = “Susanne”, age = 30, empCategory = #”a” }
Pairs, tuples, records...
Record selection:val tup1 = (5, 8);val tup2 = (“Susanne”, 30, #”a”);val empRec = {...};#1 tup1;#3 tup2;#firstName empRec;
Record types
Tuple types: int * int, string * int * char
Record types: {firstName: string, age: int, empCategory: char}
Type declarations
Type declaration: Binding of type (expression) to identifier.
E.g., type empRecType = {firstName: string, age: int, empCategory: char}