5 october 2001ifip wg 2.31 preparation start drscheme set language level to beginner open in...

5 October 2001 IFIP WG 2.3 1

preparation

• start drscheme • set language level to Beginner• open in Presentations

– length1.ss– planets0.ss– lambda.ss– convert.ss

• add teachpack convert.ss, then throw out (easy to find)


Why do “They” Still Teach SchemeWhen Haskell is So Much Better?

Matthias Felleisen (PLT)Northeastern University

Rice University

Houston, Texas


What does the question mean?

• Programmers in industry?

• College students in senior year? – need buzz words/current technology

• College students in first year? – need systematic design skills


Haskell vs Scheme: Two Different Universes

• conventional syntax

• type system– partitions

• call-by-need

• controlled effects

• parenthesized, prefix

• unitype system – predicates

• call-by-value

• full power of effects


Haskell and Scheme: One Approach to Teaching

• layered languages

• higher-order functions

• design via classes of values

• emphasize composition over effects

views of PLT not necessarily the general Scheme community


Haskell loves Scheme, Scheme loves Haskell :-)

The Commonalties outweigh the differences. So what’s the true question?


Why do “They” Still Teach Scheme or Haskell When Java and C# are So

Fashionable?


Outline

• answer both questions

• PLT’s TeachScheme! perspective national and international efforts to expose college and high school teachers to program design

• “TeachHaskell”?


PLT’s TeachScheme! Program

• Context: introductory programming at college and high school level

• introduce two important ideas: – program design – model(s) of computation

• write significant code– reaches non-majors as well as majors


PLT’s TeachScheme! Program

• Scheme: simple syntax, simple semantics

• DrScheme: a PDE for beginners

• “How to Design Programs” (MIT, 2001) – the structure and organization of programs

(systematic program design)


Part I: The Programming Language


Programming Language: Scheme

• Scheme’s notation is simple: – (, operation, operands, )

• Scheme’s semantics is easy: – it’s just the rules of mathematics:

• 1+1 = 2

• f(12) = 12 * 12 + 25 = …

• With Scheme, we can focus on ideas


Programming Language: Scheme Again

• simple syntax

• simple semantics

• powerful PE

• rich language

• it’s a lie!

• more lies!

• do you believe this?

• so where are the GUIs?


length1 returns 0, no matter what input

algebraic syntax


more algebraic syntax

an error message concerning procedures,whatever those things are


Syntax is a Problem

• simple notational mistakes produce strange results -- without warning

• simple notational mistakes produce error messages beyond the students’ knowledge

• even in Scheme there are just too many features for focus on design


Programming Languages: Not One, Many

• language 1: first-order functional PL– functions and structures– simple conditional expressions

• language 2: higher-order functional PL– local function definitions– higher-order functions

• language 3: functions and effects– set! and structure mutation


Beginning Student Scheme

(define (f x) (+ (* 5 (square x)) (* 3 x) 27))

(define-struct dollar (amount))

(define-struct planet (name picture))

;; sign : RealNumber Symbol (define (sign x) (cond [(> x 0) ‘+] [(= x 0) ‘=] [(< x 0) ‘–])))


Intermediate Student Scheme

;; h : Num (listof Num) (listof Num)(define (h D alon) (local ((define (h-aux l) (cond [(empty? l) empty] [else (cons (+ (first s) D) (h-aux (rest s)))]))) (h-aux alon)))

