To access the contents, click the chapter and section titles.

HPL: Vol. I Object-Oriented Programming Languages
(Imprint: Macmillan Technical Publishing)
(Publisher: Macmillan Computer Publishing)
Author: Peter Salus
ISBN: 1578700086


Foreword to This Volume: Object-Oriented Programming Languages
About the Authors

Part I—Object-Oriented Programming
Chapter 1—Object-Oriented Programming
1.1. Object-Oriented Programming: A Revolutionary Approach
1.1.1. Agents and Messages
1.1.2. Responsibilities and Information Hiding
1.1.4. Inheritance
1.1.5. Method Binding and Overriding
1.1.6. Polymorphism
1.1.7. Object-Oriented Computer Programming
1.1.8. Summary of Object-Oriented Concepts
1.2. OOP: An Evolutionary Idea
1.3. Combining Revolution and Evolution
1.4. References
Chapter 2—Applying Design Patterns and Frameworks to Develop Object-Oriented Communication Software
2.1. Understanding Object-Oriented Communication Software
2.2. Applying Patterns and Frameworks to Communication Software
2.2.1. Common Pitfalls of Developing Communication Software
2.2.2. Solutions in Patterns and Frameworks
2.3. Understanding ACE
2.3.1. The Structure of ACE
2.4. Developing High-Performance Web Servers with Patterns and Framework Components
2.4.1. An Overview of a Web System
2.4.2. An Overview of an OO Web Server Communication Software Architecture
2.4.3. Design Patterns for Web Server Communication Software
2.4.4. Implementing Web Server Concurrency Models with ACE
2.5. Summary
2.6. References

Part II—Smalltalk
Chapter 3—The Community of Smalltalk
3.1. The Smalltalk Vision
3.2. Smalltalk-71: First Efforts
3.3. Smalltalk-72: Inventing Personal Workstations
3.3.1. Smalltalk-74: FastTalk
3.4. Smalltalk-76: Contributing to Educational Technology
3.4.1. Smalltalk: A Programming Language of Educational Interest?
3.4.2. Smalltalk-76: The Language Definition
3.4.3. Browsers, Inspectors, and Debuggers
3.4.4. Using Smalltalk-76: Some PARC Folklore
3.4.5. Smalltalk-78: Portability Matters
3.4.6. 1979: Steve Jobs, Sun, and Standard Microprocessors
3.5. Smalltalk-80: Creating the Smalltalk Community
3.5.1. Smalltalk-80: The Language and Its Implementation
3.5.2. Composition Architectures
3.5.3. First Licenses
3.5.4. The CIA Analyst and Joshua
3.5.5. The Commercialization Experience
3.6. Acknowledgments
3.7. References
Chapter 4—Programming with Smalltalk
4.1. Objects
4.1.1. Objects Referenced as Literals
4.1.2. Objects Referenced as Variables
4.2. Behavior and Messages
4.2.1. Unary Messages
4.2.2. Binary Messages
4.2.3. Keyword Messages
4.2.4. Polymorphism with Identical Messages
4.3. Relationships Among Classes
4.3.1. Instance Variables
4.3.2. Method Definition
4.3.3. Inheritance Among Classes
4.3.4. Subclasses and Inheritance
4.3.5. Class Definitions
4.4. Control Structures
4.4.1. Conditional Execution
4.4.2. Iterative Execution
4.4.3. Combined Conditional and Iterative Execution
4.5. Computed Message Selectors
4.6. Exception Handling
4.6.1. Exception Handlers
4.6.2. Exception Resumability
4.6.3. Methods of Exiting a Handler Block
4.7. Class Libraries and Protocols
4.7.1. Protocols for Common Objects
4.7.2. Numeric Protocols
4.7.3. Collection Protocols
4.8. Smalltalk Program Structure
4.9. Source Material
Chapter 5—Smalltalk: A Developer’s Perspective
5.1. The History of Smalltalk
5.1.1. Early Smalltalk Commercialization
5.1.2. Current Smalltalk Commercialization
5.2. Smalltalk Features
5.2.1. Core Features
5.2.2. Class Library Features
5.3. The Smalltalk Language
5.3.1. One-Page Syntax
5.4. Some Simple Smalltalk Code
5.4.1. Blocks
5.4.2. ANSI Standard Smalltalk
5.5. The Smalltalk Development Environment
5.5.1. Browsers and Team Development Tools
5.5.2. Smalltalk Development Tools
5.6. Advantages and Disadvantages to Smalltalk
5.7. The Smalltalk Culture
5.7.1. Frameworks and Patterns
5.7.2. Object Technology Centers
5.7.3. The Smalltalk Development Lifecycle
5.7.4. The Vendors
5.7.5. Freeware and Shareware
5.8. Projects That Use Smalltalk
5.8.1. Smalltalk as a Web Server
5.8.2. Trading in Smalltalk
5.8.3. Banking in Smalltalk
5.8.4. Insurance and Smalltalk
5.8.5. Telecommunications and Smalltalk
5.8.6. Manufacturing, Utility, Pharmaceuticals, and Transportation with Smalltalk
5.8.7. The Government and Smalltalk
5.9. Conclusion
5.10. Smalltalk Places of Interest
5.11. References

