Prelude to Programming, 6th edition

Stewart Venit California State University Los Angeles
Elizabeth Drake Santa Fe College

eTextbook

per month

Anytime, anywhere learning with the Pearson+ app
Easy-to-use search, navigation and notebook
Simpler studying with flashcards

Print

$165.32

Hardcover, paperback or looseleaf edition
Affordable rental option for select titles
Free shipping on looseleafs and traditional textbooks

Appropriate for Pre-Programming and Introductory Programming courses in community colleges, 4-year colleges, and universities

Prelude to Programming provides beginning students with a language-independent framework for learning core programming concepts and effective design techniques. This approach gives students the foundation they need to understand the logic behind program design and to establish effective programming skills.

The Sixth Edition offers students a lively and accessible presentation as they learn core programming concepts—including data types, control structures, data files and arrays, and program design techniques such as top-down modular design and proper program documentation and style. Problem-solving skills are developed when students learn how to use basic programming tools and algorithms, which include data validation, defensive programming, calculating sums and averages, and searching and sorting lists.

Teaching and Learning Experience

This program presents a better teaching and learning experience–for you and your students. It provides:

A Language-Independent, Flexible Presentation: The text has been designed so that instructors can use it for students at various levels.
Features that Help Solidify Concepts: Examples, exercises, and programming challenges help students understand how concepts in the text apply to real-life programs.
Real Programming Experience with RAPTOR: Students gain first-hand programming experience through the optional use of RAPTOR, a free flowchart-based programming environment.
Support Learning: Resources are available to expand on the topics presented in the text.

A Language-Independent, Flexible Presentation

This language-independent intro¿duction to programming concepts helps students learn the following:

General programming topics, such as data types, control structures, arrays, files, functions, and subprograms
Structured programming principles, such as modular design, proper program documentation and style, and event-driven, and object-oriented program design
Basic tools and algorithms, such as data validation, defensive programming, sums and averages computation, and searching and sorting algorithms
Data representation of integer and floating point numbers

This text is written and organized to allow flexibility in covering topics.

Material is presented in such a way that it can be used in any introductory programming course at any level.
Each concept is presented in a clear, easily understood manner and the level of difficulty builds slowly. The text has been designed so that instructors can use it for students at various levels.

NEW and UPDATED! Rather than relegating the material on data representation to Appendices, an entire chapter is devoted to these concepts. This chapter is completely independent of the rest of the content and can be skipped with no loss of continuity. However, instructors who want to include the material now have more examples and end-of-chapter Review Exercises.
NEW and UPDATED! Chapter 0 has been revised with up-to-date content relating to new technologies.
UPDATED! Chapter 1 has been revised and now includes information on the Boolean data type.
UPDATED! The material on arrays, searching, and sorting has been divided into two chapters. Chapter 7 focuses on creating and using both one- and two-dimensional arrays. Chapter 8 presents algorithms with extensive examples for searching and sorting.
NEW! When real code is given throughout the text, JavaScript code has been added.
NEW! More built-in functions and properties are introduced including Length_Of(), To_ASCII(), To_Character(), Indexing[], and more
UPDATED! The content in Chapter 11 on object-oriented programming has been thoroughly revised and simplified.
NEW! Material on event-driven programming has been added to Chapter 11.

Features that Help Solidify Concepts

In the Everyday World: Beginning with Chapter 1, each chapter starts with a discussion of how the material in that chapter relates to familiar things. This material provides an introduction to the programming logic used in that chapter through an ordinary and easily understood topic, and establishes a foundation upon which programming concepts are presented.
Making It Work: The Making It Work Features provide information about how to implement concepts in an actual high-level language, such as C++, Java, JavaScript, or Visual Basic. These boxed features appear throughout the text and are self-contained and optional.
What & Why: Often we conclude an Example with a short discussion about what would happen if the program were run, or what would happen if something in the program were changed. These What & Why Features help students deepen their understanding of how programs run. They are useful in initiating classroom discussion.
Pointers and Style Pointers: The concepts of programming style and documentation are introduced in Chapter 3 and emphasized throughout. Other Pointers appear periodically throughout the text. These short notes provide insight into the subject or specialized knowledge about the topic at hand.
Examples: There are more than 200 numbered worked Examples in the text. The pseudocode in the Examples includes line numbers for easy reference. Detailed line-by-line discussions follow the code with sections entitled What Happened?
Focus on Problem Solving: Each chapter from Chapter 4 to the end includes a Focus on Problem Solving Feature which presents a real-life programming problem, analyzes it, designs a program to solve it, discusses appropriate coding considerations, and indicates how the program can be tested. In the process, students not only see a review of the chapter material, but also work through a programming problem of significant difficulty. These sections are particularly useful to prepare students for a language-specific programming course. For selected programs there are real code implementations in C++, Java, Visual Basic, and Python available on the Pearson website which can be used to demonstrate how the concepts learned in the text apply to real-life programs. The program code illustrates the congruence between the pseudocode taught in this book and the code in a specific programming language. Executable files are also included so the actual programs can be run, even if the code is not used pedagogically.
NEW and UPDATED Exercises: Many new Review Exercises have been added to this edition to correspond with new material. Many Review Exercises have been revised to permit them to be implemented with RAPTOR. The text contains the following diverse selection:

