The College of Saint Rose CIS 433 – Programming Languages David Goldschmidt, Ph.D. from Concepts of Programming Languages, 9th edition by Robert W. Sebesta, Addison-Wesley, 2010, ISBN

 Imperative Languages  Data and programs are both stored in memory  Variables mimic memory  Assignment statements  Arithmetic operations  Iterative repetition  Control structures  etc.

 The design of imperative languages is based directly on the von Neumann architecture  Efficiency is a primary concern  Variables are abstractions of memory locations  The design of functional languages is based directly on mathematical functions  A solid theoretical basis more natural to users  Minimally concerned with machine architecture

 A mathematical function is a mapping of members from one set (the domain) to members of another set (the range)  Parameters represent any member of the domain  Once set, a parameter is fixed to represent exactly one value during the evaluation of the mapping expression # Python def cube( x ): return x * x * x

 Mathematical functions define values whereas typical programming language functions produce values cube(x) ≡ x * x * x, where x is a real number function name function parameter(s) “is defined as” mapping expression

 A lambda expression specifies the parameters and mapping expression of a function  Essentially a nameless function  During evaluation, parameter x is bound to a particular member of the domain (x)x * x * x function parameter(s) # Python lambda x:x*x*x mapping expression

 The lambda expression is the function itself  Apply the expression to one or more parameters ( (x)x * x * x)(4) # Python (lambda x:x*x*x)(4) ( (x,y)x * y)(8,7) # Python (lambda x,y:x*y)(8,7)

 A functional form is a higher-order function that either takes functions as parameters or yields functions as its results (or both)  Example: the apply-to-all (α) functional form cube(x) ≡ x * x * x, where x is a real number α( cube, (3, 5, 2) ) ===> (27, 125, 8) # Python map( cube, [3, 5, 2] ) map( math.sqrt, [2, 3, 4, 5] ) map( lambda x,y:x+y, [3, 4, 5], [6, 7, 8] )

 In imperative languages, operations are performed and results are stored in variables for later use  Management of variables is a constant concern and source of complexity (and bugs!)  Functions in imperative language have side effects

 Functional programming languages mimic mathematical functions and mappings to the extent possible  The basic process of computation is fundamentally different than in imperative languages  No flow of control  No variables

 Write a program to calculate n-factorial  The input argument n is your only variable factorial(n) ≡ 1 if n = 0 n x factorial(n – 1) if n > 0 {

 LISP is a functional language designed at MIT by John McCarthy in 1958  Research in artificial intelligence required a language to: ▪ Process data in dynamic lists ▪ Support symbolic computation (rather than numeric)

 LISP has two data structures:  Atom: either a symbol or a numeric literal  List: a sequence of atoms and/or lists (A B C D) (A (B C) D (E (F G))) NIL

 Scheme was developed at MIT in the 1970s to be a cleaner and simpler version of LISP  Scheme uses an interpreter and built-in IDE  Literals evaluate to themselves  Scheme is available as Racket at

 Read and study Chapter 15  Download Racket  Do Exercises at the end of Chapter 15