Programming Language Pragmatics - Info and Reading Options

"Programming Language Pragmatics" Table Of Contents:

• 1- Foundations
• 2- Introduction
• 3- The Art of Language Design
• 4- The Programming Language Spectrum
• 5- Why Study Programming Languages?
• 6- Compilation and Interpretation
• 7- Programming Environments
• 8- An Overview of Compilation
• 9- Lexical and Syntax Analysis
• 10- Semantic Analysis and Intermediate Code Generation
• 11- Target Code Generation
• 12- Code Improvement
• 13- Summary and Concluding Remarks
• 14- Exercises
• 15- Explorations
• 16- Bibliographic Notes
• 17- Programming Language Syntax
• 18- Specifying Syntax
• 19- Tokens and Regular Expressions
• 20- Context-Free Grammars
• 21- Derivations and Parse Trees
• 22- Scanning
• 23- Generating a Finite Automaton
• 24- Scanner Code
• 25- Table-Driven Scanning
• 26- Lexical Errors
• 27- Pragmas
• 28- Parsing
• 29- Recursive Descent
• 30- Table-Driven Top-Down Parsing
• 31- Bottom-Up Parsing
• 32- Syntax Errors
• 33- Theoretical Foundations
• 34- Finite Automata
• 35- Push-Down Automata
• 36- Grammar and Language Classes
• 37- Summary and Concluding Remarks
• 38- Exercises
• 39- Explorations
• 40- Bibliographic Notes
• 41- Names, Scopes, and Bindings
• 42- The Notion of Binding Time
• 43- Object Lifetime and Storage Management
• 44- Static Allocation
• 45- Stack-Based Allocation
• 46- Heap-Based Allocation
• 47- Garbage Collection
• 48- Scope Rules
• 49- Static Scoping
• 50- Nested Subroutines
• 51- Declaration Order
• 52- Modules
• 53- Module Types and Classes
• 54- Dynamic Scoping
• 55- Implementing Scope
• 56- Symbol Tables
• 57- Association Lists and Central Reference Tables
• 58- The Meaning of Names Within a Scope
• 59- Aliases
• 60- Overloading
• 61- Polymorphism and Related Concepts
• 62- The Binding of Referencing Environments
• 63- Subroutine Closures
• 64- First-Class Values and Unlimited Extent
• 65- Object Closures
• 66- Macro Expansion
• 67- Separate Compilation
• 68- Separate Compilation in C
• 69- Packages and Automatic Header Inference
• 70- Module Hierarchies
• 71- Summary and Concluding Remarks
• 72- Exercises
• 73- Explorations
• 74- Bibliographic Notes
• 75- Semantic Analysis
• 76- The Role of the Semantic Analyzer
• 77- Attribute Grammars
• 78- Evaluating Attributes
• 79- Action Routines
• 80- Space Management for Attributes
• 81- Bottom-Up Evaluation
• 82- Top-Down Evaluation
• 83- Decorating a Syntax Tree
• 84- Summary and Concluding Remarks
• 85- Exercises
• 86- Explorations
• 87- Bibliographic Notes
• 88- Target Machine Architecture
• 89- The Memory Hierarchy
• 90- Data Representation
• 91- Integer Arithmetic
• 92- Floating-Point Arithmetic
• 93- Instruction Set Architecture
• 94- Addressing Modes
• 95- Conditions and Branches
• 96- Architecture and Implementation
• 97- Microprogramming
• 98- Microprocessors
• 99- RISC
• 100- Multithreading and Multicore
• 101- Two Example Architectures: The x86 and MIPS
• 102- Compiling for Modern Processors
• 103- Keeping the Pipeline Full
• 104- Register Allocation
• 105- Summary and Concluding Remarks
• 106- Exercises
• 107- Explorations
• 108- Bibliographic Notes
• 109- Core Issues in Language Design
• 110- Control Flow
• 111- Expression Evaluation
• 112- Precedence and Associativity
• 113- Assignments
• 114- Initialization
• 115- Ordering Within Expressions
• 116- Short-Circuit Evaluation
• 117- Structured and Unstructured Flow
• 118- Structured Alternatives to goto
• 119- Continuations
• 120- Sequencing
• 121- Selection
• 122- Short-Circuited Conditions
• 123- Case/Switch Statements
• 124- Iteration
• 125- Enumeration-Controlled Loops
• 126- Combination Loops
• 127- Iterators
• 128- Generators in Icon
• 129- Logically Controlled Loops
• 130- Recursion
• 131- Iteration and Recursion
• 132- Applicative- and Normal-Order Evaluation
• 133- Nondeterminacy
• 134- Summary and Concluding Remarks
• 135- Exercises
• 136- Explorations
• 137- Bibliographic Notes
• 138- Data Types
• 139- Type Systems
• 140- Type Checking
• 141- Polymorphism
• 142- The Meaning of “Type”
• 143- Classification of Types
• 144- Orthogonality
• 145- Type Checking
• 146- Type Equivalence
• 147- Type Compatibility
• 148- Type Inference
• 149- The ML Type System
• 150- Records (Structures) and Variants (Unions)
• 151- Syntax and Operations
• 152- Memory Layout and Its Impact
• 153- With Statements
• 154- Variant Records (Unions)
• 155- Arrays
• 156- Syntax and Operations
• 157- Dimensions, Bounds, and Allocation
• 158- Memory Layout
• 159- Strings
• 160- Sets
• 161- Pointers and Recursive Types
• 162- Syntax and Operations
• 163- Dangling References
• 164- Garbage Collection
• 165- Lists
• 166- Files and Input/Output
• 167- Interactive I/O
• 168- File-Based I/O
• 169- Text I/O
• 170- Equality Testing and Assignment
• 171- Summary and Concluding Remarks
• 172- Exercises
• 173- Explorations
• 174- Bibliographic Notes
• 175- Subroutines and Control Abstraction
• 176- Review of Stack Layout
• 177- Calling Sequences
• 178- Displays
• 179- Case Studies: C on the MIPS; Pascal on the x86
• 180- Register Windows
• 181- In-Line Expansion
• 182- Parameter Passing
• 183- Parameter Modes
• 184- Call by Name
• 185- Special Purpose Parameters
• 186- Function Returns
• 187- Generic Subroutines and Modules
• 188- Implementation Options
• 189- Generic Parameter Constraints
• 190- Implicit Instantiation
• 191- Generics in C++, Java, and C#
• 192- Exception Handling
• 193- Defining Exceptions
• 194- Exception Propagation
• 195- Implementation of Exceptions
• 196- Coroutines
• 197- Stack Allocation
• 198- Transfer
• 199- Implementation of Iterators
• 200- Discrete Event Simulation
• 201- Events
• 202- Sequential Handlers
• 203- Thread-Based Handlers
• 204- Summary and Concluding Remarks
• 205- Exercises
• 206- Explorations
• 207- Bibliographic Notes
• 208- Data Abstraction and Object Orientation
• 209- Object-Oriented Programming
• 210- Encapsulation and Inheritance
• 211- Modules
• 212- Classes
• 213- Nesting (Inner Classes)
• 214- Type Extensions
• 215- Extending without Inheritance
• 216- Initialization and Finalization
• 217- Choosing a Constructor
• 218- References and Values
• 219- Execution Order
• 220- Garbage Collection
• 221- Dynamic Method Binding
• 222- Virtual and Nonvirtual Methods
• 223- Abstract Classes
• 224- Member Lookup
• 225- Polymorphism
• 226- Object Closures
• 227- Multiple Inheritance
• 228- Semantic Ambiguities
• 229- Replicated Inheritance
• 230- Shared Inheritance
• 231- Mix-In Inheritance
• 232- Object-Oriented Programming Revisited
• 233- The Object Model of Smalltalk
• 234- Summary and Concluding Remarks
• 235- Exercises
• 236- Explorations
• 237- Bibliographic Notes
• 238- Alternative Programming Models
• 239- Functional Languages
• 240- Historical Origins
• 241- Functional Programming Concepts
• 242- A Review/Overview of Scheme
• 243- Bindings
• 244- Lists and Numbers
• 245- Equality Testing and Searching
• 246- Control Flow and Assignment
• 247- Programs as Lists
• 248- Extended Example: DFA Simulation
• 249- Evaluation Order Revisited
• 250- Strictness and Lazy Evaluation
• 251- I/O: Streams and Monads
• 252- Higher-Order Functions
• 253- Theoretical Foundations
• 254- Lambda Calculus
• 255- Control Flow
• 256- Structures
• 257- Functional Programming in Perspective
• 258- Summary and Concluding Remarks
• 259- Exercises
• 260- Explorations
• 261- Bibliographic Notes
• 262- Logic Languages
• 263- Logic Programming Concepts
• 264- Prolog
• 265- Resolution and Unification
• 266- Lists
• 267- Arithmetic
• 268- Search/Execution Order
• 269- Extended Example: Tic-Tac-Toe
• 270- Imperative Control Flow
• 271- Database Manipulation
• 272- Theoretical Foundations
• 273- Clausal Form
• 274- Limitations
• 275- Skolemization
• 276- Logic Programming in Perspective
• 277- Parts of Logic Not Covered
• 278- Execution Order
• 279- Negation and the “Closed World” Assumption
• 280- Summary and Concluding Remarks
• 281- Exercises
• 282- Explorations
• 283- Bibliographic Notes
• 284- Concurrency
• 285- Background and Motivation
• 286- The Case for Multithreaded Programs
• 287- Multiprocessor Architecture
• 288- Concurrent Programming Fundamentals
• 289- Communication and Synchronization
• 290- Languages and Libraries
• 291- Thread Creation Syntax
• 292- Implementation of Threads
• 293- Implementing Synchronization
• 294- Busy-Wait Synchronization
• 295- Nonblocking Algorithms
• 296- Memory Consistency Models
• 297- Scheduler Implementation
• 298- Semaphores
• 299- Language-Level Mechanisms
• 300- Monitors
• 301- Conditional Critical Regions
• 302- Synchronization in Java
• 303- Transactional Memory
• 304- Implicit Synchronization
• 305- Message Passing
• 306- Naming Communication Partners
• 307- Sending
• 308- Receiving
• 309- Remote Procedure Call
• 310- Summary and Concluding Remarks
• 311- Exercises
• 312- Explorations
• 313- Bibliographic Notes
• 314- Scripting Languages
• 315- What Is a Scripting Language?
• 316- Common Characteristics
• 317- Problem Domains
• 318- Shell (Command) Languages
• 319- Text Processing and Report Generation
• 320- Mathematics and Statistics
• 321- “Glue” Languages and General Purpose Scripting
• 322- Extension Languages
• 323- Scripting the World Wide Web
• 324- CGI Scripts
• 325- Embedded Server-Side Scripts
• 326- Client-Side Scripts
• 327- Java Applets
• 328- XSLT
• 329- Innovative Features
• 330- Names and Scopes
• 331- String and Pattern Manipulation
• 332- Data Types
• 333- Object Orientation
• 334- Summary and Concluding Remarks
• 335- Exercises
• 336- Explorations
• 337- Bibliographic Notes
• 338- A Closer Look at Implementation
• 339- Building a Runnable Program
• 340- Back-End Compiler Structure
• 341- A Plausible Set of Phases
• 342- Phases and Passes
• 343- Intermediate Forms
• 344- Diana
• 345- The gcc IFs
• 346- Stack-Based Intermediate Forms
• 347- Code Generation
• 348- An Attribute Grammar Example
• 349- Register Allocation
• 350- Address Space Organization
• 351- Assembly
• 352- Emitting Instructions
• 353- Assigning Addresses to Names
• 354- Linking
• 355- Relocation and Name Resolution
• 356- Type Checking
• 357- Dynamic Linking
• 358- Position-Independent Code
• 359- Fully Dynamic (Lazy) Linking
• 360- Summary and Concluding Remarks
• 361- Exercises
• 362- Explorations
• 363- Bibliographic Notes
• 364- Run-time Program Management
• 365- Virtual Machines
• 366- The Java Virtual Machine
• 367- The Common Language Infrastructure
• 368- Late Binding of Machine Code
• 369- Just-in-Time and Dynamic Compilation
• 370- Binary Translation
• 371- Binary Rewriting
• 372- Mobile Code and Sandboxing
• 373- Inspection/Introspection
• 374- Reflection
• 375- Symbolic Debugging
• 376- Performance Analysis
• 377- Summary and Concluding Remarks
• 378- Exercises
• 379- Explorations
• 380- Bibliographic Notes
• 381- Code Improvement
• 382- Phases of Code Improvement
• 383- Peephole Optimization
• 384- Redundancy Elimination in Basic Blocks
• 385- A Running Example
• 386- Value Numbering
• 387- Global Redundancy and Data Flow Analysis
• 388- SSA Form and Global Value Numbering
• 389- Global Common Subexpression Elimination
• 390- Loop Improvement I
• 391- Loop Invariants
• 392- Induction Variables
• 393- Instruction Scheduling
• 394- Loop Improvement II
• 395- Loop Unrolling and Software Pipelining
• 396- Loop Reordering
• 397- Register Allocation
• 398- Summary and Concluding Remarks
• 399- Bibliographic Notes
• 400- Programming Languages Mentioned
• 401- Language Design and Language Implementation
• 402- Numbered Examples
• 403- Bibliography
• 404- Index

Read “Programming Language Pragmatics”:

Read “Programming Language Pragmatics” by choosing from the options below.