Students' Guide to Programming Languages

Students' Guide to Programming Languages introduces programming languages, emphasizing why they are needed, how they are defined and constructed, and where and how they are used.
With greater access to computers at work, at school, and in the home, more and more people are now able to write programs. Only a small number of these people recognize the underlying features of the programming languages they are using, and even fewer people appreciate the features that are common to most programming languages. This book demonstrates how most programming languages are based upon the same concepts and how knowledge of these concepts can benefit the analyst and the programmer. When specifying computer solutions to real problems, the systems analyst and the programmer must be able to stand back from the particular problem in hand and visualize a solution that is independent of the constraints and limitations imposed by the programming language itself. The text helps in achieving these goals. The book as well is suitable for college students following BTEC and City and Guilds courses in computer studies and IT topics, including professional commercial and end-users.

Preface

1: Why Study Programming Languages?

Why Should We Study Programming Languages?

Programming Languages and the End-User

Programming Languages and the Systems Analyst

Programming Languages and the Programmer

2: What are Programming Languages?

The Development of Computers

Machine Code

Instruction Set

Why Have Only a Small Instruction Set?

Logical Operations

Comparison and Branching

Instruction Format

Assembly Code

Assembler

Data Names

Labels

Macros

Stored Programs

Subroutines

Subroutines in Practice

Another Processor

Third Generation Languages

Thinking of a Solution

Compiler

Ease of Use

Portability

Fourth Generation Languages

What is a Fourth Generation Language?

Different Instruction Sets

Other Instruction Sets

Binary Operations

Logical Operations

Data Format

Arithmetic Operations

Indexing

Immediate Instructions

Flags and Testing

Input and Output

Interpreting

Compiling, Linking and Loading

Linking and Loading

Executing

What Do We Want of a Programming Language?

3: Data and Data Types

Types of Data

Converting Binary Numbers to Decimal

Converting Decimal Numbers to Binary

Performing Binary Addition

Representing Other Data

Hexadecimal Notation

Binary / Decimal / Hexadecimal

Data Types

Character Data Type

Other Character Sets

Escape Sequences

Strings of Characters

Strings

Integer / Fixed Data Type

Negative Integer Numbers

Internal / External Format

Fractions

Very Large Numbers

Real Numbers

Floating Point Numbers

Normalized Numbers

Real Numbers in Storage

Single-Precision and Double-Precision

E-Notation

Packed Decimal

Boolean Data Type

Data Types in Programming Languages

Data Types in Basic

Data Types in Ada

Data Types in APL

Data Types in Cobol

Data Types in Fortran

Data Types in Pascal

Data Types in PL/1

Data Types in C

Type Checking

Arrays

Subscripts

Working with Arrays

Homogeneous Arrays

Arrays with Several Dimensions

Records

Enumerated Data Types

Implementing Enumerated Data Types

Pointers

Linked Lists

Set Types

4: Abstract Data Types - Adts

What Do We Mean By Data Type?

An Abstract Data Type

A Simple Abstract Data Type

ADT: Queue

Possible Implementations

Specifying an ADT

Specifying an Operation

Formal Specifications

The Specification of the ADT: Queue

Implementing an ADT

Constraints during Implementation

Information Hiding

5: Programming Structure and Structures

Structured Programming

Program Structures

Sequence

Assignment Statements

Arithmetic Calculations

Selection

Logical Expressions

Iteration

Surface Structures

Surface Structures in Structured English

Surface Structures in C

Surface Structures in Cobol

Surface Structures in Fortran

Surface Structures in Pascal

Exception Conditions

Handling Exception Conditions

Tree Diagrams

Modular Programming

Functions or Subroutines?

Internal Processing Modules

External Processing Modules

Functions

Arguments

Scope

Calling a Module

Common Data

Labeled Common

Using COMMON Data

6: Specifying a Programming Language

Specifying a Language

Recursive Rules

BNF: Backus-Naur Form

Deriving a Sentence from a Grammar

Parsing

EBNF: Extended Backus-Naur Form

More EBNF Symbols

Syntax Diagrams

Recursion in Syntax Diagrams

Context-Free Grammars

Semantics

Specification by Narrative Description

Specification by Example

Specification by Substitution

7: Specifying Functions

Specifying Functions

Sets

Is a Member of

Operations on Sets

Union

Difference

Intersection

Writing the Members of a Set

Primitive Types in Formal Specifications

The Input Set and the Domain

Mapping

The Output Set and the Range

Describing a Function

Partial Functions and Total Functions

Functions with Other Types of Data

More than One Input Value

Other Data Types

Formal Descriptions

Recursion

8: Compilers and Compiling

A Compiler

Lexical Analysis

The Symbol Table

Constants and Variables

Arrays and the Symbol Table

Syntax Analysis

Syntax Checking in General

Syntax Checking in Action

Syntax Errors

Arithmetic Expressions

Reverse Polish Notation

An Algorithm to Convert in-Fix Expressions to Post-Fix

Evaluating a Post-Fix Expression

An Algorithm to Evaluate Post-Fix Expressions

Producing the Object Code

Labels

Scope-Checking

Optimization

9: Applying Languages: Commercial

Procedural or Non-Procedural Languages?

Even Before Software

Report Program Generators

Program Generators

Partial Action of a Program Generator

Databases

Database Languages

Inquiry Languages

SQL

Sorting

Selecting Specific Items

Dbase

Sorting in Dbase

Processing in Dbase

QBE; Query by Example

Processing in QBE

Data Description Language

Fourth Generation Languages

What is a Fourth Generation Language?

The Pros and Cons of Using 4gls

Prototyping

4GL / Inquiry Language / Data Manipulation Language

Looking At A 4GL

Derived Fields

Using the Data Dictionary

SB + and the Users

10: Applying Languages: Specialist

Concurrent Processing

Synchronization

Condition Synchronization

Mutual Exclusion

Deadlock

Transputers

Occam

An Occam Definition

More Occam Facilities

Priority and Selection

Simulation Problems

Simulation Languages

What is the Problem?

Queuing Diagrams

A Simplified Simulation Language

What Else is There?

Linear Programming

11: Other Language Models

Functional Programming Languages

Lambda Notation

Orthogonality

Composition of Functions

LISP: List Processing

Processing with LISP

Arithmetic in LISP

Input and Output

The Quote Function

The COND Function

Defining Your Own LISP Functions

Heads and Tails

CAR and CDR

Implementing LISP

Cells and Binding

Logic Programming

Prologue: Programming in Logic

and / OR

Backtracking

Write Predicate

Prologue in Business

Processing Data in Prologue

Instantiation

Expert Systems

Object-Oriented Programming

Classes

Messages

Methods

Blocks

Selection and Iteration

Input / Output

Index