Programming Logic And Design

by Farrell, Joyce

• ISBN13: 9781418836337
• ISBN10: 1418836338
• Edition: 4th
• Format: Paperback
• Copyright: 2006-01-24
• Publisher: Cengage Learning Ptr

Summary

Programming Logic and Design, Comprehensive, Fourth Edition provides the beginning programmer with a guide to developing structured program logic.

Table of Contents

Preface	xi
An Overview of Computers and Logic	1	(38)
Understanding Computer Components and Operations	2	(4)
Understanding the Programming Process	6	(5)
Understanding the Problem	6	(1)
Planning the Logic	7	(1)
Coding the Program	7	(1)
Using Software to Translate the Program into Machine Language	8	(1)
Testing the Program	9	(1)
Putting the Program into Production	10	(1)
Understanding the Data Hierarchy	11	(1)
Using Flowchart Symbols and Pseudocode Statements	12	(5)
Using and Naming Variables	17	(2)
Ending a Program by Using Sentinel Values	19	(2)
Using the Connector	21	(1)
Assigning Values to Variables	22	(2)
Understanding Data Types	24	(2)
Understanding the Evolution of Programming Techniques	26	(2)
Chapter Summary	28	(1)
Key Terms	28	(3)
Review Questions	31	(3)
Find The Bugs	34	(1)
Exercises	35	(3)
Detective Work	38	(1)
Up For Discussion	38	(1)
Understanding Structure	39	(42)
Understanding Unstructured Spaghetti Code	40	(2)
Understanding the Three Basic Structures	42	(7)
Using the Priming Read	49	(6)
Understanding the Reasons for Structure	55	(3)
Recognizing Structure	58	(7)
Three Special Structures---Case, Do While, and Do Until	65	(6)
The Case Structure	65	(2)
The Do-While and Do-Until Loops	67	(4)
Chapter Summary	71	(1)
Key Terms	71	(1)
Review Questions	72	(3)
Find The Bugs	75	(1)
Exercises	76	(4)
Detective Work	80	(1)
Up for Discussion	80	(1)
Modules, Hierarchy Charts, and Documentation	81	(36)
Modules, Subroutines, Procedures, Functions, or Methods	82	(3)
Modularization Provides Abstraction	82	(1)
Modularization Allows Multiple Programmers to Work on a Problem	83	(1)
Modularization Allows You to Reuse Your Work	83	(1)
Modularization Makes it Easier to Identify Structures	84	(1)
Modularizing a Program	85	(4)
Modules Calling Other Modules	89	(1)
Declaring Variables	90	(3)
Creating Hierarchy Charts	93	(2)
Understanding Documentation	95	(1)
Output Documentation	95	(3)
Input Documentation	98	(5)
Completing the Documentation	103	(2)
Chapter Summary	105	(1)
Key Terms	105	(2)
Review Questions	107	(3)
Find The Bugs	110	(2)
Exercises	112	(4)
Detective Work	116	(1)
Up for Discussion	116	(1)
Designing And Writing a Complete Program	117	(44)
Understanding the Mainline Logical Flow Through a Program	118	(4)
Housekeeping Tasks	122	(12)
Declaring Variables	122	(6)
Opening Files	128	(1)
A One-Time-Only Task---Printing Headings	128	(1)
Reading the First Input Record	128	(1)
Checking for the End of the File	129	(5)
Writing the Main Loop	134	(3)
Performing End-Of-Job Tasks	137	(3)
Understanding the Need for Good Program Design	140	(1)
Storing Program Components in Separate Files	141	(2)
Selecting Variable and Module Names	143	(1)
Designing Clear Module Statements	144	(3)
Avoiding Confusing Line Breaks	145	(1)
Using Temporary Variables to Clarify Long Statements	145	(1)
Using Constants Where Appropriate	146	(1)
Maintaining Good Programming Habits	147	(1)
Chapter Summary	148	(1)
Key Terms	148	(1)
Review Questions	149	(4)
Find the Bugs	153	(2)
Exercises	155	(4)
Detective Work	159	(1)
Up for Discussion	159	(2)
Making Decisions	161	(60)
Evaluating Boolean Expressions to Make Comparisons	162	(2)
Using the Relational Comparison Operators	164	(4)
Understanding AND Logic	168	(10)
Writing Nested AND Decisions for Efficiency	173	(2)
Combining Decisions in an AND Selection	175	(1)
Avoiding Common Errors in an AND Selection	176	(2)
Understanding OR Logic	178	(8)
Avoiding Common Errors in an OR Selection	180	(3)
Writing OR Decisions for Efficiency	183	(2)
Combining Decisions in an OR Selection	185	(1)
Using Selections within Ranges	186	(4)
Common Errors Using Range Checks	188	(2)
Understanding Precedence When Combining AND and OR Selections	190	(3)
Understanding the Case Structure	193	(1)
Using Decision Tables	194	(8)
Chapter Summary	202	(1)
Key Terms	203	(1)
Review Questions	204	(4)
Find the Bugs	208	(5)
Exercises	213	(6)
Detective Work	219	(1)
Up for Discussion	219	(2)
Looping	221	(42)
Understanding the Advantages of Looping	222	(1)
Using a While Loop with a Loop Control Variable	222	(3)
Using a Counter to Control Looping	225	(4)
Looping with a Variable Sentinel Value	229	(2)
Looping by Decrementing	231	(1)
Avoiding Common Loop Mistakes	232	(3)
Neglecting to Initialize the Loop Control Variable	232	(1)
Neglecting to Alter the Loop Control Variable	232	(1)
Using the Wrong Comparison with the Loop Control Variable	233	(1)
Including Statements Inside the Loop that Belong Outside the Loop	233	(2)
Initializing a Variable That Does Not Require Initialization	235	(1)
Using the For Statement	235	(3)
Using the Do While and Do Until Loops	238	(3)
Recognizing the Characteristics Shared by All Loops	241	(1)
Nesting Loops	242	(5)
Using a Loop to Accumulate Totals	247	(3)
Chapter Summary	250	(1)
Key Terms	251	(1)
Review Questions	251	(5)
Find the Bugs	256	(2)
Exercises	258	(4)
Detective Work	262	(1)
Up for Discussion	262	(1)
Control Breaks	263	(48)
Understanding Control Break Logic	264	(1)
Performing a Single-Level Control Break to Start a New Page	265	(8)
Using Control Data within a Heading in a Control Break Module	273	(2)
Using Control Data within a Footer in a Control Break Module	275	(3)
Performing Control Breaks with Totals	278	(5)
Performing Multiple-Level Control Breaks	283	(7)
Performing Page Breaks	290	(6)
Chapter Summary	296	(1)
Key Terms	296	(1)
Review Questions	297	(5)
Find the Bugs	302	(3)
Exercises	305	(3)
Detective Work	308	(1)
Up for Discussion	309	(2)
Arrays	311	(50)
Understanding Arrays	312	(1)
How Arrays Occupy Computer Memory	312	(2)
Manipulating an Array to Replace Nested Decisions	314	(10)
Array Declaration and Initialization	324	(2)
Declaring and Initializing Constant Arrays	326	(4)
Loading an Array from a File	330	(1)
Searching for an Exact Match in an Array	331	(2)
Using Parallel Arrays	333	(4)
Remaining within Array Bounds	337	(2)
Improving Search Efficiency Using an Early Exit	339	(2)
Searching an Array for a Range Match	341	(4)
Chapter Summary	345	(1)
Key Terms	345	(1)
Review Questions	346	(3)
Find the Bugs	349	(5)
Exercises	354	(6)
Detective Work	360	(1)
Up for Discussion	360	(1)
Advanced Array Manipulation	361	(44)
Understanding the Need for Sorting Records	362	(1)
Understanding How to Swap Two Values	363	(1)
Using a Bubble Sort	364	(17)
Refining the Bubble Sort by Using a constant for the Array Size	371	(3)
Sorting a List of Variable Size	374	(3)
Refining the Bubble Sort by Reducing Unnecessary Comparisons	377	(2)
Refining the Bubble Sort by Eliminating Unnecessary Passes	379	(2)
Using an Insertion Sort	381	(3)
Using a Selection Sort	384	(2)
Using Indexed Files	386	(1)
Using Linked Lists	387	(2)
Using Multidimensional Arrays	389	(4)
Chapter Summary	393	(1)
Key Terms	394	(1)
Review Questions	395	(4)
Find the Bugs	399	(3)
Exercises	402	(2)
Detective Work	404	(1)
Up for Discussion	404	(1)
Using Menus and Validating Input	405	(44)
Using Interactive Programs	406	(1)
Using a Single-Level Menu	407	(4)
Coding Modules as Black Boxes	411	(5)
Making Improvements to a Menu Program	416	(5)
Using the Case Structure to Manage a Menu	421	(4)
Using Multilevel Menus	425	(7)
Validating Input	432	(2)
Understanding Types of Data Validation	434	(3)
Validating a Data Type	434	(1)
Validating a Data Range	435	(1)
Validating Reasonableness and Consistency of Data	436	(1)
Validating Presence of Data	436	(1)
Chapter Summary	437	(1)
Key Terms	438	(1)
Review Questions	439	(3)
Find the Bugs	442	(3)
Exercises	445	(3)
Detective Work	448	(1)
Up for Discussion	448	(1)
Sequential File Merging, Matching, and Updating	449	(46)
Understanding Sequential Data Files and the Need For Merging Files	450	(1)
Creating the Mainline and housekeeping () Logic for a Merge Program	451	(3)
Creating the mergeFiles() and finishUp() Modules for a Merge Program	454	(5)
Modifying the housekeeping() Module in the Merge Program to Check for eof	459	(2)
Master and Transaction File Processing	461	(1)
Matching Files to Update Fields in Master File Records	462	(6)
Allowing Multiple Transactions for a Single Master File Record	468	(2)
Updating Records in Sequential Files	470	(11)
Chapter Summary	481	(1)
Key Terms	481	(1)
Review Questions	482	(4)
Find the Bugs	486	(1)
Exercises	487	(6)
Detective Work	493	(1)
Up for Discussion	493	(2)
Advanced Modularization Techniques	495	(42)
Understanding Local and Global Variables and Encapsulation	496	(6)
Passing A Single Value to a Module	502	(7)
Passing Multiple Values to a Module	509	(3)
Returning a Value from a Module	512	(3)
Using Prewritten, Built-in Modules	515	(3)
Using an IPO Chart	518	(1)
Understanding the Advantages of Encapsulation	518	(2)
Reducing Coupling and Increasing Cohesion	520	(5)
Reducing Coupling	520	(2)
Increasing Cohesion	522	(3)
Chapter Summary	525	(1)
Key Terms	525	(2)
Review Questions	527	(3)
Find the Bugs	530	(2)
Exercises	532	(3)
Detective Work	535	(1)
Up for Discussion	535	(2)
Object-Oriented Programming	537	(32)
An Overview of Object-Oriented Programming	538	(3)
Objects and Classes	539	(1)
Methods	539	(1)
Inheritance	540	(1)
Encapsulation	540	(1)
Defining Classes and Creating Class Diagrams	541	(3)
Understanding Public and Private Access	544	(2)
Instantiating and Using Objects	546	(1)
Understanding Inheritance	547	(4)
Understanding Polymorphism	551	(1)
Understanding Protected Access	552	(1)
Understanding the Role of the this Reference	553	(2)
Using Constructors and Destructors	555	(1)
One Example of Using Predefined Classes: Creating GUI Objects	556	(1)
Understanding the Advantages of Object-Oriented Programming	557	(1)
Chapter Summary	558	(1)
Key Terms	559	(2)
Review Questions	561	(3)
Find the Bugs	564	(2)
Exercises	566	(2)
Detective Work	568	(1)
Up for Discussion	568	(1)
Event-Driven Programming with Graphical User Interfaces	569	(30)
Understanding Event-Driven Programming	570	(1)
User-Initiated Actions and GUI Components	571	(2)
Designing Graphical User Interfaces	573	(2)
The Interface Should be Natural and Predictable	573	(1)
The Screen Design Should Be Attractive and User-Friendly	574	(1)
It's Helpful If The User Can Customize Your Applications	575	(1)
The Program Should Be Forgiving	575	(1)
The GUI Is Only a Means To an End	575	(1)
Modifying The Attributes Of GUI Components	575	(1)
The Steps to Developing an Event-Driven Application	576	(4)
Understanding The Problem	577	(1)
Creating Storyboards	577	(1)
Defining the Objects In An Object Dictionary	578	(1)
Defining the Connections Between the User Screens	578	(1)
Planning the Logic	579	(1)
Understanding The Disadvantages of Traditional Error-Handling Techniques	580	(3)
Understanding the Advantages of Object-Oriented Exception Handling	583	(5)
Chapter Summary	588	(1)
Key Terms	589	(1)
Review Questions	590	(3)
Find the Bugs	593	(2)
Exercises	595	(2)
Detective Work	597	(1)
Up for Discussion	597	(2)
System Modeling With the UML	599	(30)
Understanding the Need for System Modeling	600	(1)
What Is UML?	601	(2)
Using Use Case Diagrams	603	(5)
Using Class and Object Diagrams	608	(4)
Using Sequence and Communication Diagrams	612	(2)
Using State Machine Diagrams	614	(1)
Using Activity Diagrams	615	(3)
Using Component and Deployment Diagrams	618	(2)
Diagramming Exception Handling	620	(1)
Deciding Which UML Diagrams to Use	621	(1)
Chapter Summary	622	(1)
Key Terms	623	(1)
Review Questions	624	(3)
Find the Bugs	627	(1)
Exercises	627	(1)
Detective Work	628	(1)
Up for Discussion	628	(1)
Using Relational Databases	629
Understanding relational Database Fundamentals	630	(2)
Creating Databases and Table Descriptions	632	(7)
Identifying Primary Keys	634	(2)
Understanding Database Structure Notation	636	(1)
Adding, Deleting, and Updating Records within Tables	636	(1)
Sorting the Records in a Table	637	(1)
Creating Queries	637	(2)
Understanding Table Relationships	639	(6)
Understanding One-to-Many Relationships	640	(1)
Understanding Many-to-Many Relationships	641	(4)
Understanding One-to-One Relationships	645	(1)
Recognizing Poor Table Design	645	(2)
Understanding Anomalies, Normal Forms, and the Normalization Process	647	(8)
First Normal Form	648	(2)
Second Normal Form	650	(2)
Third Normal Form	652	(3)
Database Performance and Security Issues	655	(2)
Providing Data Integrity	655	(1)
Recovering Lost Data	655	(1)
Avoiding Concurrent Update Problems	656	(1)
Providing Authentication and Permissions	656	(1)
Providing Encryption	656	(1)
Chapter Summary	657	(1)
Key Terms	658	(3)
Review Questions	661	(4)
Find the Bugs	665	(1)
Exercises	666	(4)
Detective Work	670	(1)
Up for Discussion	671
Appendix A Solving Difficult Structuring Problems	1	(1)
Appendix B Understanding Numbering Systems and Computer Codes	1	(1)
Appendix C Using a Large Decision Table	1	(1)
Glossary	1	(1)
Index	1