Concepts of Programming Languages 12th Edition by Robert W Sebesta ISBN 9780134997186 0134997182

Concepts of Programming Languages 12th Edition by Robert W Sebesta – Ebook PDF Instant Download/Delivery: 9780134997186 ,0134997182
Full download Concepts of Programming Languages 12th Edition after payment

Product details:

ISBN 10: 0134997182
ISBN 13: 9780134997186
Author: Robert W Sebesta

Concepts of Programming Languages 12th Edition Table of contents:

1 Preliminaries

1.1 Reasons for Studying Concepts of Programming Languages

1.2 Programming Domains

1.2.1 Scientific Applications

1.2.2 Business Applications

1.2.3 Artificial Intelligence

1.2.4 Web Software

1.3 Language Evaluation Criteria

1.3.1 Readability

1.3.1.1 Overall Simplicity

1.3.1.2 Orthogonality

1.3.1.3 Data Types

1.3.1.4 Syntax Design

1.3.2 Writability

1.3.2.1 Simplicity and Orthogonality

1.3.2.2 Expressivity

1.3.3 Reliability

1.3.3.1 Type Checking

1.3.3.2 Exception Handling

1.3.3.3 Aliasing

1.3.3.4 Readability and Writability

1.3.4 Cost

1.4 Influences on Language Design

1.4.1 Computer Architecture

1.4.2 Programming Design Methodologies

1.5 Language Categories

1.6 Language Design Trade-Offs

1.7 Implementation Methods

1.7.1 Compilation

1.7.2 Pure Interpretation

1.7.3 Hybrid Implementation Systems

1.7.4 Preprocessors

1.8 Programming Environments

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

2 Evolution of the Major Programming Languages

2.1 Zuse’s Plankalkül

2.1.1 Historical Background

2.1.2 Language Overview

2.2 Pseudocodes

2.2.1 Short Code

2.2.2 Speedcoding

2.2.3 The UNIVAC “Compiling” System

2.2.4 Related Work

2.3 The IBM 704 and Fortran

2.3.1 Historical Background

2.3.2 Design Process

2.3.3 Fortran I Overview

2.3.4 Fortran II

2.3.5 Fortrans IV, 77, 90, 95, 2003, and 2008

2.3.6 Evaluation

2.4 Functional Programming: Lisp

2.4.1 The Beginnings of Artificial Intelligence (AI) and List Processing

2.4.2 Lisp Design Process

2.4.3 Language Overview

2.4.3.1 Data Structures

2.4.3.2 Processes in Functional Programming

2.4.3.3 The Syntax of Lisp

2.4.4 Evaluation

2.4.5 Two Descendants of Lisp

2.4.5.1 Scheme

2.4.5.2 Common Lisp

2.4.6 Related Languages

2.5 The First Step Toward Sophistication: ALGOL 60

2.5.1 Historical Background

2.5.2 Early Design Process

2.5.3 ALGOL 58 Overview

2.5.4 Reception of the ALGOL 58 Report

2.5.5 ALGOL 60 Design Process

2.5.6 ALGOL 60 Overview

2.5.7 Evaluation

2.6 Computerizing Business Records: COBOL

2.6.1 Historical Background

2.6.2 FLOW-MATIC

2.6.3 COBOL Design Process

2.6.4 Evaluation

2.7 The Beginnings of Timesharing: Basic

2.7.1 Design Process

2.7.2 Language Overview

2.7.3 Evaluation

2.8 Everything for Everybody: PL/I

2.8.1 Historical Background

2.8.2 Design Process

2.8.3 Language Overview

2.8.4 Evaluation

2.9 Two Early Dynamic Languages: APL and SNOBOL

2.9.1 Origins and Characteristics of APL

2.9.2 Origins and Characteristics of SNOBOL

2.10 The Beginnings of Data Abstraction: SIMULA 67

2.10.1 Design Process

2.10.2 Language Overview

2.11 Orthogonal Design: ALGOL 68

2.11.1 Design Process

2.11.2 Language Overview

2.11.3 Evaluation

2.12 Some Early Descendants of the ALGOLs

