I. Discussion about Paul Graham's essay "Beating the Averages" What was that article about? A. main claim What was the main claim made in the article? B. testability ------------------------------------------ SCIENTIFIC HYPOTHESIS Popper: a hypothesis is scientific only if it is falsifiable What about: "Algol 60 is the best language that ever has or ever will be invented." "C++ is one of the best languages for writing embedded software." "Static type checking reduces errors by 30%." "Static type checking completely eliminates type errors." ------------------------------------------ How could we state the paper's hypothesis so that it's scientific? C. experiments What kind of experiment could we do to test that? II. goals and process for designing a language ("Dorothy") A. goals --------------------------------------------------------- GOALS support multiple programming models: - minimal features to allow each model to be expressed simplicity: - minimality - regularity - syntax that is easy to parse --------------------------------------------------------- B. process C. parts of a language --------------------------------------------------------- PARTS OF A LANGUAGE means of computation = primitive data + operations means of combination means of abstraction --------------------------------------------------------- III. data or means of computation A. plan 1. brainstorming What should be the types in the language? How do we know whether we have enough types? 2. condensation How does simplicity affect the list of types? ------------------------------------------ SIMULATION, GENERALITY def: A type T can simulate a type U if using T one can get the same behavior as U. Behavior includes: functionality (inputs, outputs) size (space used) time (complexity of running ops) ------------------------------------------ How do we know whether we have too many types? What types should be built-in? 3. type checking Should there be a static type system, or should there be run-time type checking? ------------------------------------------ TYPE CHECKING AND TYPE ERRORS term: type error def: *dynamic type checking* means type errors are detected (in general) def: *static type checking* means type errors are detected ------------------------------------------ Which is better for users? Which is more flexible? Which is simpliest to implement? B. operations What literals, constructors, and observers are needed? Are any special forms (e.g., &&, || in Java) needed? C. terminology --------------------------------------------------------- TERMINOLOGY special form closure (as in algebraic closure) --------------------------------------------------------- IV. means of combination syntax A. syntax of expressions What should the syntax be for expressions? How should we make literals/symbols? B. commands and combinations of commands (statements) What commands do we need? V. means of abstraction A. naming How should we name expressions and procedures? Do we want to have local declarations within expressions? B. parameterization and function declarations How should we declare parameters for procedures? Can we unify the two kinds of declarations? C. results from our discussion