Part III—C++
Chapter 6—A History of C++
6.1. Introduction to C++
6.2. C with Classes: 1979-1983
6.2.1. Prehistory of C++
6.2.2. The Birth of C with Classes
6.2.3. C with Classes Feature Overview
6.2.4. C with Classes Feature Details
6.2.5. The C with Classes Work Environment
6.3. From C with Classes to C++: 1982-1985
6.3.1. Aims
6.3.2. Cfront
6.3.3. Language Feature Details
6.3.4. C++’s Relationship to Classic C
6.3.5. Tools for Language Design
6.3.6. The C++ Programming Language (First Edition)
6.3.7. The “What Is?” Paper
6.4. C++ Release 2.0: 1985-1988
6.4.1. C++ 2.0 Feature Overview
6.4.2. Multiple Inheritance
6.4.3. Abstract Classes
6.5. Standardization: 1988-1998
6.5.1. The Annotated Reference Manual
6.5.2. ANSI and ISO
6.5.3. C++ 2.1 Feature Overview
6.5.4. Some Minor Features
6.5.5. Templates
6.5.6. Exception Handling
6.5.7. Namespaces
6.5.8. Runtime Type Identification
6.5.9. Rampant Featurism?
6.6. The Standard Library
6.6.1. Early Foundation Libraries
6.6.2. The Stream I/O Library
6.6.3. The Standard Template Library
6.6.4. Standard Library Facilities
6.7. The Explosion in Interest and Use: 1987-The Present
6.7.1. Conferences
6.7.2. Journals and Books
6.7.3. Compilers
6.7.4. Tools and Environments
6.7.5. Commercial Competition
6.8. Retrospective
6.8.1. Did C++ Succeed at What It Was Designed For?
6.8.2. Is C++ a Coherent Language?
6.8.3. What Was the Biggest Mistake?
6.8.4. Hopes for the Future
6.9. Acknowledgments
6.10. References
Chapter 7—A Detailed Introduction to C++
7.1. C++ Overview
7.1.1. A Multiparadigm Language
7.1.2. Elementary C++ Examples
7.1.3. Language Versus Library
7.2. C++ Fundamentals
7.2.1. Program Structure
7.2.2. Numbers and Arithmetic
7.2.3. Enumerated Types
7.2.4. Numeric Conversions
7.2.5. Operator Precedence
7.2.6. Pointers, References, and Arrays
7.2.7. String Literals
7.2.8. Functions
7.2.9. Statements
7.2.10. Namespaces
7.3. Data Abstraction
7.3.1. Structures and Classes
7.3.2. Member Functions
7.3.3. Protection
7.3.4. Special Member Functions
7.3.5. Pointers to Members
7.3.6. A Data Abstraction Example
7.4. Generic Programming
7.4.1. Template Functions
7.4.2. Template Classes
7.4.3. Generic Algorithms
7.5. Object-Oriented Programming
7.5.1. Inheritance
7.5.2. Dynamic Binding
7.5.3. An Extended Object-Oriented Programming Example
7.6. The Standard Library
7.6.1. Input/Output
7.6.2. Strings
7.6.3. Numerics
7.6.4. Containers
7.6.5. Iterators
7.6.6. Algorithms
7.6.7. Adaptors
7.7. Summary
7.8. Recommended Reading
7.9. References
7.10. Acknowledgments
Chapter 8—C++ Traps and Pitfalls
8.1. Why Programmers Get in Trouble
8.1.1. Two Sources of Pitfalls
8.1.2. The Relationship Between C++ and C
8.1.3. Synopsis
8.2. Syntactic Pitfalls
8.2.1. Lexical Pitfalls
8.2.2. Declarations and Specifiers
8.2.3. Where Does the const Go?
8.2.4. Constructor Initializers
8.2.5. Summary of Syntactic Pitfalls
8.3. Semantic Pitfalls
8.3.1. How Much Does const Promise?
8.3.2. Functions That Return References
8.3.3. Multidimensional Arrays and new Expressions
8.3.4. Implicit Base Class Conversions
8.3.5. Containers and Comparisons
8.3.6. Pointer Comparisons and Order Relations
8.3.7. Semantic Pitfalls Summary
8.4. Execution Pitfalls
8.4.1. Cheating on Array Bounds
8.4.2. Input/Output and Order of Evaluation
8.4.3. Dangling Pointers
8.4.4. References and Aliasing
8.5. Conclusion
8.6. Acknowledgments
8.7. Reference