2.12.1 Simplicity by Design: Pascal

2.12.1.1 Historical Background

2.12.1.2 Evaluation

2.12.2 A Portable Systems Language: C

2.12.2.1 Historical Background

2.12.2.2 Evaluation

2.13 Programming Based on Logic: Prolog

2.13.1 Design Process

2.13.2 Language Overview

2.13.3 Evaluation

2.14 History’s Largest Design Effort: Ada

2.14.1 Historical Background

2.14.2 Design Process

2.14.3 Language Overview

2.14.4 Evaluation

2.14.5 Ada 95 and Ada 2005

2.15 Object-Oriented Programming: Smalltalk

2.15.1 Design Process

2.15.2 Language Overview

2.15.3 Evaluation

2.16 Combining Imperative and Object-Oriented Features: C++

2.16.1 Design Process

2.16.2 Language Overview

2.16.3 Evaluation

2.16.4 A Replacement for Objective-C, Swift

2.16.5 Another Related Language: Delphi

2.17 An Imperative-Based Object-Oriented Language: Java

2.17.1 Design Process

2.17.2 Language Overview

2.17.3 Evaluation

2.18 Scripting Languages

2.18.1 Origins and Characteristics of Perl

2.18.2 Origins and Characteristics of JavaScript

2.18.3 Origins and Characteristics of PHP

2.18.4 Origins and Characteristics of Python

2.18.5 Origins and Characteristics of Ruby

2.19 The Flagship .NET Language: C#

2.19.1 Design Process

2.19.2 Language Overview

2.19.3 Evaluation

2.20 Markup-Programming Hybrid Languages

2.20.1 XSLT

2.20.2 JSP

SUMMARY

BIBLIOGRAPHIC NOTES

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

3 Describing Syntax and Semantics

3.1 Introduction

3.2 The General Problem of Describing Syntax

3.2.1 Language Recognizers

3.2.2 Language Generators

3.3 Formal Methods of Describing Syntax

3.3.1 Backus-Naur Form and Context-Free Grammars

3.3.1.1 Context-Free Grammars

3.3.1.2 Origins of Backus-Naur Form

3.3.1.3 Fundamentals

3.3.1.4 Describing Lists

3.3.1.5 Grammars and Derivations

3.3.1.6 Parse Trees

3.3.1.7 Ambiguity

3.3.1.8 Operator Precedence

3.3.1.9 Associativity of Operators

3.3.1.10 An Unambiguous Grammar for if-else

3.3.2 Extended BNF

3.3.3 Grammars and Recognizers

3.4 Attribute Grammars

3.4.1 Static Semantics

3.4.2 Basic Concepts

3.4.3 Attribute Grammars Defined

3.4.4 Intrinsic Attributes

3.4.5 Examples of Attribute Grammars

3.4.6 Computing Attribute Values

3.4.7 Evaluation

3.5 Describing the Meanings of Programs: Dynamic Semantics

3.5.1 Operational Semantics

3.5.1.1 The Basic Process

3.5.1.2 Evaluation

3.5.2 Denotational Semantics

3.5.2.1 Two Simple Examples

3.5.2.2 The State of a Program

3.5.2.3 Expressions

3.5.2.4 Assignment Statements

3.5.2.5 Logical Pretest Loops

3.5.2.6 Evaluation

3.5.3 Axiomatic Semantics

3.5.3.1 Assertions

3.5.3.2 Weakest Preconditions

3.5.3.3 Assignment Statements

3.5.3.4 Sequences

3.5.3.5 Selection

3.5.3.6 Logical Pretest Loops

3.5.3.7 Program Proofs

3.5.3.8 Evaluation

SUMMARY

BIBLIOGRAPHIC NOTES

REVIEW QUESTIONS

PROBLEM SET

4 Lexical and Syntax Analysis

4.1 Introduction

4.2 Lexical Analysis

4.3 The Parsing Problem

4.3.1 Introduction to Parsing

4.3.2 Top-Down Parsers

4.3.3 Bottom-Up Parsers

4.3.4 The Complexity of Parsing

4.4 Recursive-Descent Parsing

