David Evans CS655: Programming Languages University of Virginia Computer Science Lecture 14: Types of Types “It would appear that we have reached the limits of what it is possible to achieve with computer technology, although one should be careful with such statements, as they tend to sound pretty silly in five years.” John Von Neumann, 1949

6 March 2001CS 655: Lecture 142 Menu Latent Types, Dynamic Checking Manifest Types, Dynamic Checking Project Kickoff Manifest Types, Static Checking

6 March 2001CS 655: Lecture 143 Types integers in [0, …) Strings Beatle’s Song Titles pointers that points to integer that is prime number Colors secret information pointers that points to pointer that points to storage shared by some other pointer programs that halt Type is any set of values After Spring Break, we will see a different definition...

6 March 2001CS 655: Lecture 144 Why have types? Overloading operators + vs. FADD – compiler needs types to figure out what “+” means Detecting program errors –Better to notice error than report incorrect result Make programs easier to read, understand and maintain –Better than comments if they are checked and can be trusted Security –Can use types to constrain the behavior of programs (we’ll see Proof-Carrying Code later…)

6 March 2001CS 655: Lecture 145 Taxonomy Latent vs. Manifest –Are types visible in the program text? Checked statically vs. checked dynamically –Do you have to run the program to know if it has type errors? Checked weakly vs. strongly –How strict are the rules for using types? –Meaningless (just matter of degree) All combinations are (theoretically) possible –Language that is manifest + static + “weak”? –Language that is latent + dynamic + “strong”?

6 March 2001CS 655: Lecture 146 Labrador: BARK with Latent Types Instruction ::= STORE Loc Literal | HALT | ERROR (Same as BARK) | ADD Loc 1 Loc 2 Loc 1 gets the value of Loc 1 + Loc 2. Loc 1 and Loc 2 must be the same type, result has same type. | MUL Loc 1 Loc 2 Loc 1 gets the value of Loc 1 * Loc 2. Loc 1 and Loc 2 must be the same type. | IF Loc 1 THEN Loc 1 If value in Loc 1 is non-zero, jump to instruction corresponding to value in Loc 2. Loc 1 and Loc 2 must contain integers. Literal ::= IntLiteral | RealLiteral IntLiteral ::= [ - ] ? [ ][ ]*Has type integer. RealLiteral ::= [-] ? [ ][ ]*.[ ]*Has type real. As companions Labradors are kindly, patient,intelligent and always keen to please. They make perfect family dogs being especially good with children. Walter & Shackles Guide to Dogs

6 March 2001CS 655: Lecture 147 Labrador Program [0] STORE R [1] STORE R1 4 [2] MUL R1 R1 [3] MUL R0 R1.

6 March 2001CS 655: Lecture 148 Operational Semantics: ADD Instructions[PC] = ADD Loc 1 Loc 2  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc 1 RegisterFile[Loc 1 ] + RegisterFile[Loc 2 ] BARK rule: What does this mean?

6 March 2001CS 655: Lecture 149 Typed Register File C = Instructions x PC x RegisterFile RegisterFile[i] = for all integers i type = integer | real value = an integer if type if integer, a real if type is real Assume functions typeof(RegisterFile[i]), valueof(RegisterFile[i])

6 March 2001CS 655: Lecture 1410 Operational Semantics: ADD integer Instructions[PC] = ADD Loc 1 Loc 2,  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc 1 <integer, valueof(RegisterFile[Loc 1 ]) + integer valueof(RegisterFile[Loc 2 ])> typeof(RegisterFile[Loc 1 ]) = integer, typeof(RegisterFile[Loc 2 ]) = integer

6 March 2001CS 655: Lecture 1411 Operational Semantics: ADD real Instructions[PC] = ADD Loc 1 Loc 2, typeof(RegisterFile[Loc 1 ]) = real, typeof(RegisterFile[Loc 2 ]) = real  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc 1 <real, valueof(RegisterFile[Loc 1 ]) + real valueof(RegisterFile[Loc 2 ])>

6 March 2001CS 655: Lecture 1412 Strong vs. Weak Typing What do we have? –Latent, dynamic, “strongly” typed language To get: latent, dynamic, “weakly” typed language: –Allow ADD and MUL to work on mixed types, result is real, allow IF predicate to be real –Add transition rules for Instructions[PC] = ADD Loc 1 Loc 2, typeof(RegisterFile[Loc 1 ]) = real, typeof(RegisterFile[Loc 2 ]) = integer etc.

6 March 2001CS 655: Lecture 1413 Manifest Types Often, however, explicit (manifest) types make programs easier for compilers to read, not easier for humans to read; and explicit (manifest) types are generally cumbersome for the program writer as well. Implicitly (latently) typed programming languages thus have clear advantages in terms of readability and writability. Turbak & Gifford

6 March 2001CS 655: Lecture 1414 Mastiff: BARK with Manifest Types Program ::= Declaration* Instruction* Declaration ::= TYPE Loc INTEGER Loc will hold integral values. | TYPE Loc REAL Loc will hold real values. Instruction ::= STORE Loc Literal Loc gets the value of Literal. Loc must have been declared with the same type as Literal. … (same as Labrador) Mastiff: An excellent guard dog, yet gentle and affectionate to its family. Walter & Shackles Guide to Dogs

6 March 2001CS 655: Lecture 1415 Mastiff Program [D0]TYPE R0 REAL [D1]TYPE R1 INTEGER [0] STORE R [1] STORE R1 4 [2] MUL R1 R1 [3] MUL R0 R1