Part IV—Eiffel
Chapter 9—Eiffel
9.1. Eiffel Overview
9.2. General Properties
9.3. The Software Process in Eiffel
9.3.1. Clusters and the Cluster Model
9.3.2. Seamlessness and Reversibility
9.3.3. Generalization and Reuse
9.3.4. Constant Availability
9.3.5. Compilation Technology
9.3.6. Quality and Functionality
9.4. Hello, World
9.5. The Static Picture: System Organization
9.5.1. Systems
9.5.2. Classes
9.5.3. Class Relations
9.5.4. The Global Inheritance Structure
9.5.5. Clusters
9.5.6. External Software
9.6. The Dynamic Structure: Execution Model
9.6.1. Objects, Fields, Values, and References
9.6.2. Features
9.6.3. A Simple Class
9.6.4. Creating and Initializing Objects
9.6.5. Entities
9.6.6. Calls
9.6.7. Infix and Prefix Notation
9.6.8. Type Declaration
9.6.9. Type Categories
9.6.10. Basic Operations
9.6.11. Deep Operations and Persistence
9.6.12. Memory Management
9.6.13. Information Hiding and the Call Rule
9.6.14. Execution Scenario
9.6.15. Abstraction
9.7. Genericity
9.8. Design by Contract, Assertions, and Exceptions
9.8.1. Design by Contract Basics
9.8.2. Expressing Assertions
9.8.3. Using Assertions for Built-in Reliability
9.8.4. Runtime Assertion Monitoring
9.8.5. The Short Form of a Class
9.8.6. Exception Handling
9.8.7. Other Applications of Design by Contract
9.9. The Inheritance Mechanism
9.9.1. Basic Inheritance Structure
9.9.2. Redefinition
9.9.3. Polymorphism
9.9.4. Dynamic Binding
9.9.5. Deferred Features and Classes
9.9.6. Applications of Deferred Classes
9.9.7. Structural Property Classes
9.9.8. Multiple Inheritance and Feature Renaming
9.9.9. Inheritance and Contracts
9.9.10. Joining and Uneffecting
9.9.11. Changing the Export Status
9.9.12. Flat and Flat-Short Forms
9.9.13. Repeated Inheritance and Selection
9.9.14. Constrained Genericity
9.9.15. Assignment Attempt
9.9.16. Covariance and Anchored Declarations
9.10. Other Important Mechanisms
9.10.1. once Routines and Shared Objects
9.10.2. Constant Attributes
9.10.3. Instructions
9.10.4. Lexical Conventions
9.11. Concurrency and Further Developments
9.11.1. SCOOP
9.11.2. Other Developments
9.12. Eiffel History
9.13. More Information on Eiffel
9.13.1. Documentation
9.13.2. Information Sources
9.13.3. Compiler Sources

Part V—Ada 95
Chapter 10—Ada 95 in Context
10.1. Introduction
10.2. Preliminaries
10.2.1. A Brief Historical Sketch of Ada 83
10.2.2. From Ada 83 to Ada 95
10.2.3. Validation, or “Just Which Language Does This Compiler Compile?”
10.3. Ada in Today’s World
10.3.1. Ada in Use
10.3.2. Education and Ada
10.3.3. Ada 95 Compiler Availability
10.4. Programming
10.4.1. Examples of Basic Structure and Syntax
10.4.2. Packages: The Ada Encapsulation Mechanism
10.4.3. Type Extension, Inheritance, and Polymorphism
10.4.4. Concurrent Programming
10.5. Bibliography
10.5.1. World Wide Web Resources on Ada
10.5.2. Books, Selected Articles, and Other Publications of Interest on Ada 95