4.4.1 The Recursive-Descent Parsing Process

4.4.2 The LL Grammar Class

4.5 Bottom-Up Parsing

4.5.1 The Parsing Problem for Bottom-Up Parsers

4.5.2 Shift-Reduce Algorithms

4.5.3 LR Parsers

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

5 Names, Bindings, and Scopes

5.1 Introduction

5.2 Names

5.2.1 Design Issues

5.2.2 Name Forms

5.2.3 Special Words

5.3 Variables

5.3.1 Name

5.3.2 Address

5.3.3 Type

5.3.4 Value

5.4 The Concept of Binding

5.4.1 Binding of Attributes to Variables

5.4.2 Type Bindings

5.4.2.1 Static Type Binding

5.4.2.2 Dynamic Type Binding

5.4.3 Storage Bindings and Lifetime

5.4.3.1 Static Variables

5.4.3.2 Stack-Dynamic Variables

5.4.3.3 Explicit Heap-Dynamic Variables

5.4.3.4 Implicit Heap-Dynamic Variables

5.5 Scope

5.5.1 Static Scope

5.5.2 Blocks

5.5.3 Declaration Order

5.5.4 Global Scope

5.5.5 Evaluation of Static Scoping

5.5.6 Dynamic Scope

5.5.7 Evaluation of Dynamic Scoping

5.6 Scope and Lifetime

5.7 Referencing Environments

5.8 Named Constants

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

6 Data Types

6.1 Introduction

6.2 Primitive Data Types

6.2.1 Numeric Types

6.2.1.1 Integer

6.2.1.2 Floating-Point

6.2.1.3 Complex

6.2.1.4 Decimal

6.2.2 Boolean Types

6.2.3 Character Types

6.3 Character String Types

6.3.1 Design Issues

6.3.2 Strings and Their Operations

6.3.3 String Length Options

6.3.4 Evaluation

6.3.5 Implementation of Character String Types

6.4 Enumeration Types

6.4.1 Design Issues

6.4.2 Designs

6.4.3 Evaluation

6.5 Array Types

6.5.1 Design Issues

6.5.2 Arrays and Indices

6.5.3 Subscript Bindings and Array Categories

6.5.4 Array Initialization

6.5.5 Array Operations

6.5.6 Rectangular and Jagged Arrays

6.5.7 Slices

6.5.8 Evaluation

6.5.9 Implementation of Array Types

6.6 Associative Arrays

6.6.1 Structure and Operations

6.6.2 Implementing Associative Arrays

6.7 Record Types

6.7.1 Definitions of Records

6.7.2 References to Record Fields

6.7.3 Evaluation

6.7.4 Implementation of Record Types

6.8 Tuple Types

6.9 List Types

6.10 Union Types

6.10.1 Design Issues

6.10.2 Discriminated Versus Free Unions

6.10.3 Unions in F#

6.10.4 Evaluation

6.10.5 Implementation of Union Types

6.11 Pointer and Reference Types

6.11.1 Design Issues

6.11.2 Pointer Operations

6.11.3 Pointer Problems

6.11.3.1 Dangling Pointers

6.11.3.2 Lost Heap-Dynamic Variables

6.11.4 Pointers in C and C++

6.11.5 Reference Types

6.11.6 Evaluation

6.11.7 Implementation of Pointer and Reference Types

6.11.7.1 Representations of Pointers and References

6.11.7.2 Solutions to the Dangling-Pointer Problem

6.11.7.3 Heap Management

Single-Size Cells 

Variable-Size Cells 

6.12 Optional Types

6.13 Type Checking

6.14 Strong Typing

6.15 Type Equivalence

6.16 Theory and Data Types

SUMMARY

BIBLIOGRAPHIC NOTES

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

7 Expressions and ­Assignment Statements

7.1 Introduction

7.2 Arithmetic Expressions

7.2.1 Operator Evaluation Order

7.2.1.1 Precedence

7.2.1.2 Associativity

7.2.1.3 Parentheses

7.2.1.4 Ruby Expressions

7.2.1.5 Expressions in Lisp

7.2.1.6 Conditional Expressions

