SOSP09: Keynote: Barbara Liskov, ACM Turing Award Lecture
Keynote: Barbara Liskov, ACM Turing Award Lecture
—————————
the Interdata 3:
- idea: first build a small machine (hw) them build a power machine on top of that (programs)
- I designed th instruction set and put semaphore in them
Software crisis:
- cheap machines and expensive programmers
- Dijkstra, The humble programmer, 1972
Programming methodology:
Dikstra: Go To Statement Considered Harmful, 1968
- Relation between static instructions and dynamic states
- The difficulty of debugging
- The need for structured programming: goto-less programming
Wirth: Program Development Stepwise Refinement, 1971
- Start from the top abstract level
- top-down process
Parna: Information Distribution Aspects of Design Methodology, 1971
Parnas: On the criteria to be used in decomposing systems into modules, 1972
- Modular programming
Liskov: A Design methodology for reliable software systems, 1972
- Break the entire system to partitions
- The states in each partition can be accessed by dedicated interfaces
- Similar in spirit to operating system design in which access to os data is limited
From Partitions to ADTs;
- Idea: connect partitions to data types
Extensible Languages:
- overreaction to a problem in programming languages
- syntactic & semantic extensibility
– syntactic: have new symbol for new concepts in program
– semantic: …
Dahl, Hoare: Hierachical Program Structures. Structured Programming, 1972
- Class and Sub-Classes
Morris: Protection in Programming Languages, 1973
- Importance of locality of data
- The encapsulation was expensive to enforce, though
Wulf and Shaw: Global Variable Considered Harmful, 1973
Liskov and Zilles: Programming with abstract data types
- A set of operations
- A set of objects
- operations are the only way to access the objects
- polymorphisms
- static type checking (we hoped)
- exception handling
From ADTs to CLU:
- The need for a programming language to enforce them
Goals:
- ease of use
- simplicity
- expressive power
- performance
Assumptions/Decisions:
- Heap-based with garbage collection!
- No block structure!
- Separate compilation
- Static type checking
- No concurrency
- No gotos
- no inheritance
CLU Mechanisms:
- Clusters: unlike OO, we considered operations for types not objects
- Polymorphisms: ???
- Exception Handling;
– Termination vs. Resumption
– How to specify handlers
- Iterators: it did not support nested iterators for the sake of efficiency in implementation
Type hierarchy:
At the time, inheritance was used both for implementation and type hierarchy
LSP: The Liskov Substitution principle
- objects of subtypes should behave like those of supertype if they are called via supertype methods
What next?
- modularity based on abstraction is the way thing are done
Modern Programming Languages:
- Are good!
- Serialization is not done well
- data types are changing over time, it is hard to program
The state of programming:
- The return of globals! 
- Persistent storage violates the rules: files are like global variables
Performance is not the most important issue
- vs. Semantics
- vs. Simplicity
Massively parallel machines (many-cores) are actually distributed systems
Tags: SOSP09