6 March 2001CS 655: Lecture 1416 Input Function: I : Program  C C = Instructions x PC x RegisterFile where Instructions = same as before, PC = 0 RegisterFile[n] = if TYPE Rn INTEGER is in Declarations RegisterFile[n] = if TYPE Rn REAL is in Declarations RegisterFile[n] = for all other integers n RegisterFile[n] = if (TYPE Rn INTEGER and TYPE Rn REAL are in Declarations)

6 March 2001CS 655: Lecture 1417 STORE Loc IntLiteral Instructions[PC] = STORE Loc IntLiteral, typeof(RegisterFile[Loc]) = integer  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc

6 March 2001CS 655: Lecture 1418 Is Dynamic Type Checking Useful?

6 March 2001CS 655: Lecture 1419 Projects Ideal Project Should: 1.Contribute to your thesis research work 2.Lead to a conference paper 3.Involve something interesting related to programming languages 4.Not take up all of your time for the rest of the semester Not all projects will be ideal. #1 is beneficial; #2 is optimistic; #3 is required; #4 is optional.

6 March 2001CS 655: Lecture 1420 Finding a Project Topic Think about how your research relates to programming languages: –Are there things that you describe in an ad hoc way today, that could be better understood if they were described more precisely? –Are the places where new abstractions (or removing old ones) would help? Send me an before March 19 describing your idea

6 March 2001CS 655: Lecture 1421 Example (Haiyong) Doing research on packet classification, performance is crucial Lots of tradeoffs between how you define your packet classifier and how well it performs, some attempts to define high- level languages for packet classifiers, but they are inflexible or inefficient Project topic: –Design language for defining packet filters that is flexible and extensible, but performs well.

6 March 2001CS 655: Lecture 1422 If you really can’t find a project related to your research Try harder You can: –Partner with someone else doing a project related to their research –Do a project on something else (possibly with other classmates). I have a few ideas.

6 March 2001CS 655: Lecture 1423 Course Project Calendar Sunday, 18 Mar (midnight): Send me about your project idea Week of 19 Mar - 23 Mar: Project meetings 26 Mar: Project proposal 10 Apr: Preliminary project report 24 Apr and 26 Apr: Presentations Tuesday, 1 May: Final report due

6 March 2001CS 655: Lecture 1424 Project Mantras Choose an ambitious topic, but be realistic about what you can accomplish in 7 weeks –Try to find a topic you will be interested in working on after the class is over to turn into conference paper Keep me informed on how your project is going and if you run into any problems. Don’t wait until due dates. Focus on design and understanding – only build things when there is a clear motivation to solve a problem or conducting an experiment.

6 March 2001CS 655: Lecture 1425 Project Questions Next: static semantics

6 March 2001CS 655: Lecture 1426 Static Semantics Static checking = at compile-time –Dynamic checking = at run (simulate)-time Know a whole program is type-correct without running it Can make claims about all possible executions Drawbacks: –May limit expressiveness of types (not everything can be checked statically) –Some type-correct programs may not pass static checking

6 March 2001CS 655: Lecture 1427 Premise;...; Premise Conclusion Conclusions are type judgments: A E : T Read: A proves E has type T. Use type okay to mean it type-checks, but has no type. Type environment: A Type bindings: [I 1 :T 1,..., I n :T n ] I n (Loc) has type T n Typing Rules

6 March 2001CS 655: Lecture 1428 Mastiff Typing Rules A IntLiteral : integer[int-literal] RealLiteral : real[real-literal] A contains [Loc:T] Loc : T[location] true

6 March 2001CS 655: Lecture 1429 Typing ADD A Loc 1 : integer, A Loc2 2 : integer A ADD Loc 1 Loc 2 : okay [add-integers] A Loc 1 : real, A Loc2 2 : real A ADD Loc 1 Loc 2 : okay [add-reals]

6 March 2001CS 655: Lecture 1430 Typing MUL A Loc 1 : integer, A Loc2 2 : integer A MUL Loc 1 Loc 2 : okay [mul-integers] A Loc 1 : real, A Loc 2 : integer A MUL Loc 1 Loc 2 : okay [mul-weak]

6 March 2001CS 655: Lecture 1431 Typing IF A Loc 1 : integer, A Loc 2 : integer A IF Loc 1 THEN Loc 2 : okay [if] A Loc 1 : real, A Loc 2 : integer A IF Loc 1 THEN Loc 2 : okay [if-weak]

6 March 2001CS 655: Lecture 1432 Type Checking Statement is well-typed if and only if it has a provable type judgment: –Construct a proof tree, where the root is the type judgment for this statement, and leaves are the axioms Declarations provide the axioms: Declarations = TYPE Loc i0 T i0 ; TYPE Loc i1 T i1,...  A = [Loc i0 : T i0, Loc i1 : T i1,... ]

6 March 2001CS 655: Lecture 1433 Type Checking Example Check instruction 3: MUL R0 R1 [D0]TYPE R0 REAL [D1]TYPE R1 INTEGER [0] STORE R [1] STORE R1 4 [2] MUL R1 R1 [3] MUL R0 R1 A R0 : real, A R1 : integer A MUL R0 R1 : okay [mul-weak] A contains [ R0 : real] R0 : real same for R1 : integer A = [ R0 : real; R1 : integer] from Declarations

6 March 2001CS 655: Lecture 1434 Summary Statically Checked Dynamically Checked Manifest TypesMastiff-SMastiff-D Latent TypesLabrador CLU, Pascal ML Scheme, Smalltalk Java (casts)

6 March 2001CS 655: Lecture 1435 Charge Think about project ideas –Spend at least 1½ hours on Thursday just thinking (not reading, not near a computer) Lots more on types to come... After Spring Break: –Data Abstraction CLU: language designed to support methodology based on data abstraction Reasoning (informally) about data abstractions –Object-Oriented Languages Later: –How to do static checking with latent types (type reconstruction, type inference) –How to use types for security