Protection in programming languages
Communications of the ACM
Report on the algorithmic language ALGOL 68
Report on the algorithmic language ALGOL 68
Issues in the design of object-oriented database programming languages
OOPSLA '87 Conference proceedings on Object-oriented programming systems, languages and applications
Abstract types have existential type
ACM Transactions on Programming Languages and Systems (TOPLAS)
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
On Ada packages, types and task types
ACM SIGAda Ada Letters
HOPL-II The second ACM SIGPLAN conference on History of programming languages
LCLint: a tool for using specifications to check code
SIGSOFT '94 Proceedings of the 2nd ACM SIGSOFT symposium on Foundations of software engineering
Abstract types have existential types
POPL '85 Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Proving Properties of Complex Data Structures
Journal of the ACM (JACM)
A Statement-Oriented Approach to Data Abstraction
ACM Transactions on Programming Languages and Systems (TOPLAS)
Data Type Specification: Parameterization and the Power of Specification Techniques
ACM Transactions on Programming Languages and Systems (TOPLAS)
Some ideas on data types in high-level languages
Communications of the ACM
Semantic evaluation from left to right
Communications of the ACM
A mathematical approach to language design
POPL '75 Proceedings of the 2nd ACM SIGACT-SIGPLAN symposium on Principles of programming languages
POPL '75 Proceedings of the 2nd ACM SIGACT-SIGPLAN symposium on Principles of programming languages
POPL '83 Proceedings of the 10th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Data types, parameters and type checking
POPL '80 Proceedings of the 7th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Formal software engineering for computational modelling
Nordic Journal of Computing
Algebraic specifications: some old history and new thoughts
Nordic Journal of Computing
LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
Architectural implications of abstract data type implementation
ISCA '79 Proceedings of the 6th annual symposium on Computer architecture
Data type specification: Parameterization and the power of specification techniques
STOC '78 Proceedings of the tenth annual ACM symposium on Theory of computing
FP with data abstraction and strong typing
FPCA '81 Proceedings of the 1981 conference on Functional programming languages and computer architecture
Data abstraction from a programming language viewpoint
Proceedings of the 1980 workshop on Data abstraction, databases and conceptual modeling
The use of abstract data types to simplify program modifications
Proceedings of the 1976 conference on Data : Abstraction, definition and structure
Abstract data types in the Model programming language
Proceedings of the 1976 conference on Data : Abstraction, definition and structure
A data type encapsulation scheme utilizing base language operators
Proceedings of the 1976 conference on Data : Abstraction, definition and structure
Towards an engineering approach to software design
ICSE '76 Proceedings of the 2nd international conference on Software engineering
Abstract data types, then and now
Software pioneers
Abstract data types and the development of data structures
Software pioneers
Simplifying ADA by removing limitations
ACM SIGPLAN Notices
Limits of the "algebraic" specification of abstract data types
ACM SIGPLAN Notices
A bisimulation for dynamic sealing
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Issues in programming language design: an overview
ACM SIGPLAN Notices - Special issue on programming language design
Abstraction in the Intel iAPX-432 prototype systems implementation language
ACM SIGPLAN Notices
A bisimulation for type abstraction and recursion
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
History of programming languages---II
ACM SIGSAM Bulletin
A bisimulation for dynamic sealing
Theoretical Computer Science
Case study on algebraic software methodologies for scientific computing
Scientific Programming
A bisimulation for type abstraction and recursion
Journal of the ACM (JACM)
Capability Based Tagged Architectures
IEEE Transactions on Computers
Issues in programming language design: an overview
AFIPS '75 Proceedings of the May 19-22, 1975, national computer conference and exposition
Institutions, property-aware programming and testing
LCSD '07 Proceedings of the 2007 Symposium on Library-Centric Software Design
Proceedings for the 1st workshop on Script to Program Evolution
Objects and values: the basis of a storage model for procedural languages
IBM Journal of Research and Development
Web applications: spaghetti code for the 21st century
Web applications: spaghetti code for the 21st century
Parametric polymorphism through run-time sealing or, theorems for low, low prices!
ESOP'08/ETAPS'08 Proceedings of the Theory and practice of software, 17th European conference on Programming languages and systems
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Gradual typing for first-class classes
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Hi-index | 0.04 |
The title is not a statement of fact, of course, but an opinion about how language designers should think about types. There has been a natural tendency to look to mathematics for a consistent, precise notion of what types are. The point of view there is extensional: a type is a subset of the universe of values. While this approach may have served its purpose quite adequately in mathematics, defining programming language types in this way ignores some vital ideas. Some interesting developments following the extensional approach are the ALGOL-68 type system [vW], Scott's theory [S], and Reynolds' system [R]. While each of these lend valuable insight to programming languages, I feel they miss an important aspect of types.Rather than worry about what types are I shall focus on the role of type checking. Type checking seems to serve two distinct purposes: authentication and secrecy. Both are useful when a programmer undertakes to implement a class of abstract objects to be used by many other programmers. He usually proceeds by choosing a representation for the objects in terms of other objects and then writes the required operations to manipulate them.