Programming: Concepts and Paradigms Publisher/ISBN/Ordering Information Description of Book Program Examples from Book Solutions Manual for Book Preface Table of Contents

Book Information

Book Description

It emphasizes the basic concepts of programming and presents, in parallel, the two principal paradigms for structuring programs: the procedure-oriented paradigm and the object-oriented paradigm. This approach is intended to help students understand both paradigms and to move more easily between them. The computer concepts covered include: input of data, control constructs, procedures, functions, object, classes and inheritance, arrays, records, unions and sets, algorithms for sorting, pointers and linked lists, and trees.

Preface to Programming: Concepts and Paradigms (First Edition)

The programming language used in this book is Object Oriented Turing (OOT), which has an easy-to-learn syntax and is supported by student-friendly programming environments. By learning the fundamentals of programming using a language that does not intrude with a difficult syntax, students can make a relatively easy transition to any one of the currently popular object-oriented languages such as C++ or Java.

Overview

The list of chapter titles outlines the arrangement of materials.

1. Programming Paradigms
2. Basic Programming Language Concepts
3. Input of Data
4. Control Constructs
5. Procedures
6. Functions
7. Objects, Classes, and Inheritance
8. Arrays
9. Records, Unions, and Sets
10. Algorithms for Sorting Lists
11. Pointers and Linked Lists
12. Trees
13. Advanced Graphics and Sound

Chapter 2 presents the EBNF metalanguage for formally describing the syntax of a programming language. The simple data types of the OOT language are defined along with the way to declare variables of these types. Expressions for each type are also defined and the statement that assigns the value of such an expression to a variable of the appropriate type introduced. How values of the different data types are output and formatted is explained. Comments are shown as providing internal documentation to a program.

Chapter 3 discusses how data can be input to a program. Ways in which a list of data items can be input by counted or conditional loops are shown. Input from the standard input, the keyboard, and input from a file are discussed. Input of string data by token, characters, or by line is presented. Ways to generate data using random numbers, for purposes of testing programs are presented. The statistical analysis of numerical data is also described.

Chapter 4 deals with program structure. Programs are described as consisting of the three basic forms of structure: linear sequence, repetition, and selection. The OOT syntax for each of these is defined. The use of diagrams such as flow charts to supplement the program itself is discussed and shown to be unnecessary for a structured program properly paragraphed and internally documented. Tracing execution of a program before trying to run it on a computer is encouraged.

Chapter 5 provides details about procedures - subprograms that act. The relationship between formal and actual parameters is defined. Variable parameters are introduced. The scope of identifiers in a program is defined. Ways of formally specifying the action of a procedure, testing it, and tracing the execution are outlined.

Chapter 6 defines functions - subprograms that produce a value from parameters that are provided to it. Many predefined functions are reviewed. Declaration and specification of functions is formalized, and the perils of side effects discussed. Functions that call themselves - recursive functions - and iterative functions that accomplish the same result are dealt with.

Chapter 7 shows how objects can encapsulate data and the procedures or functions that operate on the data and illustrates how other objects or programs using the object are prevented from interfering with the encapsulated data. The use of predefined objects is discussed, as well as ways of creating new objects. Students are introduced to a class as a pattern or template for creating multiple objects. Inheritance is introduced as the means by which new classes are created through modifications of a base or parent class. By using a library of classes students will be able both to create multiple objects (instances) and to create new classes.

Chapter 8 introduces the structured data type called an array. This chapter demonstrates how individual elements of an array share the same name and data type but are distinguished from each other by having an index. It also illustrates how arrays passed as parameters to subprograms may have dynamic definition. The efficiencies of searching an unsorted array by a linear search and a sorted array by a binary search are compared.

Chapter 9 describes additional data types that are structured, that is, composed of groups of simple data types or of structured types themselves. The use of the types: record, union, and set, is discussed. A simple linear search of an array of records is introduced as an example of using records.

Chapter 10 presents algorithms for sorting lists of records stored in arrays. The time complexity of sorting algorithms is explored and big O notation introduced. The chapter also explains how methods depending on recursion prove to be much more efficient than simple exchange algorithms.

Chapter 11 gives details of pointers and how they can be used to link records together in simple linked lists and in the instantiation of a class to produce an object. A list class is created and then modified to produce an ordered list class by inheritance.

Chapter 12 introduces the binary tree as a data structure that has a recursive definition and is easily implemented by pointers. The chapter demonstrates how the binary search tree provides the efficiency of searching achieved with a sorted array using a binary search, and the ease of insertion and deletion of elements in a linear listed list. The heap sort is introduced as a recursive method of sorting which uses trees that are defined somewhat differently than binary search trees.

Chapter 13 describes the use of the OOT modules for creating relatively complex graphics, including animation and accompanying sound. A class is defined to allow the creation of multiple pie charts. Other areas covered include OOT predefines for graphics and font control.

Flexibility

Object Oriented Turing

The Turing language was developed in 1982 in response to the need for a programming notation that incorporates good structuring methods, supports a correctness approach, is easy for the student to learn, and is suited to interactive programming. This language has gained considerable acceptance as a teaching medium.

The Turing language has undergone extensive enhancement, in terms of both software support and language notation, since its inception. In 1992 a superset of Turing, called Object Oriented Turing (OOT) was created by adding a number of features including classes, inheritance, concurrency, and unit-based separate compilation.

The programming environment for OOT is particularly helpful for the learning student. It provides good diagnostic messages for syntax errors and run-time errors. It provides strong run-time checking, with automatic detection of uninitialized variables and dangling pointers. It supports an on-line manual (lookup of language features by a button press), a directory browser, and multi-window editing. Versions of the environment allow the student to use a wide variety of hardware platforms and operating systems.

Once programming concepts have been learned in OOT, it is relatively easy to transfer these ideas to new situations. In particular, data structuring, algorithms, and object-orientation learned using OOT transfer directly to industrial systems such as C++ and Java. Of course, in order to use C++ or Java effectively, the student must also learn to cope with a difficult syntax and with minimal run-time checking, things which are best put off until essential concepts are mastered.

J.N.P. Hume
D.T. Barnard

Table of Contents of Programming: Concepts and Paradigms (1st edition)