CART

(0) items

Programming Logic and Design: Comprehensive,9780619216917
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:
3rd
ISBN13:

9780619216917

ISBN10:
0619216913
Format:
Paperback
Pub. Date:
8/11/2004
Publisher(s):
Course Technology

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

This new edition provides the beginning programmer with a guide to developing structured program logic, assumes no programming experience and does not focus on any particular language.

Table of Contents

Preface xi
An Overview of Computers and Logic
1(34)
Understanding Computer Components and Operations
2(3)
Understanding the Programming Process
5(5)
Understand the Problem
6(1)
Plan the Logic
6(1)
Code the Program
7(1)
Translate the Program into Machine Language
7(1)
Test the Program
8(1)
Put the Program into Production
9(1)
Understanding the Data Hierarchy
10(2)
Using Flowchart Symbols and Pseudocode Statements
12(4)
Using and Naming Variables
16(2)
Ending a Program by Using Sentinel Values
18(2)
Using the Connector
20(1)
Assigning Values to Variables
21(1)
Understanding Data Types
22(2)
Understanding the Evolution of Programming Techniques
24(2)
Chapter Summary
26(1)
Key Terms
26(3)
Review Questions
29(3)
Exercises
32(3)
Understanding Structure
35(38)
Understanding Unstructured Spaghetti Code
36(1)
Understanding the Three Basic Structures
37(7)
Using the Priming Read
44(6)
Understanding the Reasons for Structure
50(2)
Recognizing Structure
52(7)
Two Special Structures---Case and Do Until
59(5)
The Case Structure
59(1)
The Do Until Loop
60(4)
Chapter Summary
64(1)
Key Terms
64(1)
Review Questions
65(3)
Exercises
68(5)
Modules, Hierarchy Charts, and Documentation
73(40)
Modules, Subroutines, Procedures, Functions, or Methods
74(3)
Modularization Provides Abstraction
74(1)
Modularization Allows Multiple Programmers to Work on a Problem
75(1)
Modularization Allows You to Reuse Your Work
75(1)
Modularization Makes it Easier to Identify Structures
76(1)
Modularizing a Program
77(4)
Modules Calling Other Modules
81(1)
Declaring Variables
82(2)
Creating Hierarchy Charts
84(2)
Understanding Documentation
86(1)
Output Documentation
87(7)
Input Documentation
94(5)
Completing the Documentation
99(2)
Chapter Summary
101(1)
Key Terms
101(2)
Review Questions
103(3)
Exercises
106(7)
Writing and Designing a Complete Program
113(36)
Understanding the Mainline Logical Flow Through a Program
114(4)
Housekeeping Tasks
118(11)
Declaring Variables
118(5)
Opening Files
123(1)
A One-Time-Only Task---Printing Headings
124(1)
Reading the First Input Record
124(5)
Writing the Main Loop
129(3)
Performing End-Of-Job Tasks
132(2)
Understanding the Need for Good Program Design
134(1)
Storing Program Components in Separate Files
135(2)
Selecting Variable and Module Names
137(1)
Designing Clear Module Statements
138(2)
Avoiding Confusing Line Breaks
138(1)
Using Temporary Variables to Clarify Long Statements
139(1)
Using Constants Where Appropriate
139(1)
Maintaining Good Programming Habits
140(1)
Chapter Summary
141(1)
Key Terms
141(1)
Review Questions
142(3)
Exercises
145(4)
Making Decisions
149(54)
Evaluating Boolean Expressions to Make Comparisons
150(2)
Using the Logical Comparison Operators
152(4)
Understanding AND Logic
156(10)
Writing Nested AND Decisions for Efficiency
161(2)
Combining Decisions in an AND Selection
163(1)
Avoiding Common Errors in an AND Selection
164(2)
Understanding OR Logic
166(8)
Avoiding Common Errors in an OR Selection
167(3)
Writing OR Decisions for Efficiency
170(2)
Combining Decisions in an OR Selection
172(2)
Using Selections within Ranges
174(4)
Common Errors Using Range Checks
176(2)
Understanding Precedence When Combining AND and OR Selections
178(2)
Understanding the Case Structure
180(2)
Using Decision Tables
182(8)
Chapter Summary
190(1)
Key Terms
191(1)
Review Questions
192(4)
Exercises
196(7)
Looping
203(42)
Understanding the Advantages of Looping
204(1)
Using a While Loop with a Loop Control Variable
204(3)
Using a Counter to Control Looping
207(4)
Looping with a Variable Sentinel Value
211(2)
Looping by Decrementing
213(1)
Avoiding Common Loop Mistakes
214(3)
Neglecting to Initialize the Loop Control Variable
214(1)
Neglecting to After the Loop Control Variable
214(1)
Using the Wrong Comparison with the Loop Control Variable
215(1)
Including Statements Inside the Loop that Belong Outside the Loop
215(1)
Initializing a Variable That Does Not Require Initialization
216(1)
Using the For Loop
217(2)
Using the Do Until Loop
219(4)
Recognizing the Characteristics Shared by All Loops
223(1)
Nesting Loops
224(6)
Using a Loop to Accumulate Totals
230(3)
Chapter Summary
233(1)
Key Terms
233(1)
Review Questions
234(5)
Exercises
239(6)
Control Breaks
245(40)
Understanding Control Break Logic
246(1)
Performing a Single-Level Control Break to Start a New Page
246(6)
Using Control Data within a Heading in a Control Break Module
252(2)
Using Control Data within a Footer in a Control Break Module
254(2)
Performing Control Breaks with Totals
256(5)
Performing Multiple-Level Control Breaks
261(6)
Performing Page Breaks
267(6)
Chapter Summary
273(1)
Key Terms
274(1)
Review Questions
275(5)
Exercises
280(5)
Arrays
285(44)
Understanding Arrays
286(1)
How Arrays Occupy Computer Memory
286(1)
Manipulating an Array to Replace Nested Decisions
287(10)
Array Declaration and Initialization
297(2)
Run-Time and Compile-Time Arrays
299(3)
Loading an Array from a File
302(2)
Searching for an Exact Match in an Array
304(2)
Using Parallel Arrays
306(4)
Remaining within Array Bounds
310(2)
Improving Search Efficiency Using an Early Exit
312(2)
Searching an Array for a Range Match
314(4)
Chapter Summary
318(1)
Key Terms
318(1)
Review Questions
319(4)
Exercises
323(6)
Advanced Array Manipulation
329(42)
Understanding the Need for Sorting Records
330(1)
Understanding How to Swap Two Values
331(1)
Using a Bubble Sort
332(17)
Refining the Bubble Sort by Using a Variable for the Array Size
339(3)
Sorting a List of Variable Size
342(3)
Refining the Bubble Sort by Reducing Unnecessary Comparisons
345(2)
Refining the Bubble Sort by Eliminating Unnecessary Passes
347(2)
Using an Insertion Sort
349(2)
Using a Selection Sort
351(2)
Using Indexed Files
353(1)
Using Linked Lists
354(2)
Using Multidimensional Arrays
356(6)
Chapter Summary
362(1)
Key Terms
362(1)
Review Questions
363(4)
Exercises
367(4)
Using Menus and Validating Input
371(40)
Using Interactive Programs
372(1)
Using a Single-Level Menu
373(4)
Coding Modules as Black Boxes
377(5)
Making Improvements to a Menu Program
382(5)
Using the Case Structure to Manage a Menu
387(3)
Using Multilevel Menus
390(7)
Validating Input
397(2)
Understanding Types of Data Validation
399(3)
Validating a Data Type
399(1)
Validating a Data Range
400(1)
Validating Reasonableness and Consistency of Data
400(1)
Validating Presence of Data
401(1)
Chapter Summary
402(1)
Key Terms
403(1)
Review Questions
404(3)
Exercises
407(4)
Sequential File Merging, Matching, and Updating
411(42)
Understanding Sequential Data Files and the Need for Merging Files
412(1)
Creating the Mainline and housekeeping() Logic for a Merge Program
413(3)
Creating the MainLoop() and finishUp() Modules for a Merge Program
416(5)
Modifying the housekeeping() Module in the Merge Program to Check for eof
421(2)
Master and Transaction File Processing
423(1)
Matching Files to Update Fields in Master File Records
424(6)
Allowing Multiple Transactions for a Single Master File Record
430(1)
Updating Records in Sequential Files
431(11)
Chapter Summary
442(1)
Key Terms
443(1)
Review Questions
443(4)
Exercises
447(6)
Advanced Modularization Techniques
453(38)
Understanding Local and Global Variables and Encapsulation
454(6)
Passing a Single Value to a Module
460(6)
Passing Multiple Values to a Module
466(3)
Returning a Value from a Module
469(3)
Using Prewritten, Built-in Modules
472(2)
Using an IPO Chart
474(1)
Understanding the Advantages of Encapsulation
475(1)
Reducing Coupling and Increasing Cohesion
476(6)
Reducing Coupling
477(2)
Increasing Cohesion
479(3)
Chapter Summary
482(1)
Key Terms
482(2)
Review Questions
484(3)
Exercises
487(4)
Object-Oriented Programming
491(26)
An Overview of Object-Oriented Programming
492(1)
Defining Classes
493(4)
Instantiating and Using Objects
497(1)
Understanding Inheritance
498(3)
Understanding Polymorphism
501(3)
Understanding Constructor and Destructor Methods
504(3)
Using Predefined Classes to Create GUI Objects
507(1)
The Advantages of Object-Oriented Programming
508(1)
Chapter Summary
509(1)
Key Terms
509(2)
Review Questions
511(3)
Exercises
514(3)
Event-Driven Programming with Graphical User Interfaces
517(24)
Understanding Event-Driven Programming
518(1)
User-Initiated Actions and GUI Components
519(2)
Designing Graphical User Interfaces
521(2)
The Interface Should Be Natural and Predictable
521(1)
The Screen Design Should Be Attractive and User-Friendly
522(1)
It's Helpful If the User Can Customize Your Applications
522(1)
The Program Should Be Forgiving
523(1)
The GUI Is Only a Means to an End
523(1)
Modifying the Attributes of GUI Components
523(1)
The Steps to Developing an Event-Driven Application
524(4)
Understanding the Problem
524(1)
Creating Storyboards
525(1)
Defining the Objects in an Object Dictionary
525(1)
Defining the Connections Between the User Screens
526(1)
Planning the Logic
527(1)
Object-Oriented Error Handling: Throwing Exceptions
528(6)
Chapter Summary
534(1)
Key Terms
534(1)
Review Questions
535(3)
Exercises
538(3)
System Modeling with UML
541(26)
Understanding the Need for System Modeling
542(1)
What Is UML?
542(2)
Using Use Case Diagrams
544(5)
Using Class and Object Diagrams
549(4)
Using Sequence and Collaboration Diagrams
553(2)
Using Statechart Diagrams
555(1)
Using Activity Diagrams
556(1)
Using Component and Deployment Diagrams
557(2)
Deciding Which UML Diagrams to Use
559(1)
Chapter Summary
560(1)
Key Terms
561(1)
Review Questions
562(3)
Exercises
565(2)
Using Relational Databases
567
Understanding Relational Database Fundamentals
568(2)
Creating Databases and Table Descriptions
570(6)
Identifying Primary Keys
571(2)
Understanding Database Structure Notation
573(1)
Adding, Deleting, and Updating Records within Tables
573(1)
Sorting the Records in a Table
574(1)
Creating Queries
574(2)
Understanding Table Relationships
576(6)
Understanding One-to-Many Relationships
577(1)
Understanding Many-to-Many Relationships
578(4)
Understanding One-to-One Relationships
582(1)
Recognizing Poor Table Design
582(2)
Understanding Anomalies, Normal Forms, and the Normalization Process
584(7)
First Normal Form
585(1)
Second Normal Form
586(2)
Third Normal Form
588(3)
Database Performance and Security Issues
591(2)
Providing Data Integrity
591(1)
Recovering Lost Data
591(1)
Avoiding Concurrent Update Problems
592(1)
Providing Authentication and Permissions
592(1)
Providing Encryption
592(1)
Chapter Summary
593(1)
Key Terms
594(2)
Review Questions
596(4)
Exercises
600
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...