;; d/dx : (Num Num) (Num Num)(define (d/dx f) (local ((define (f-prime x) (/ (- (f (+ x eps)) (f (- x eps))) 2 eps)) f-prime))


Advanced Student Scheme

(define counter 0)

(define (bump) (set! bump (+ bump 1)))

(define (zero-all boxes) (cond [(empty? boxes) (void)] [else (begin (set-box! (first boxes) 0) (zero-all (rest boxes)))]))


Lesson on Programming Languages

• arrange programming language in pedagogic layers

• … put students into a knowledge-appropriate context

• … focus on design ideas relative to this context


Part II: The Programming Environment


The Programming Environment

• one PE for all languages – supplemental code that does not

conform to the language level

• interactive– ensure model-view separation (MVC)

• exploration of– program structure– program evaluation


DrScheme: Demo

• language level: catching simple errors• pictures as values • lexical structure, alpha renaming • evaluation as algebraic reduction • teachpacks: model-view separation

– more in a moment …


Part III: Program Design Methods


Program Design for Beginners

• foster basic good habits in beginners

• emphasize systematic design of programs

• deemphasize input/output


Design Recipes

to be designedin out

How do we wire the “program” to the rest of the world?


Design Recipes


• read-from-console/compute/print• file I/o• graphical user interface (GUI)• common gateway interface (CGI)• etc.


Design Recipes


How do we wire the “program” to the rest of the world?

IMPERATIVE: Teach Model-View Separation


Design Recipes

• understand classes of data – representation of (external) information as

data in your favorite language

• understand “program” as function – that is triggered by events– that consumes/produces data

• most important: connect class definition and function definition


The Basic Design Recipe

• data analysis and class definition

• contract, purpose statement, header

• in-out (effect) examples

• function template

• function definition

• testing, test suite development


From Class Definitions to Function Templates

• the structure class definitions

• the structure of function templates


Design Recipes: Class Definitions

• use rigorous language, not formalism

• naïve set theory– basic sets: numbers, chars, booleans– intervals– (labeled) products, that is, structures – (tagged) unions– self-references– mutual references – vectors (natural numbers)


Design Recipes: Class Definitions (2)

(define-struct spider (name size legs))

A spider is a structure:

(make-spider symbol number number)



A zoo animal is either • a spider• an elephant • a giraffe • a mouse • …

Each of these classes of animals has its own definition



A list of zoo animals is either • empty• (cons animal a-list-of-zoo-animals)

Let’s make examples: • empty (by definition)• (cons (make-spider ‘Asterix 1 6) empty)• (cons (make-spider ‘Obelix 99 6) (cons … …))



(define-struct child (name father mother))

A family tree is either • ‘unknown • (make-child symbol a-family-tree a-family-tree-2)

Many, if not most, interesting class definitions are self-referential.


Design Recipes: Function Templates (Structure)

• a function template reflects the structure of the class definitions

• this match helps – designers guide the process– readers comprehend– teachers diagnose weaknesses– modifiers/maintainers analyze or change


Design Recipes: Templates (2)

• is it a basic class?

• is it a union?

• is it a structure?

• is it self-referential?

• “domain knowledge”

• case analysis

• extract field values

• annotate for recursion




;; fun-for-zoo : list-of-zoo-animals -> ???(define (fun-for-zoo a-loZA) … )

is it a union?




;; fun-for-zoo : list-of-zoo-animals -> ???(define (fun-for-zoo a-loZA) (cond [ <<condition>> <<answer>> ] [ <<condition>> <<answer>> ]))

what are the sub-classes




;; fun-for-zoo : list-of-zoo-animals -> ???(define (fun-for-zoo a-loZA) (cond [ (empty? a-loZA) <<answer>> ] [ (cons? a-loZA) <<answer>> ]))

are any of the potentialinputs structures?




;; fun-for-zoo : list-of-zoo-animals -> ???(define (fun-for-zoo a-loZA) (cond [ (empty? a-loZA) … ] [ (cons? a-loZA) … (first a-loZA) … … (rest a-loZA) … ]))

is the class definition self-referential?




;; fun-for-zoo : list-of-zoo-animals -> ???(define (fun-for-zoo a-loZA) (cond [ (empty? a-loZA) … ] [ (cons? a-loZA) … (first a-loZA) … … (rest a-loZA) … ]))


Design Recipes: Defining Functions

• templates remind beginners of all the information that is available– which cases– which field values, argument values – which natural recursions are computed

• the goal of function definitions is– to compute with the available values – to combine the computed effects


Design Recipes: Overview

• basic data, intervals of numbers • structures • unions• self-reference in class description • mutual references • generative recursion• special attributes:

– accumulators– effects

• abstraction of designs


Design Recipes: Conclusion

• get students used to discipline from DAY ONE

• use scripted question-and-answer game until they realize they can do it on their own

• works well as long as class definitions are “standard”


Part IV: From Scheme to Java

Training OO Programmers


Scheme to Java: OO Computing

• focus: objects and method invocation

• basic operations:– creation– select field – mutate field

• select method via “polymorphism”

• structures and functions

• basic operations:– creation– select field – mutate field – recognize kind

• f(o) becomes o.f()


Scheme to Java: OO Programming

• develop class and interface hierarchy

• allocate code of function to proper subclass

• develop class definitions

• allocate code of function to proper cond-clause


Scheme to Java: Class Hierarchy


List of zoo animals

Empty Cons: animal list of zoo animals


Scheme to Java: Code Allocation

;; fun-for-zoo : list-of-zoo-animals -> ???(define (fun-for-zoo a-loZA) (cond [ (empty? a-loZA) ] [ (cons? a-loZA) … (first a-loZA) … … (rest a-loZA) … ]))

List of zoo animals

Empty:

Cons: animal list of zoo animals


Scheme to Java: Ketchup & Caviar

abstract class List_Zoo_Animal { int fun_for_list(); }

class Cons extends List_Zoo_Animal { Zoo_Animal first; List_Zoo_Animal rest;

int fun_for_list() { return 1 + rest.fun_for_list(); }}

class Empty extends List_Zoo_Animal { int fun_for_list() { return 0; }}


Scheme to Java

• the design recipes work step for step for the production of OO programs

• the differences are notational

• the differences are instructive


Why not just Java first?

• complex notation, complex mistakes

• no PE supports stratified Java

• design recipes drown in syntax


Part V: Experiences


Experiences: Rice Constraints

• life-long learners

• accommodate industry long-time

• enable students to gain industry experience after two semesters

• no trends, no fashion

• oo programming components

• until recently: – C++

• now more and more:– Java, true OOP


Experiences: The Rice Experiment

beginners: no experience, up to three years of experience

comp sci introduction:• TeachScheme curriculum• good evaluation• huge growth • many different teachers

applied comp introduction:• C/C++ curriculum• weak evaluations• little growth •several teachers

second semester: OOP, classical data structures, patterns


Experiences: The Rice Experiment

• Faculty with preferences for C/C++ state that students from the Scheme introduction perform better on exams and projects in second course than students from the C/C++ introduction

• Students with lots of experiences eventually understand how much the course adds to their basis


Experiences: Secondary Schools

• trained around 200 teachers/professors

• 120+ deployed the curriculum, reuse it

• better basis for second courses

• much higher retention rate– especially among females


Part V: Teach Haskell ?


Social Theorem 1: Beginners make mistakes.

Corollary: Teaching efforts must help beginners and teachers find and help mistakes in designs, notation, and evaluations.


Social Theorem 2: To beginners, it’s about two things: the computer and the human.

Corollary: Adding intermediate layers doesn’t help.


Haskell’s Key Features

• conventional syntax

• types

• lazy data

• controlled effects

• see theorem 1

• see theorem 2

• yet another recipe

• too difficult, interesting


Working with Haskell (1)

queens_kill :: Int -> [Int] -> Bool

-- determine whether a queen can be placed in file lcon, -- places the preceding files of the boardqueesn_kill locn places = helper places 1 where helper [] _ = False helper (hd:tl) offset = lcon == hd || -- same file lcon == hd + offset || -- right diagonal lcon == hd - offset || -- left diagonal helper tl offset + 1



Reading file: `nq.hs`: Type checkingERROR: `nq.hs` (line 6): Bool is not an instance of class `Num`

line 6: helper [] _ = False




-- determine whether a queen can be placed in file lcon, -- places the preceding files of the boardqueesn_kill locn places = helper places 1 where helper [] _ = false helper (hd:tl) offset = lcon == hd || -- same file lcon == hd + offset || -- right diagonal lcon == hd - offset || -- left diagonal helper tl offset + 1




-- determine whether a queen can be placed in file lcon, -- places the preceding files of the boardqueesn_kill locn places = helper places 1 where helper [] _ = false helper (hd:tl) offset = lcon == hd || -- same file lcon == hd + offset || -- right diagonal lcon == hd - offset || -- left diagonal helper tl (offset + 1)


Keys to TeachScheme!’s Success: on to Haskell

• tower of languages

• pde support for (1)

• other pde support

• design recipes– emphasis on classes

of values

• tower of types• tower of notation • pde support for both

• easy

• adapt for lazy data• adapt for controlled

effects


Conclusions


Conclusion

• training good programmers does not mean starting them on “currently fashionable” languages

• provide a strong, rigorous foundation in data-oriented, class-oriented thinking

• then, and only then, expose to fashion


Conclusion

• students wish to intern during summer

• OOP languages are here to stay

• constraints on introductory courses: – students likely to have some experience– students need to see some OOP language– non-standard students check out “CS”


Conclusion

• teach Scheme for the first semester

• teach an OOP language for second

• teaches students: – about classes of values– rigorous program development – interests non-standard students


My Ideal Scenario

• TeachScheme!: for speedy start

• (O)CAML: for types (and classes)

• Haskell: for reasoning about effects and lazy data

• Java/C#: for classes and “real world”

• Felleisen

• Harper

• Hudak

• Steele


The End


Credits

• Findler• Flanagan• Flatt• Krishnamurthi

• Cartwright• Clements• Friedman• Steckler

5 october 2001ifip wg 2.31 preparation start drscheme set language level to beginner open in...

Documents

ifip wg

programming language

context slide

texas slide

moment slide

inputoutput slide

programming environment

program scheme