Part VI—Modula-3
CHAPTER 11—The Modula-3 Programming Language
11.2. Introduction
11.2.2. Perspective
11.2.3. Features
11.3. Definitions
11.4. Types
11.4.1. Ordinal Types
11.4.2. Floating-Point Types
11.4.3. Arrays
11.4.4. Records
11.4.5. Packed Types
11.4.6. Sets
11.4.7. References
11.4.8. Procedures
11.4.9. Objects
11.4.10. Subtyping Rules
11.4.11. Predeclared Opaque Types
11.5. Statements
11.5.1. Assignment
11.5.2. Procedure Calls
11.5.3. EVAL
11.5.4. Block Statements
11.5.5. Sequential Composition
11.5.6. RAISE
11.5.7. TRY-EXCEPT
11.5.8. TRY-FINALLY
11.5.9. LOOP
11.5.10. EXIT
11.5.11. RETURN
11.5.12. IF
11.5.13. WHILE
11.5.14. REPEAT
11.5.15. WITH
11.5.16. FOR
11.5.17. CASE
11.5.18. TYPECASE
11.5.19. LOCK
11.5.20. INC and DEC
11.6. Declarations
11.6.1. Types
11.6.2. Constants
11.6.3. Variables
11.6.4. Procedures
11.6.5. Exceptions
11.6.6. Opaque Types
11.6.7. Revelations
11.6.8. Recursive Declarations
11.7. Modules and Interfaces
11.7.1. Import Statements
11.7.2. Interfaces
11.7.3. Modules
11.7.4. A Sample Module and Interface
11.7.5. Generics
11.7.6. Initialization
11.7.7. Safety
11.8. Expressions
11.8.1. Conventions for Describing Operations
11.8.2. Operation Syntax
11.8.3. Designators
11.8.4. Numeric Literals
11.8.5. Text and Character Literals
11.8.6. NIL
11.8.7. Function Application
11.8.8. Set, Array, and Record Constructors
11.8.9. NEW
11.8.10. Arithmetic Operations
11.8.11. Relations
11.8.12. Boolean Operations
11.8.13. Type Operations
11.8.14. Text Operations
11.8.15. Constant Expressions
11.9. Unsafe Operations
11.10. Required Interfaces
11.10.1. The Text Interface
11.10.2. The Thread Interface
11.10.3. The Word Interface
11.10.4. The Real, LongReal, and Extended Interfaces
11.10.5. The RealFloat, LongFloat, and ExtendedFloat Interfaces
11.10.6. The FloatMode Interface
11.11. Syntax
11.11.1. Keywords
11.11.2. Reserved Identifiers
11.11.3. Operators
11.11.4. Comments
11.11.5. Pragmas
11.11.6. Conventions for Syntax
11.11.7. Compilation Unit Productions
11.11.9. Statement Productions
11.11.9. Type Productions
11.11.10. Expression Productions
11.11.11. Miscellaneous Productions
11.11.12. Token Productions
11.12. Acknowledgments

Part VII—Java
Chapter 12—What Is Java?
Chapter 13—Working with Java
13.1. Getting Started
13.2. Variables
13.3. Comments in Code
13.4. Named Constants
13.4.1. Unicode Characters
13.5. Flow of Control
13.6. Classes and Objects
13.6.1 Creating Objects
13.6.2. Static or Class Fields
13.6.3. The Garbage Collector
13.7. Methods and Parameters
13.7.1. Invoking a Method
13.7.2. The this Reference
13.7.3. Static or Class Methods
13.8. Arrays
13.9. String Objects
13.10. Extending a Class
13.10.1. The Object Class
13.10.2. Invoking Methods from the Superclass
13.11. Interfaces
13.12. Exceptions
13.13. Packages
13.14. The Java Infrastructure
13.15. Other Topics Briefly Noted
Chapter 14—Programming in Java
14.1. Getting Started with Java
14.1.1. Why Is Java Interesting?
14.2. How Java Differs from C
14.2.1. Program Structure and Environment
14.2.2. The Name Space: Packages, Classes, and Members
14.2.3. Comments
14.2.4. No Preprocessor
14.2.5. Unicode and Character Escapes
14.2.6. Primitive Data Types
14.2.7. Reference Data Types
14.2.8. Objects
14.2.9. Arrays
14.2.10. Strings
14.2.11. Operators
14.2.12. Statements
14.2.13. Exceptions and Exception Handling
14.2.14. Miscellaneous Differences
14.3. Classes and Objects in Java
14.3.1. Introduction to Classes and Objects
14.3.2. Object Creation
14.3.3. Class Variables
14.3.4. Class Methods
14.3.5. Object Destruction
14.3.6. Subclasses and Inheritance
14.3.7. Overriding Methods
14.3.8. Data Hiding and Encapsulation
14.3.9. Abstract Classes and Interfaces
14.3.10. C++ Features Not Found in Java
14.3.11. Summary
14.4. What’s New in Java 1.1
14.4.1. Java 1.1 Package-by-Package
14.4.2. Inner Classes
14.4.3. The New AWT Event Model
14.4.4. Deprecated Features
14.4.5. Other AWT Improvements
14.4.6. Internationalization
14.4.7. Object Serialization
14.4.8. Reflection
14.4.9. Java Beans
14.4.10. Enterprise APIs: JDBC, RMI, and Security
14.4.11. Applet Changes
14.4.12. New JDK Utilities
Index