Programming Language Design Concepts - Watt, David A. (University of Glasgow)

. .

Auteur(s) : Watt, David A. (University of Glasgow)

Editeur : John Wiley & Sons

Langue : Anglais

Parution : 29/02/2004

Format : Moyen, de 350g à 1kg

Nombre de pages : 504.0

ISBN : 9780470853207

Résumé :
This book explains the concepts underlying programming languages, and demonstrates how these concepts are synthesized in the major paradigms: imperative, OO, concurrent, functional, logic and scripting.? It gives greatest prominence to the OO paradigm, and uses Java as the main exemplar language.

It includes numerous examples, case studies of several major programming languages, and numerous end-of-chapter exercises. Sample solutions to most of the exercises are provided at the book's companion Web site

...

Sommaire:
Preface.

PART I: INTRODUCTION.

1. Programming Languages.

1.1 Programming linguistics.

1.1.1 Concepts and paradigms.

1.1.2 Syntax, semantics, and pragmatics.

1.1.3 Language processors.

1.2 Historical development.

Summary.

Further reading.

Exercises.

PART II: BASIC CONCEPTS

2. Values and Types.

2.1 Types.

2.2 Primitive types.

2.2.1 Built-in primitive types.

2.2.2 Defined primitive types.

2.2.3 Discrete primitive types.

2.3 Composite types.

2.3.1 Cartesian products, structures, and records.

2.3.2 Mappings, arrays, and functions.

2.3.3 Disjoint unions, discriminated records, and objects.

2.4 Recursive types.

2.4.1 Lists.

2.4.2 Strings.

2.4.3 Recursive types in general.

2.5 Type systems.

2.5.1 Static vs dynamic typing.

2.5.2 Type equivalence.

2.5.3 The Type Completeness Principle.

2.6 Expressions.

2.6.1 Literals.

2. 6.2 Constructions.

2.6.3 Function calls.

2.6.4 Conditional expressions.

2.6.5 Iterative expressions.

2.6.6 Constant and variable accesses.

2.7 Implementation notes.

2.7.1 Representation of primitive types.

2.7.2 Representation of Cartesian products.

2.7.3 Representation of arrays.

2.7.4 Representation of disjoint unions.

2.7.5 Representation of recursive types.

Summary.

Further reading.

Exercises.

3. Variables and Storage.

3.1 Variables and storage.

3.2 Simple variables.

3.3 Composite variables.

3.3.1 Total vs selective update.

3.3.2 Static vs dynamic vs flexible arrays.

3.4 Copy semantics vs reference semantics.

3.5 Lifetime.

3.5.1 Global and local variables.

3.5.2 Heap variables.

3.5.3 Persistent variables.

3.6 Pointers.

3.6.1 Pointers and recursive types.

3.6.2 Dangling pointers.

3.7 Commands.

3.7.1 Skips.

3.7.2 Assignments.

3.7.3 Procedure calls.

3.7.4 Sequential commands.

3.7.5 Collateral commands.

3.7.6 Conditional commands.

3.7.7 Iterative commands.

3.8 Expressions with side effects.

3.8.1 Command expressions.

3.8.2 Expression-oriented languages.

3.9 Implementation notes

3.9.1 Storage for global and local variables.

3.9.2 Storage for heap variables.

Summary.

Further reading.

Exercises.

4. Bindings and Scope.

4.1 Bindings and environments.

4.2 Scope.

4.2.1 Block structure.

4.2.2 Scope and visibility.

4.2.3 Static vs dynamic scoping.

4.3 Declarations.

4.3.1 Type declarations.

4.3.2 Constant declarations.

4.3.3 Variable declarations.

4.3.4 Procedure definitions.

4.3.5 Collateral declarations.

4.3.6 Sequential declarations.

4.3.6 Recursive declarations.

4.3.8 Scopes of declarations.

4.4 Blocks.

4.4.1 Block commands.

4.4.2 Block expressions.

4.4.3 The Qualification Principle.

Summary.

Further reading.

Exercises.

5. Procedural Abstraction.

5.1 Function procedures and proper procedures.

5.1.1 Function procedures.

5.1.2 Proper procedures

5.1.3 The Abstraction Principle.

5.2 Parameters and arguments.

5.2.1 Copy parameter mechanisms.

5.2.2 Reference parameter mechanisms.

5.2.3 The Correspondence Principle.

5.3 Implementation notes

5.3.1 Implementation of procedure calls.

5.3.1 Implementation of parameter passing.

Summary.

Further reading.

Exercises.