Self Checks at the end of each section include items that test students’ understanding of the material covered in that section (answers to Self Checks are in Appendix C)
Review Questions at the end of each chapter include questions of various types that provide further review of the chapter material (Answers to the odd-numbered questions are in Appendix D; answers to the even-numbered questions are on the instructor support Web site).
Programming Challenges at the end of each chapter require students to design programs using the material learned in that chapter and earlier chapters. All Programming Challenges can be implemented with RAPTOR. Solutions to all Programming Challenges in RAPTOR are available on the instructor support Web site.

Real Programming Experience with RAPTOR

The text uses RAPTOR, a free flowcharting software application that allows students to create and run programs without focusing on syntax.
NEW! In this edition, each chapter from Chapter 3 onward contains a section entitled Running With RAPTOR. The section describes how to use RAPTOR for that chapter’s material with screenshots and step-by-step instructions. Short examples demonstrate how RAPTOR is used to work with the chapter’s content and a longer program is developed. The Running With RAPTOR sections can be skipped with no loss of continuity. However, if used, the longer RAPTOR programs give students a real-life experience by creating an interesting, executable program.

Support Learning

The following supplements are available to qualified instructors on Pearson's Instructor Resource Center. Please contact your local Pearson sales representative, or visit www.pearsonhighered.com/educator to access this material.

PowerPoint Presentations for all Chapters
Solutions to all Self Checks including RAPTOR implementations of appropriate problems
Solutions to all Review Exercises including corresponding RAPTOR programs
RAPTOR programs corresponding to all Programming Challenges
Testbanks with at least 40 test questions per chapter in a variety question types, including Multiple Choice, True/False, and Short Answer questions

A Language-Independent, Flexible Presentation

Rather than relegating the material on data representation to Appendices, an entire chapter is devoted to these concepts. This chapter is completely independent of the rest of the content and can be skipped with no loss of continuity. However, instructors who want to include the material now have more examples and end-of-chapter Review Exercises.
Chapter 0 has been revised with up-to-date content relating to new technologies
Chapter 1 has been revised and now includes information on the Boolean data type.
The material on arrays, searching, and sorting has been divided into two chapters. Chapter 7 focuses on creating and using both one- and two-dimensional arrays. Chapter 8 presents algorithms with extensive examples for searching and sorting.
When real code is given throughout the text, JavaScript code has been added.
More built-in functions and properties are introduced including Length_Of(), To_ASCII(), To_Character(), Indexing[], and more.
The content in Chapter 11 on object-oriented programming has been thoroughly revised and simplified.
New material on event-driven programming has been added to Chapter 11.

Features that Help Solidify Concepts

Throughout the text Examples, Self Checks, and Review Exercises have been redesigned when necessary to ensure that they can be worked with or without RAPTOR.
The Review Exercises in each chapter contain Multiple Choice, True/False, Short Answer, and a Programming Challenges section. All Challenge problems are suitable for RAPTOR.

Real Programming Experience with RAPTOR

The text uses RAPTOR, a free flowcharting software application that allows students to create and run programs without focusing on syntax. Each chapter, from Chapter 3 on, includes a section devoted to learning RAPTOR and using RAPTOR to develop interesting, executable programs.

Introduction
- 0.1 A Brief History of Computers
  - What Is a Computer?
  - Personal Computers
  - The Internet