7.2.2 Operand Evaluation Order

7.2.2.1 Side Effects

7.2.2.2 Referential Transparency and Side Effects

7.3 Overloaded Operators

7.4 Type Conversions

7.4.1 Coercion in Expressions

7.4.2 Explicit Type Conversion

7.4.3 Errors in Expressions

7.5 Relational and Boolean Expressions

7.5.1 Relational Expressions

7.5.2 Boolean Expressions

7.6 Short-Circuit Evaluation

7.7 Assignment Statements

7.7.1 Simple Assignments

7.7.2 Conditional Targets

7.7.3 Compound Assignment Operators

7.7.4 Unary Assignment Operators

7.7.5 Assignment as an Expression

7.7.6 Multiple Assignments

7.7.7 Assignment in Functional Programming Languages

7.8 Mixed-Mode Assignment

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

8 Statement-Level Control Structures

8.1 Introduction

8.2 Selection Statements

8.2.1 Two-Way Selection Statements

8.2.1.1 Design Issues

8.2.1.2 The Control Expression

8.2.1.3 Clause Form

8.2.1.4 Nesting Selectors

8.2.1.5 Selector Expressions

8.2.2 Multiple-Selection Statements

8.2.2.1 Design Issues

8.2.2.2 Examples of Multiple Selectors

8.2.2.3 Implementing Multiple Selection Structures

8.2.2.4 Multiple Selection Using if

8.3 Iterative Statements

8.3.1 Counter-Controlled Loops

8.3.1.1 Design Issues

8.3.1.2 The for Statement of the C-Based Languages

8.3.1.3 The for Statement of Python

8.3.1.4 Counter-Controlled Loops in Functional Languages

8.3.2 Logically Controlled Loops

8.3.2.1 Design Issues

8.3.2.2 Examples

8.3.3 User-Located Loop Control Mechanisms

8.3.4 Iteration Based on Data Structures

8.4 Unconditional Branching

8.5 Guarded Commands

8.6 Conclusions

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

9 Subprograms

9.1 Introduction

9.2 Fundamentals of Subprograms

9.2.1 General Subprogram Characteristics

9.2.2 Basic Definitions

9.2.3 Parameters

9.2.4 Procedures and Functions

9.3 Design Issues for Subprograms

9.4 Local Referencing Environments

9.4.1 Local Variables

9.4.2 Nested Subprograms

9.5 Parameter-Passing Methods

9.5.1 Semantics Models of Parameter Passing

9.5.2 Implementation Models of Parameter Passing

9.5.2.1 Pass-by-Value

9.5.2.2 Pass-by-Result

9.5.2.3 Pass-by-Value-Result

9.5.2.4 Pass-by-Reference

9.5.2.5 Pass-by-Name

9.5.3 Implementing Parameter-Passing Methods

9.5.4 Parameter-Passing Methods of Some Common Languages

9.5.5 Type Checking Parameters

9.5.6 Multidimensional Arrays as Parameters

9.5.7 Design Considerations

9.5.8 Examples of Parameter Passing

9.6 Parameters That Are Subprograms

9.7 Calling Subprograms Indirectly

9.8 Design Issues for Functions

9.8.1 Functional Side Effects

9.8.2 Types of Returned Values

9.8.3 Number of Returned Values

9.9 Overloaded Subprograms

9.10 Generic Subprograms

9.10.1 Generic Functions in C++

9.10.2 Generic Methods in Java 5.0

9.10.3 Generic Methods in C# 2005

9.10.4 Generic Functions in F#

9.11 User-Defined Overloaded Operators

9.12 Closures

9.13 Coroutines

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

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.3.1 More Complex Activation Records

10.3.2 An Example without Recursion

10.3.3 Recursion

10.4 Nested Subprograms

10.4.1 The Basics

10.4.2 Static Chains

10.5 Blocks

10.6 Implementing Dynamic Scoping

10.6.1 Deep Access

10.6.2 Shallow Access

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

11 Abstract Data Types and Encapsulation Constructs

11.1 The Concept of Abstraction

11.2 Introduction to Data Abstraction

11.2.1 Floating-Point as an Abstract Data Type

