Concepts of Programming Languages

Chapter 1: Preliminaries

• • 1.1 Reasons for Studying Concepts of Programming Languages
• • 1.2 Programming Domains
• • 1.3 Language Evaluation Criteria
• • 1.4 Influences on Language Design
• • 1.5 Language Categories
• • 1.6 Language Design Trade-Offs
• • 1.7 Implementation Methods
• • 1.8 Programming Environments

Chapter 2: Evolution of the Major Programming Languages

• • 2.1 Zuse’s Plankalkül
• • 2.2 Pseudocodes
• • 2.3 The IBM 704 and Fortran
• • 2.4 Functional Programming: Lisp
• • 2.5 The First Step Toward Sophistication: ALGOL 60
• • 2.6 Computerizing Business Records: COBOL
• • 2.7 The Beginnings of Timesharing: Basic
• • 2.8 Everything for Everybody: PL/I
• • 2.9 Two Early Dynamic Languages: APL and SNOBOL
• • 2.10 The Beginnings of Data Abstraction: SIMULA 67
• • 2.11 Orthogonal Design: ALGOL 68
• • 2.12 Some Early Descendants of the ALGOLs
• • 2.13 Programming Based on Logic: Prolog
• • 2.14 History’s Largest Design Effort: Ada
• • 2.15 Object-Oriented Programming: Smalltalk
• • 2.16 Combining Imperative and Object-Oriented Features: C++
• • 2.17 An Imperative-Based Object-Oriented Language: Java
• • 2.18 Scripting Languages
• • 2.19 The Flagship .NET Language: C#
• • 2.20 Markup-Programming Hybrid Languages

Chapter 3: Describing Syntax and Semantics

• • 3.1 Introduction
• • 3.2 The General Problem of Describing Syntax
• • 3.3 Formal Methods of Describing Syntax
• • 3.4 Attribute Grammars
• • 3.5 Describing the Meanings of Programs: Dynamic Semantics

Chapter 4: Lexical and Syntax Analysis

• • 4.1 Introduction
• • 4.2 Lexical Analysis
• • 4.3 The Parsing Problem
• • 4.4 Recursive-Descent Parsing
• • 4.5 Bottom-Up Parsing

Chapter 5: Names, Bindings, and Scopes

• • 5.1 Introduction
• • 5.2 Names
• • 5.3 Variables
• • 5.4 The Concept of Binding
• • 5.5 Scope
• • 5.6 Scope and Lifetime
• • 5.7 Referencing Environments
• • 5.8 Named Constants

Chapter 6: Data Types

• • 6.1 Introduction
• • 6.2 Primitive Data Types
• • 6.3 Character String Types
• • 6.4 Enumeration Types
• • 6.5 Array Types
• • 6.6 Associative Arrays
• • 6.7 Record Types
• • 6.8 Tuple Types
• • 6.9 List Types
• • 6.10 Union Types
• • 6.11 Pointer and Reference Types
• • 6.12 Optional Types
• • 6.13 Type Checking
• • 6.14 Strong Typing
• • 6.15 Type Equivalence
• • 6.16 Theory and Data Types

Chapter 7: Expressions and Assignment Statements

• • 7.1 Introduction
• • 7.2 Arithmetic Expressions
• • 7.3 Overloaded Operators
• • 7.4 Type Conversions
• • 7.5 Relational and Boolean Expressions
• • 7.6 Short-Circuit Evaluation
• • 7.7 Assignment Statements
• • 7.8 Mixed-Mode Assignment

Chapter 8: Statement-Level Control Structures

• • 8.1 Introduction
• • 8.2 Selection Statements
• • 8.3 Iterative Statements
• • 8.4 Unconditional Branching
• • 8.5 Guarded Commands
• • 8.6 Conclusions

Chapter 9: Subprograms

• • 9.1 Introduction
• • 9.2 Fundamentals of Subprograms
• • 9.3 Design Issues for Subprograms
• • 9.4 Local Referencing Environments
• • 9.5 Parameter-Passing Methods
• • 9.6 Parameters That Are Subprograms
• • 9.7 Calling Subprograms Indirectly
• • 9.8 Design Issues for Functions
• • 9.9 Overloaded Subprograms
• • 9.10 Generic Subprograms
• • 9.11 User-Defined Overloaded Operators
• • 9.12 Closures
• • 9.13 Coroutines

Chapter 10: Implementing Subprograms

• • 10.1 The General Semantics of Calls and Returns
• • 10.2 Implementing “Simple” Subprograms
• • 10.3 Implementing Subprograms with Stack-Dynamic Local Variables
• • 10.4 Nested Subprograms
• • 10.5 Blocks
• • 10.6 Implementing Dynamic Scoping

Chapter 11: Abstract Data Types and Encapsulation Constructs

• • 11.1 The Concept of Abstraction
• • 11.2 Introduction to Data Abstraction
• • 11.3 Design Issues for Abstract Data Types
• • 11.4 Language Examples
• • 11.5 Parameterized Abstract Data Types
• • 11.6 Encapsulation Constructs
• • 11.7 Naming Encapsulations

Chapter 12: Support for Object-Oriented Programming

• • 12.1 Introduction
• • 12.2 Object-Oriented Programming
• • 12.3 Design Issues for Object-Oriented Languages
• • 12.4 Support for Object-Oriented Programming in Specific Languages
• • 12.5 Implementation of Object-Oriented Constructs
• • 12.6 Reflection

Chapter 13: Concurrency

• • 13.1 Introduction
• • 13.2 Introduction to Subprogram-Level Concurrency
• • 13.3 Semaphores
• • 13.4 Monitors
• • 13.5 Message Passing
• • 13.6 Ada Support for Concurrency
• • 13.7 Java Threads
• • 13.8 C# Threads
• • 13.9 Concurrency in Functional Languages
• • 13.10 Statement-Level Concurrency

Chapter 14: Exception Handling and Event Handling

• • 14.1 Introduction to Exception Handling
• • 14.2 Exception Handling in C++
• • 14.3 Exception Handling in Java
• • 14.4 Exception Handling in Python and Ruby
• • 14.5 Introduction to Event Handling
• • 14.6 Event Handling with Java
• • 14.7 Event Handling in C#

Chapter 15: Functional Programming Languages

• • 15.1 Introduction
• • 15.2 Mathematical Functions
• • 15.3 Fundamentals of Functional Programming Languages
• • 15.4 The First Functional Programming Language: Lisp
• • 15.5 An Introduction to Scheme
• • 15.6 Common Lisp
• • 15.7 ML
• • 15.8 Haskell
• • 15.9 F#
• • 15.10 Support for Functional Programming in Primarily Imperative Languages
• • 15.11 A Comparison of Functional and Imperative Languages

Chapter 16: Logic Programming Languages

• • 16.1 Introduction
• • 16.2 A Brief Introduction to Predicate Calculus
• • 16.3 Predicate Calculus and Proving Theorems
• • 16.4 An Overview of Logic Programming
• • 16.5 The Origins of Prolog
• • 16.6 The Basic Elements of Prolog
• • 16.7 Deficiencies of Prolog
• • 16.8 Applications of Logic Programming