- 0.2 Computer Basics
  - The Central Processing Unit
  - Internal Memory
  - Mass Storage Devices
  - Input Devices
  - Output Devices
- 0.3 Software and Programming Languages
  - Types of Software
  - Types of Programming and Scripting Languages
  - Chapter Review and Exercises
An Introduction to Programming
- In the Everyday World: You Are Already a Programmer!
- 1.1 What Is Programming?
  - A General Problem-Solving Strategy
  - Creating Computer Programs: The Program Development Cycle
- 1.2 Basic Programming Concepts
  - A Simple Program
  - Data Input
  - Program Variables and Constants
- 1.3 Data Processing and Output
  - Processing Data
  - Data Output
- 1.4 Data Types
  - The Declare Statement
  - Character and String Data
- 1.5 Integer Data
  - Operations on Integers
- 1.6 Floating Point Data
  - The Declare Statement Revisited
  - Types of Floating Point Numbers
- 1.7 Running With RAPTOR (Optional)
- Chapter Review and Exercises
Data Representation
- In the Everyday World: It Isn’t Magic–It’s Just Computer Code
- 2.1 Decimal and Binary Representation
  - Bases and Exponents
  - The Binary System
- 2.2 The Hexadecimal System
  - Hexadecimal Digits
  - Using Hexadecimal Notation
- 2.3 Integer Representation
  - Unsigned Integer Format
  - Sign-and-Magnitude Format
  - One’s Complement Format
  - Two’s Complement Format
- 2.4 Floating Point Representation
  - Floating Point Numbers: the Integer Part
  - Floating Point Numbers: the Fractional Part
  - Converting a Decimal Fraction to Binary
  - Putting the Two Parts Together
- 2.5 Putting it All Together
  - Scientific Notation
  - Exponential Notation
  - Base 10 Normalization
  - Normalizing Binary Floating Point Numbers
  - The Excess_127 System
  - Base 2 Normalization
  - Single- and Double-Precision Floating Point Numbers
  - Hexadecimal Representation
  - Chapter Review and Exercises
Developing a Program
- In the Everyday World: Planning to Program? You Need a Plan
- 3.1 The Program Development Cycle
  - The Process of Developing a Program
  - Additional Steps in the Cycle
- 3.2 Program Design
  - Modular Programming
- 3.3 Coding, Documenting, and Testing a Program
  - Coding and Documenting a Program
  - Testing a Program
  - Types of Errors
- 3.4 Commercial Programs: Testing and Documenting
  - The Testing Phase Revisited
  - External Documentation
- 3.5 Structured Programming
  - Flowcharts
  - Control Structures
  - Programming Style
- 3.6 Running With RAPTOR (Optional)
  - Getting Started
  - Introduction to RAPTOR Symbols
  - Variables
  - RAPTOR Symbols
  - Run It: The Sign-In Program
  - Developing the Program
  - Creating the Program in RAPTOR: Input
  - Creating the Program in RAPTOR: Processing
  - Creating the Program in RAPTOR: Output
  - Check It Out
  - Chapter Review and Exercises
Selection Structures: Making Decisions
- In the Everyday World: Decisions, Decisions, Decisions . . .
- 4.1 An Introduction to Selection Structures
  - Types of Selection Structures
  - Single- and Dual-Alternative Structures
- 4.2 Relational and Logical Operators
  - Relational Operators
  - Logical Operators
  - Hierarchy of Operations
- 4.3 ASCII Code and Comparing Strings
  - Representing Characters With Numbers
- 4.4 Selecting from Several Alternatives
  - Using If Structures
  - Using Case-Like Statements
- 4.5 Applications of Selection Structures
  - Defensive Programming
  - Menu-Driven Programs
- 4.6 Focus on Problem Solving: A New Car Price Calculator
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 4.7 Running With RAPTOR (Optional)
  - The Selection Symbol
  - The Call Symbol and Subcharts
  - An Example
  - Run It: The New Car Price Calculator
  - Developing the Program
  - Check It Out
  - Chapter Review and Exercises
Repetition Structures: Looping
- In the Everyday World: Doing the Same Thing Over and Over and Knowing When to Stop
- 5.1 An Introduction to Repetition Structures: Computers Never
  - Get Bored!
  - Loop Basics
  - Relational and Logical Operators
- 5.2 Types of Loops
  - Pre-Test and Post-Test Loops
  - Counter-Controlled Loops