11.2.2 User-Defined Abstract Data Types

11.2.3 An Example

11.3 Design Issues for Abstract Data Types

11.4 Language Examples

11.4.1 Abstract Data Types in C++

11.4.1.1 Encapsulation

11.4.1.2 Information Hiding

11.4.1.3 Constructors and Destructors

11.4.1.4 An Example

11.4.2 Abstract Data Types in Java

11.4.2.1 An Example

11.4.2.2 Evaluation

11.4.3 Abstract Data Types in C#

11.4.3.1 Encapsulation

11.4.3.2 Information Hiding

11.4.4 Abstract Data Types in Ruby

11.4.4.1 Encapsulation

11.4.4.2 Information Hiding

11.4.4.3 An Example

11.4.4.4 Evaluation

11.5 Parameterized Abstract Data Types

11.5.1 C++

11.5.2 Java 5.0

11.5.3 C# 2005

11.6 Encapsulation Constructs

11.6.1 Introduction

11.6.2 Encapsulation in C

11.6.3 Encapsulation in C++

11.6.4 C# Assemblies

11.7 Naming Encapsulations

11.7.1 C++ Namespaces

11.7.2 Java Packages

11.7.3 Ruby Modules

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

12 Support for Object-­Oriented Programming

12.1 Introduction

12.2 Object-Oriented Programming

12.2.1 Introduction

12.2.2 Inheritance

12.2.3 Dynamic Binding

12.3 Design Issues for Object-Oriented Languages

12.3.1 The Exclusivity of Objects

12.3.2 Are Subclasses Subtypes?

12.3.3 Single and Multiple Inheritance

12.3.4 Allocation and Deallocation of Objects

12.3.5 Dynamic and Static Binding

12.3.6 Nested Classes

12.3.7 Initialization of Objects

12.4 Support for Object-Oriented Programming in Specific Languages

12.4.1 Smalltalk

12.4.1.1 General Characteristics

12.4.1.2 Inheritance

12.4.1.3 Dynamic Binding

12.4.1.4 Evaluation of Smalltalk

12.4.2 C++

12.4.2.1 General Characteristics

12.4.2.2 Inheritance

12.4.2.3 Dynamic Binding

12.4.2.4 Evaluation

12.4.3 Java

12.4.3.1 General Characteristics

12.4.3.2 Inheritance

12.4.3.3 Dynamic Binding

12.4.3.4 Nested Classes

12.4.3.5 Evaluation

12.4.4 C#

12.4.4.1 General Characteristics

12.4.4.2 Inheritance

12.4.4.3 Dynamic Binding

12.4.4.4 Nested Classes

12.4.4.5 Evaluation

12.4.5 Ruby

12.4.5.1 General Characteristics

12.4.5.2 Inheritance

12.4.5.3 Dynamic Binding

12.4.5.4 Evaluation

12.5 Implementation of Object-Oriented Constructs

12.5.1 Instance Data Storage

12.5.2 Dynamic Binding of Method Calls to Methods

12.6 Reflection

12.6.1 Introduction

12.6.2 What Is Reflection?

12.6.3 Reflection in Java

12.6.4 Reflection in C#

SUMMARY

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

13 Concurrency

13.1 Introduction

13.1.1 Multiprocessor Architectures

13.1.2 Categories of Concurrency

13.1.3 Motivations for the Use of Concurrency

13.2 Introduction to Subprogram-Level Concurrency

13.2.1 Fundamental Concepts

13.2.2 Language Design for Concurrency

13.2.3 Design Issues

13.3 Semaphores

13.3.1 Introduction

13.3.2 Cooperation Synchronization

13.3.3 Competition Synchronization

13.3.4 Evaluation

13.4 Monitors

13.4.1 Introduction

13.4.2 Competition Synchronization

13.4.3 Cooperation Synchronization

13.4.4 Evaluation

13.5 Message Passing

13.5.1 Introduction

13.5.2 The Concept of Synchronous Message Passing

13.6 Ada Support for Concurrency

13.6.1 Fundamentals

13.6.2 Cooperation Synchronization

13.6.3 Competition Synchronization

