1. λ => Scheme for Rubyists

2. Scheme History Authors: Guy Steele and Gerald Sussman Structure and Interpretation of Computer Programs (SICP) by Abelson & Sussman http://mitpress.mit.edu/sicp/ http://www.archive.org/details.php?identifier=mit_ocw_sicp

3. Scheme in Real Life GIMP (Script-Fu) Guile (official extension language of GNU) Lily Pond (sheet music engraving)

4. Scheme is a Lisp dialect LISP ==> “LIS t P rocessing language ”

5. Scheme is a Lisp dialect LISP ==> “LIS t P rocessing language ” LISP ==> L ots of I rritating S uperfluous P arentheses

6. Lisp Family of languages: Common Lisp Scheme Emacs Lisp Clojure Arc First incarnation by John McCarthy, 1958 older than COBOL (!)

7. Lisp vs. the World Prefix notation (+ x y) (< x y) (eq? x y)

8. Lisp vs. the World No operator precedence rules (mandatory parentheses eliminate the need) (sqrt (+ (/ (* 3 4) 2) 3))

9. Lisp vs. the World No operator precedence rules (mandatory parentheses eliminate the need) (sqrt (+ (/ (* 3 4) 2) 3)) ==> 3

10. Lisp vs. the World Functions are first-class objects, so we can: Assign them to variables Pass them as parameters to other functions Return them from other functions

11. Lisp vs. the World Example of 1st-class function use in Scheme (Scheme's map =~ Ruby's map or collect ) (define square (lambda (x) (* x x))) (map square (list 1 2 3 4 5 6 7 8 9))

12. Lisp vs. the World Example of 1st-class function use in Scheme (Scheme's map =~ Ruby's map or collect ) (define square (lambda (x) (* x x))) (map square (list 1 2 3 4 5 6 7 8 9)) ==> (1 4 9 16 25 36 49 64 81)

13. Lisp vs. the World Linked lists are built in; based on pairs Scheme representation: (1 2 “a” 4 #\b) 1 2 “a” 4 #\b (empty list)

14. Scheme vs. Other Lisps Optimized tail recursion “Normal” looping constructs are not used Tail-recursive procedures are replaced by iterative version in compilation Why? Even for mutually recursive procedures

15. Scheme vs. Other Lisps Optimized tail recursion “Normal” looping constructs are not used Tail-recursive procedures are replaced by iterative version in compilation Why? So we don't blow the stack Even for mutually recursive procedures

16. Mutual Tail Recursion (define even? (lambda (x) (if (= x 0) #t (odd? (- x 1))))) (define odd? (lambda (x) (if (= x 0) #f (even? (- x 1)))))

17. Why use recursion? Some problems are more cleanly solved

18. Why use recursion? Some problems are more cleanly solved Especially in mathematics factorial(n) = { 1 if n==0 or n==1 n * factorial(n-1)

19. Why use recursion? (define factorial (lambda (n) (cond ((or (= n 1) (= n 0)) 1) (else (* n (factorial (- n 1))))))) Nearly identical to math definition Any problems?

20. Why use recursion? (define factorial (lambda (n) (cond ((or (= n 1) (= n 0)) 1) (else (* n (factorial (- n 1))))))) Nearly identical to math definition Any problems? not tail-recursive

21. Why use recursion? (define factorial (lambda (n) (define factorial2 (lambda (n acc) (cond ((or (= n 1) (= n 0)) acc) (else (factorial2 (- n 1) (* n acc)))))) (factorial2 n 1))) Now we're tail-recursive Is this better?

22. Why use recursion? (define factorial (lambda (n) (define factorial2 (lambda (n acc) (cond ((or (= n 1) (= n 0)) acc) (else (factorial2 (- n 1) (* n acc)))))) (factorial2 n 1))) Now we're tail-recursive Is this better? it depends

23. A Tale of Two Factorial Solutions (factorial 5) (* 5 (factorial 4)) (* 5 (* 4 (factorial 3))) (* 5 (* 4 (* 3 (factorial 2)))) (* 5 (* 4 (* 3 (* 2 (factorial 1))))) (* 5 (* 4 (* 3 (* 2 1)))) (* 5 (* 4 (* 3 2))) (* 5 (* 4 6)) (* 5 (24)) 120 (factorial 5) (factorial2 5 1) (factorial2 4 5) (factorial2 3 20) (factorial2 2 60) (factorial2 1 120) 120 Non-tail-recursiveTail-recursive

24. Scheme vs. Other Lisps Scheme has a minimal set of standard features Common Lisp has lots of built-in libraries One namespace :( Continuations Representation of the state of execution (think goto on steroids) Also available in Ruby ( callcc )

25. Prefix Notation (+ 2 7) => 9 (* 2/3 5/8) => 5/12 (/ 1.0 3) =>.333333333333 (= 2 (+ 0 3)) => #f (not (= (> 2 (+ 6 1)) #t)) => #t

26. Defining Procedures (define add (lambda (x y) (+ x y))) (define truthy? (lambda (x) (not (= #f x)))) (define (truthy? x) (not (= #f x)))

27. Quoting (1 2 3) ;The object 1 is not applicable. (quote (1 2 3)) ==> (1 2 3) '(1 2 3) ==> (1 2 3) 'testing ==> testing

28. Applying Procedures (add 7 17) => 24 (truthy? '(1 2 4)) => #t (truthy? #f) => #f (truthy? 78) => #t

29. Parsing Lists (car '(1 2 3)) ==> 1 (cdr '(1 2 3)) ==> (2 3)

30. Building Lists (cons 1 2) ==> (1. 2) (cons 1 (cons 2 '())) ==> (1 2) 12 12 (empty list)

31. Building Lists Will this work the way we expect? (cons '(1 2 3) '(4 5 6))

32. Building Lists Will this work the way we expect? (cons '(1 2 3) '(4 5 6)) ==> ((1 2 3) 4 5 6)

33. Building Lists What about this? (cons 1 (cons 2 (cons 3 '(4 5 6))))

34. Building Lists What about this? (cons 1 (cons 2 (cons 3 '(4 5 6)))) ==> (1 2 3 4 5 6) Yes, but this way sucks

35. Building Lists The simpler solution: (append '(1 2 3) '(4 5 6)) ==> (1 2 3 4 5 6)

36. Functional Programming The result depends only on the input(s) No side effects Easy to run in parallel

37. Scheme's functional-ness Scheme encourages functional programming But it doesn't require it (not purely functional) (define x '(1 2 3)) x ==> (1 2 3) (set-car! x 'stupid-symbol) x ==> (stupid-symbol 2 3) (set-cdr! x '(#t #f)) x ==> (stupid-symbol #t #f)

38. Getting Started with Scheme Download an implementation MIT-Scheme: http://www.gnu.org/software/mit-scheme/http://www.gnu.org/software/mit-scheme/ Set up your text editor Emacs (indentation help) http://www.aquamacs.org Textmate Bundle http://svn.textmate.org/trunk/Bundles/Scheme.tmbundle http://svn.textmate.org/trunk/Bundles/Scheme.tmbundle

39. Anything else we might want?

40. Test Manager: xUnit for Scheme Author: Alexey Radul Home Page: http://web.mit.edu/~axch/www/index.html Documentation: http://web.mit.edu/~axch/www/testing.html

41. Test Manager Example (load “test-manager/load.scm”) (define-each-test (assert-equal 2 (factorial 2)) (assert-equal 6 (factorial 3)) (assert-equal 24 (factorial 4))) (run-registered-tests)

42. λ => Happy Happy Joy Joy