- 5.3 The For Loop
  - The For Statement
  - The For Loop in Action
  - The Careful Bean Counter
- 5.4 Applications of Repetition Structures
  - Using Sentinel-Controlled Loops to Input Data
  - Data Validation
  - The Floor() and Ceiling() Functions
  - Computing Sums and Averages
- 5.5 Focus on Problem Solving: A Cost, Revenue, and Profit Problem
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 5.6 Running With RAPTOR (Optional)
  - Repetition: The Loop Symbol
  - A Short Example
  - Run It: Encryption: The Secret Message Encoder
  - What is Encryption?
  - Problem Statement
  - Developing the Program
  - Developing the Encrypting Algorithms
  - Check It Out
  - Chapter Review and Exercises
More about Loops and Decisions
- In the Everyday World: Loops Within Loops
- 6.1 Combining Loops with If-Then Statements
  - Exiting a Loop
- 6.2 Combining Loops and Decisions in Longer Programs
  - The Length_Of() Function
  - The Print Statement and the New Line Indicator
- 6.3 Random Numbers
  - The Random() Function
  - Not Really Random: The Pseudorandom Number
- 6.4 Nested Loops
  - Nested For Loops
  - Nesting Other Kinds of Loops
  - A Mental Workout: Mind Games
- 6.5 Focus on Problem Solving: A Guessing Game
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 6.6 Running With RAPTOR (Optional)
  - Two Short Examples
  - Run It: Validating a Password
  - Problem Statement
  - Developing the Program
  - Check the length of the password (4—8 characters)
  - Check the first character of the password (cannot be a number)
  - Check that the password contains one of the special characters (#, *, or $)
  - Chapter Review and Exercises
Arrays: Lists and Tables
- In the Everyday World: Organize It with Lists and Tables
- 7.1 One-Dimensional Arrays
  - Array Basics
- 7.2 Parallel Arrays
  - Some Advantages of Using Arrays
  - A Word About Databases
- 7.3 Strings as Arrays of Characters
  - Concatenation Revisited
  - String Length versus Array Size
- 7.4 Two-Dimensional Arrays
  - An Introduction to Two-Dimensional Arrays
  - Using Two-Dimensional Arrays
- 7.5 Focus on Problem Solving: The Magic Square
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 7.6 Running With RAPTOR (Optional)
  - A Short Example
  - Run It: Self-Grading Math Test
  - Problem Statement
  - Developing and Creating the Program
  - Check It Out
  - Chapter Review and Exercises
Searching and Sorting Arrays
- In the Everyday World: Searching and Sorting
- 8.1 Introduction to Searching and Sorting
  - The Serial Search Technique
  - Basic Steps in a Serial Search
  - Pseudocode for a Serial Search
- 8.2 The Bubble Sort Technique
  - Swapping Values
  - Using the Bubble Sort Algorithm
- 8.3 The Binary Search
  - Use the Binary Search for Large Arrays
- 8.4 The Selection Sort
  - General Selection Sort Technique
  - Applying the Selection Sort Technique
- 8.5 Focus on Problem Solving: A Grade Management Program
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 8.6 Running With RAPTOR (Optional)
  - The Serial Search
  - The Bubble Sort
  - The Binary Search
  - The Selection Sort
  - Run It: Soccer Camp
  - Problem Statement
  - Developing and Creating the Program
  - Check It Out
  - Revise and Improve
  - Check It Out
  - Chapter Review and Exercises
Program Modules, Subprograms, and Functions
- In the Everyday World: Living and Programming in ManageablePieces: Subprograms
- 9.1 Data Flow Diagrams, Arguments, and Parameters
  - A Big Sale: The Sale Price Computation Program
  - Data Flow Diagrams
  - An Introduction to Arguments and Parameters
- 9.2 More about Subprograms
  - Value and Reference Parameters
  - How to Tell the Difference between Value and Reference
  - Parameters
  - Two Helpful Functions: ToUpper() and ToLower()
  - The Scope of a Variable
- 9.3 Functions
  - Built-in Functions
  - User-Defined Functions
- 9.4 Recursion
  - The Recursive Process
- 9.5 Focus on Problem Solving: A Fitness Plan
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 9.6 Running With RAPTOR (Optional)
  - RAPTOR Built-In Functions (Procedures)
  - Creating a New Procedure
  - Run It: The Fitness Plan
  - Problem Statement
  - Developing and Creating the Program
  - Check It Out
  - Chapter Review and Exercises
Sequential Data Files
- In the Everyday World: Keeping it On File
- 10.1 An Introduction to Data Files
  - File Basics
  - Creating and Reading Sequential Files
- 10.2 Modifying a Sequential File
  - Deleting Records
  - Modifying Records
  - Inserting Records
  - Using Arrays in File Maintenance
- 10.3 Merging Sequential Files
- 10.4 Focus on Problem Solving: Control Break Processing
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Coding and Testing the Program
- 10.5 Focus on Problem Solving: The Invoice Preparation Program
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 10.6 Running With RAPTOR: (Optional)
  - Creating Data Files with the Redirect_Output() Procedure
  - Displaying Data Files with the Redirect_Input() Procedure
  - The Limitations
  - Run It: Professor Weisheit’s Semester Grades
  - Check It Out
  - Chapter Review and Exercises
Object-Oriented and Event-Driven Programming
- In the Everyday World: Objects are Everywhere
- 11.1 Classes and Objects
  - Classes
  - Defining Classes and Creating Objects
  - Creating Objects
  - The Constructor
- 11.2 More Features of Object-Oriented Programming
  - Benefits of Object-Oriented Languages
  - Inheritance and Polymorphism
- 11.3 Object-Oriented Program Design and Modeling
  - Modeling Languages
  - Unified Modeling Language (UML)
- 11.4 Graphical User Interfaces and Event-Driven
  - Programming
  - Window Components
  - Creating GUI Objects in a Program
  - Event-Driven Programming
  - Handling Events
  - Event-Driven Program Design
- 11.5 Focus on Problem Solving: Another Grade Management
  - Program
  - Problem Statement
  - Problem Analysis
  - Program Design
  - Program Code
  - Program Test
- 11.6 Running With RAPTOR (Optional)
  - Object-Oriented Mode
  - Creating a Class
  - The main Program
  - Inheritance and Polymorphism
  - Run It: Monster Evasion
  - Problem Statement
  - Developing and Creating the Program
  - The main program
  - Using the Classes
  - Check It Out
  - Chapter Review and Exercises

Appendix A:

A Study Skills
A.1 Achieving Success in the Course
A.2 Using the Textbook
A.3 Doing the Homework
A.4 Writing Programs
A.5 Preparing for Tests
A.6 More about Preparing for Tests
A.7 Taking Tests
A.8 Overcoming Test Anxiety

Appendix B:

The ASCII Character Set: Printable Characters

Appendix C:

Answers to Self Checks

Index

Stewart Venit received a PhD in mathematics from the University of California, Berkeley in 1971. For the past two decades, he has taught mathematics at California State University in Los Angeles. Professor Venit is a past department Chair and recipient of the University’s Outstanding Professor Award. He has authored numerous journal articles and ten textbooks for mathematics or computer science.
Elizabeth Drake has worked full time as a professor in the ITE and Math Departments at Santa Fe CC since 1999. Before that, she was an adjunct professor and lecturer in Math, Computer Science, Physics, and Anthropology at SFC, UF, Three Rivers Community College in Connecticut, and the University of Connecticut. She has earned Master's degrees in Anthropology (A.B.D.) and Counseling, a B.S.E.E. in Electrical Engineering, a B.S. in Physics, B.A. in Sociology, and A.S. in Computer Information Technology.

Need help? Get in touch

Pearson+
All in one place. Pearson+ offers instant access to eTextbooks, videos and study tools in one intuitive interface. Students choose how they learn best with enhanced search, audio and flashcards. The Pearson+ app lets them read where life takes them, no wi-fi needed. Students can access Pearson+ through a subscription or their MyLab or Mastering course.

Privacy and cookies

By watching, you agree Pearson can share your viewership data for marketing and analytics for one year, revocable by deleting your cookies.

Video transcript (PDF | 16KB)

Pearson eTextbook: What’s on the inside just might surprise you

They say you can’t judge a book by its cover. It’s the same with your students. Meet each one right where they are with an engaging, interactive, personalized learning experience that goes beyond the textbook to fit any schedule, any budget, and any lifestyle.

Prelude to Programming, 6th edition

eTextbook

Print