CART

(0) items

Programming Logic And Design: Comprehensive,9781418836337
This item qualifies for
FREE SHIPPING!

FREE SHIPPING OVER $59!

Your order must be $59 or more, you must select US Postal Service Shipping as your shipping preference, and the "Group my items into as few shipments as possible" option when you place your order.

Bulk sales, PO's, Marketplace Items, eBooks, Apparel, and DVDs not included.

Programming Logic And Design: Comprehensive

by
Edition:
4th
ISBN13:

9781418836337

ISBN10:
1418836338
Format:
Paperback
Pub. Date:
1/24/2006
Publisher(s):
Cengage Learning Ptr
List Price: $184.95

eBook


 
Duration
Price
$56.39

Rent Book

We're Sorry
Sold Out

Used Book

We're Sorry
Sold Out

New Book

We're Sorry
Sold Out

More New and Used
from Private Sellers
Starting at $0.01

Related Products


  • A Guide to Programming Logic and Design: Comprehensive
    A Guide to Programming Logic and Design: Comprehensive
  • C++ Programs to Accompany Programming Logic and Design
    C++ Programs to Accompany Programming Logic and Design
  • C++ Programs to Accompany Programming Logic and Design
    C++ Programs to Accompany Programming Logic and Design
  • Guide to Programming Logic and Design : Comprehensive
    Guide to Programming Logic and Design : Comprehensive
  • Pkg Program Logic Design Compre Pac Video Prog Logic Design
    Pkg Program Logic Design Compre Pac Video Prog Logic Design
  • Programming Logic and Design : Comprehensive
    Programming Logic and Design : Comprehensive
  • Programming Logic and Design Comprehensive (Book Only)
    Programming Logic and Design Comprehensive (Book Only)
  • Programming Logic and Design, Comprehensive
    Programming Logic and Design, Comprehensive
  • Programming Logic and Design, Comprehensive
    Programming Logic and Design, Comprehensive
  • Programming Logic and Design, Comprehensive
    Programming Logic and Design, Comprehensive
  • Programming Logic and Design, Comprehensive
    Programming Logic and Design, Comprehensive
  • Programming Logic and Design: Comprehensive
    Programming Logic and Design: Comprehensive
  • Programming Logic and Design: Comprehensive, 6th Edition
    Programming Logic and Design: Comprehensive, 6th Edition




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


Please wait while the item is added to your cart...