Students' Guide to Programming Languages

Students' Guide to Programming Languages

1st Edition - March 25, 1992

Write a review

  • Author: Malcolm Bull
  • eBook ISBN: 9781483141473

Purchase options

Purchase options
DRM-free (PDF)
Sales tax will be calculated at check-out

Institutional Subscription

Free Global Shipping
No minimum order

Description

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.

Table of Contents


  • 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


Product details

  • No. of pages: 538
  • Language: English
  • Copyright: © Newnes 1992
  • Published: March 25, 1992
  • Imprint: Newnes
  • eBook ISBN: 9781483141473

About the Author

Malcolm Bull

Ratings and Reviews

Write a review

There are currently no reviews for "Students' Guide to Programming Languages"