13.6.4 Protected Objects

13.6.5 Evaluation

13.7 Java Threads

13.7.1 The Thread Class

13.7.2 Priorities

13.7.3 Semaphores

13.7.4 Competition Synchronization

13.7.5 Cooperation Synchronization

13.7.6 Nonblocking Synchronization

13.7.7 Explicit Locks

13.7.8 Evaluation

13.8 C# Threads

13.8.1 Basic Thread Operations

13.8.2 Synchronizing Threads

13.8.3 Evaluation

13.9 Concurrency in Functional Languages

13.9.1 Multi-LISP

13.9.2 Concurrent ML

13.9.3 F#

13.10 Statement-Level Concurrency

13.10.1 High-Performance Fortran

SUMMARY

BIBLIOGRAPHIC NOTES

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

14 Exception Handling and Event Handling

14.1 Introduction to Exception Handling

14.1.1 Basic Concepts

14.1.2 Design Issues

14.2 Exception Handling in C++

14.2.1 Exception Handlers

14.2.2 Binding Exceptions to Handlers

14.2.3 Continuation

14.2.4 Other Design Choices

14.2.5 An Example

14.2.6 Evaluation

14.3 Exception Handling in Java

14.3.1 Classes of Exceptions

14.3.2 Exception Handlers

14.3.3 Binding Exceptions to Handlers

14.3.4 Other Design Choices

14.3.5 An Example

14.3.6 The finally Clause

14.3.7 Assertions

14.3.8 Evaluation

14.4 Exception Handling in Python and Ruby

14.4.1 Python

14.4.2 Ruby

14.5 Introduction to Event Handling

14.6 Event Handling with Java

14.6.1 Java Swing GUI Components4

14.6.2 The Java Event Model

14.7 Event Handling in C#

SUMMARY

BIBLIOGRAPHIC NOTES

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

15 Functional Programming Languages

15.1 Introduction

15.2 Mathematical Functions

15.2.1 Simple Functions

15.2.2 Functional Forms

15.3 Fundamentals of Functional Programming Languages

15.4 The First Functional Programming Language: Lisp

15.4.1 Data Types and Structures

15.4.2 The First Lisp Interpreter

15.5 An Introduction to Scheme

15.5.1 Origins of Scheme

15.5.2 The Scheme Interpreter

15.5.3 Primitive Numeric Functions

15.5.4 Defining Functions

15.5.5 Output Functions

15.5.6 Numeric Predicate Functions

15.5.7 Control Flow

15.5.8 List Functions

15.5.9 Predicate Functions for Symbolic Atoms and Lists

15.5.10 Example Scheme Functions

15.5.11 LET

15.5.12 Tail Recursion in Scheme

15.5.13 Functional Forms

15.5.13.1 Functional Composition

15.5.13.2 An Apply-to-All Functional Form

15.5.14 Functions That Build Code

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

SUMMARY

BIBLIOGRAPHIC NOTES

REVIEW QUESTIONS

PROBLEM SET

PROGRAMMING EXERCISES

16 Logic Programming Languages

16.1 Introduction

16.2 A Brief Introduction to Predicate Calculus

16.2.1 Propositions

16.2.2 Clausal Form

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.6.1 Terms

16.6.2 Fact Statements

16.6.3 Rule Statements

16.6.4 Goal Statements

16.6.5 The Inferencing Process of Prolog

16.6.6 Simple Arithmetic

16.6.7 List Structures

16.7 Deficiencies of Prolog

16.7.1 Resolution Order Control

16.7.2 The Closed-World Assumption

16.7.3 The Negation Problem

16.7.4 Intrinsic Limitations

16.8 Applications of Logic Programming

16.8.1 Relational Database Management Systems

16.8.2 Expert Systems

16.8.3 Natural-Language Processing

People also search for Concepts of Programming Languages 12th Edition:

robert sebesta concepts of programming languages
    
basic concepts of programming languages
    
concepts of programming languages 12th edition
    
fundamental concepts of programming languages
    
concepts of programming languages 11th edition

Tags: Robert W Sebesta, Programming Languages, Concepts