Programming and Problem Solving With Ada 95,9780763707927

Programming and Problem Solving With Ada 95

by ; ;
Edition: 2nd
ISBN13: 9780763707927
ISBN10: 0763707929
Format: Paperback
Pub. Date: 2000-03-16
Publisher(s): Jones & Bartlett Learning
List Price: $160.95

Buy New

Usually Ships in 8 - 10 Business Days.
$160.79
Add to Cart

Rent Textbook

Select for Price
Add to Cart
There was a problem. Please try again later.

Used Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

Buy from our Marketplace starting at $7.06

How Marketplace Works:

  • This item is offered by an independent seller and not shipped from our warehouse
  • Item details like edition and cover design may differ from our description; see seller's comments before ordering.
  • Sellers much confirm and ship within two business days; otherwise, the order will be cancelled and refunded.
  • Marketplace purchases cannot be returned to eCampus.com. Contact the seller directly for inquiries; if no response within two days, contact customer service.
  • Additional shipping costs apply to Marketplace purchases. Review shipping costs at checkout.

Summary

Programming and Problem Solving with Ada 95 provides a solid introduction to programming while introducing the capabilities of Ada 95 and its syntax without overwhelming the student. The book focuses on the development of good programming habits. This text offers superior pedagogy that has long defined computer science education, including problem solving case studies, testing and debugging sections, quick checks, exam preparation, programming warm-up exercises, and programming problems. The extensive coverage of material in such a student-friendly resource means that more rigor, more theory, greater use of abstraction and modeling, And The earlier application of software engineering principles can be employed. Download the student files

Table of Contents

Preface xxi
Acknowledgments xxix
Overview of Programming and Problem Solving
1(46)
Overview of Programming
2(7)
What Is Programming?
2(1)
What Is a Computer?
3(6)
Background Information: Mainframes, Micros, and Minis
9(9)
How Do We Write a Program?
13(5)
Theoretical Foundations: Data Representation
18(5)
What Is a Programming Language?
19(4)
Problem-Solving Techniques
23(7)
Ask Questions
25(1)
Look for Things That Are Familiar
25(1)
Solve by Analogy
26(1)
Means-Ends Analysis
27(1)
Divide and Conquer
27(1)
The Building-Block Approach
28(1)
Merging Solutions
29(1)
How to Start
29(1)
Algorithmic Problem Solving
30(1)
Software Engineering
30(5)
Programming at Many Scales
31(2)
The Ada Programming Language
33(2)
Background Information: The Origins of Ada
35(2)
Problem-Solving Case Study: A Company Payroll
37(5)
Summary
42(5)
Quick Check
43(1)
Answers
44(1)
Exam Preparation Exercises
44(2)
Programming Warm-up Exercises
46(1)
Ada Syntax, Semantics, and the Program Development Process
47(70)
The Elements of Ada Programs
48(5)
Syntax and Semantics
48(3)
Identifiers
51(2)
Matters of Style: Using Meaningful, Readable Identifiers
53(1)
Data Types
53(1)
Background Information: Data Storage
54(6)
Declarations
57(3)
Software Engineering Tip: Using Constants
60(12)
Executable Statements
62(6)
Output: Packages and Procedures
68(3)
Commenting a Program
71(1)
Background Information: Ada Lovelace
72(2)
Program Construction
74(2)
Program Entry, Correction, and Execution
76(3)
Entering a Program
76(1)
Compiling and Running a Program
77(1)
Debugging
78(1)
Software Engineering Tip: Understanding Before Changing
79(1)
More About Expressions
79(5)
Precedence Rules
80(3)
Static Expressions
83(1)
Type Conversions
83(1)
Background Information: Strongly Typed Languages
84(1)
Formatting Output
85(4)
Line Spaces and Blanks
85(1)
Integer Numbers
86(1)
Float Numbers
87(2)
Matters of Style: Program Layout
89(1)
The Use Package Clause
90(4)
Problem-Solving Case Study: Mileage
94(3)
Problem-Solving Case Study: Filling Down Comforters
97(4)
Testing and Debugging
101(1)
Testing and Debugging Hints
102(1)
Summary
102(15)
Quick Check
103(2)
Answers
105(1)
Exam Preparation Exercises
106(5)
Programming Warm-up Exercises
111(3)
Programming Problems
114(3)
Input and Design Methodology
117(52)
Getting Data into Programs
118(6)
Input of Numeric Data
118(3)
Input of String Data
121(3)
Theoretical Foundations: More About Procedures and Parameters
124(19)
String Slices
125(4)
Input of Mixed Data Types
129(9)
File Input/Output
138(5)
Background Information: Charles Babbage
143(2)
Programming Methodology
145(8)
Top-Down Design
145(7)
Object-Oriented Design
152(1)
Software Engineering Tip: Documentation
153(1)
Problem-Solving Case Study: Mixing Proportions
154(5)
Testing and Debugging
159(2)
Testing and Debugging Hints
160(1)
Summary
161(8)
Quick Check
162(1)
Answers
162(1)
Exam Preparation Exercises
162(2)
Programming Warm-up Exercises
164(2)
Programming Problems
166(3)
Boolean and Enumeration Types, Conditions, and Selection Control Structures
169(62)
Conditions and Boolean Expressions
170(6)
Boolean Expressions
170(6)
Background Information: George Boole
176(2)
Precedence of Operators
177(1)
Software Engineering Tip: Changing English Statements into Boolean Expressions
178(1)
Flow of Control
179(1)
Selection
180(1)
The if Statement
180(4)
The if-then-else Form
181(2)
The if-then Form
183(1)
Nested if Statements
184(5)
The if-elsif Form
186(3)
Enumeration Data Types
189(5)
Accurate Modeling
189(3)
Input and Output of Enumeration Types
192(2)
Problem-Solving Case Study: The Lumberyard
194(7)
Problem-Solving Case Study: Ski Wax Selection
201(8)
Temperature Guidelines (used to select a wax group)
202(7)
Testing and Debugging
209(10)
The Problem-Solving Phase: The Algorithm Trace
209(2)
The Implementation Phase
211(7)
Testing and Debugging Hints
218(1)
Summary
219(12)
Quick Check
219(1)
Answers
220(1)
Exam Preparation Exercises
220(6)
Programming Warm-up Exercises
226(1)
Programming Problems
227(4)
Looping
231(50)
Loop and Exit Statements
232(3)
Phases of Loop Execution
235(1)
Loop Design Patterns
235(10)
Count-Controlled Loops
236(2)
Event-Controlled Loops
238(4)
Looping Subtasks
242(3)
How to Design Loops
245(7)
Designing the Flow of Control
246(2)
Designing the Process Within the Loop
248(1)
The Loop Exit
249(1)
Commenting Loops
250(2)
Nested Logic
252(2)
Designing Nested Loops
254(1)
Theoretical Foundations: The Magnitude of Work
254(3)
Problem-Solving Case Study: Average Income by Gender
257(7)
Problem-Solving Case Study: High and Low Temperatures
264(5)
Testing and Debugging
269(1)
Loop Testing Strategy
269(1)
Testing and Debugging Hints
270(1)
Summary
270(11)
Quick Check
272(1)
Answers
272(1)
Exam Preparation Exercises
273(4)
Programming Warm-up Exercises
277(1)
Programming Problems
278(3)
Subprograms
281(96)
Program Design with Procedures
282(2)
When to Use Procedures
282(1)
Writing Modules as Procedures
283(1)
Procedure Construction
284(13)
Procedure Syntax
286(1)
Parameters
286(4)
Procedure Placement
290(5)
Flow of Control in Procedure Calls
295(2)
Matters of Style: Naming and Formatting Procedures
297(1)
Procedure Options
297(4)
Local Variables
297(1)
Named and Positional Parameter Association
298(3)
Designing Procedures
301(2)
Nesting
303(13)
Declarative Regions
304(2)
Scope Rules
306(8)
Avoiding Use of Global Variables Through Declaration Order
314(1)
Designing Programs with Nesting
315(1)
Overloading Subprogram Names
316(3)
Function Subprograms
319(7)
Boolean Functions
322(1)
Operator Functions
323(1)
When to Use Functions
324(1)
Standard Mathematical Functions
325(1)
Problem-Solving Case Study: Running Records
326(10)
Software Engineering Tip: Control Abstraction, Functional Cohesion, and Communication Complexity
336(2)
Problem-Solving Case Study: Starship Weight and Balance
338(13)
Testing and Debugging
351(5)
Stubs and Drivers
352(3)
Testing and Debugging Hints
355(1)
Summary
356(21)
Quick Check
357(1)
Answers
358(1)
Exam Preparation Exercises
359(10)
Programming Warm-up Exercises
369(3)
Programming Problems
372(5)
Types and Subtypes
377(62)
Data Types
378(5)
Attributes
379(4)
Character Data Type
383(8)
Character Input/Output
384(1)
Working with Characters as a Discrete Type
385(2)
Wide Characters
387(1)
Qualified Expressions
387(1)
Operations with String and Character Types
388(3)
Programmer-Defined Scalar Data Types
391(13)
Floating-Point Type Declarations
393(4)
Integer Type Declarations
397(1)
Decimal Type Declarations
397(3)
Input and Output
400(1)
Combining Different Types
401(3)
Theoretical Foundations: Type Coercion and Conversion
404(1)
Subtypes
405(6)
Programmer-Defined Subtypes
405(3)
Predefined Subtypes
408(1)
Membership Operators
408(1)
Subtypes and Parameters
409(1)
Input and Output of Subtypes
410(1)
Named and Anonymous String Types
411(1)
Types or Subtypes?
412(1)
When to Use Subtypes
412(1)
When to Use Types
412(1)
Software Engineering Tip: Program Portability
413(1)
Universal Types
413(2)
Named Numbers
414(1)
Matters of Style: Declarative Part Style
415(1)
Problem-Solving Case Study: The Rich Uncle
415(8)
Specification
415(8)
Problem-Solving Case Study: Currency Conversions
423(7)
Specification
423(7)
Testing and Debugging
430(1)
Testing and Debugging Hints
431(1)
Summary
431(8)
Quick Check
432(1)
Answers
433(1)
Exam Preparation Exercises
433(2)
Programming Warm-up Exercises
435(2)
Programming Problems
437(2)
Additional Control Structures
439(38)
The Case Statement
440(5)
When to Use the Case Statement
443(1)
The Null Statement
444(1)
The For Statement
445(6)
The Loop Parameter
448(1)
Loop Parameter Type
449(2)
Matters of Style: Loop Names
451(2)
The While Loop
452(1)
Guidelines for Choosing a Looping Statement
453(1)
Problem-Solving Case Study: Solitaire Scoring
454(8)
Specification
454(8)
Testing and Debugging
462(5)
The Loop Invariant
462(2)
Loop Testing Strategy
464(2)
Testing and Debugging Hints
466(1)
Summary
467(10)
Quick Check
467(1)
Answers
468(1)
Exam Preparation Exercises
468(3)
Programming Warm-up Exercises
471(2)
Programming Problems
473(4)
The File Data Type and Handling Exceptions
477(62)
Files
478(2)
Text Files
479(1)
Logical Layout of a Text File
The End_Of_Line and End_Of_File Functions
480(5)
Additional Text File Operations
485(3)
Background Information: Admiral Grace Murray Hopper
488(9)
Binary Files
489(8)
Exception Handling
497(13)
Exceptions and Block Statements
499(5)
Exceptions and Subprograms
504(1)
Propagation of Exceptions
505(5)
Matters of Style: Exceptions For Exceptional Situations
510(2)
Package Calendar
512(3)
Problem-Solving Case Study: The Pasta House
515(12)
Testing and Debugging
527(2)
Summary
529(10)
Quick Check
529(1)
Answers
530(1)
Exam Preparation Exercises
530(5)
Programming Warm-up Exercises
535(1)
Programming Problems
536(3)
Records
539(48)
Record Types
540(11)
Operations on Entire Records
544(4)
Default Initial Values
548(1)
Record Aggregates
549(2)
Files of Records
551(2)
Hierarchical Records
553(6)
Hierarchical Record Aggregates
558(1)
Data Structures
559(3)
Style Considerations in Choice of Data Structures
559(3)
Problem-Solving Case Study: Department Store Accounts
562(10)
Testing and Debugging
572(3)
Testing and Debugging Hints
575(1)
Summary
575(12)
Quick Check
575(1)
Answers
576(1)
Exam Preparation Exercises
577(4)
Programming Warm-up Exercises
581(3)
Programming Problems
584(3)
Arrays
587(98)
One-Dimensional Arrays
588(31)
Defining Arrays
591(1)
Accessing Individual Components
592(1)
Accessing an Entire Array at Once
593(2)
Array Aggregates
595(3)
Examples of Defining and Accessing Arrays
598(9)
Processing Arrays
607(3)
Unconstrained Array Types
610(7)
Other Array Operations
617(2)
Two-Dimensional Arrays
619(17)
Defining and Accessing Two-Dimensional Arrays
620(4)
Processing Two-Dimensional Arrays
624(7)
Arrays of Arrays
631(3)
Unconstrained Two-Dimensional Array Types
634(1)
Array Attributes
635(1)
Multidimensional Arrays
636(3)
Software Engineering Tip: Choosing a Data Structure
639(1)
Problem-Solving Case Study: Frequency of Characters
640(6)
Problem-Solving Case Study: Mustard Yields
646(4)
Problem-Solving Case Study: City Council Election
650(8)
Testing and Debugging
658(2)
Testing and Debugging Hints
660(1)
Summary
660(25)
Quick Check
661(2)
Answers
663(2)
Exam Preparation Exercises
665(9)
Programming Warm-up Exercises
674(3)
Programming Problems
677(8)
Packages, Searching, and Sorting
685(84)
An Overview of Packages
686(4)
Child Packages
688(1)
Package Syntax
689(1)
Kinds of Packages
690(9)
Definition Packages
690(2)
Service Packages
692(5)
Data Abstraction Packages
697(2)
Compilation of Programs and Packages
699(6)
The Program Library
700(1)
Order of Compilation
701(4)
Background Information: Reusable Components and Software Repositories
705(1)
The Use Clause
706(5)
The Use Package Clause
707(1)
The Use Type Clause
708(3)
The Predefined Package Standard
711(1)
Searching and Sorting
712(20)
Sequential Search in an Unordered List
713(5)
Selection Sort
718(4)
Sequential Search in an Ordered List
722(2)
Inserting into an Ordered List
724(2)
Insertion Sort
726(2)
Binary Search in an Ordered List
728(4)
Theoretical Foundations: Complexity of Searching and Sorting
732(7)
Package List_Ops
734(5)
Problem-Solving Case Study: A Data Abstraction Package for Vectors
739(6)
Problem-Solving Case Study: Exam Attendance
745(11)
Testing and Debugging
756(2)
Testing and Debugging Hints
758(1)
Summary
758(11)
Quick Check
759(2)
Answers
761(1)
Exam Preparation Exercises
761(3)
Programming Warm-up Exercises
764(1)
Programming Problems
764(5)
Recursion
769
What Is Recursion?
770(7)
Recursive Algorithms with Simple Variables
777(12)
Fibonacci Numbers
779(4)
Towers of Hanoi
783(6)
Recursive Algorithms with Array Variables
789(6)
Sequential Search
792(1)
Binary Search
793(2)
Recursion or Iteration?
795(1)
Problem-Solving Case Study: Converting Decimal Integers to Binary Integers
796(4)
Problem-Solving Case Study: Minimum Value in an Integer Array
800(2)
Testing and Debugging
802(1)
Testing and Debugging Hints
802(1)
Summary
803
Quick Check
803(1)
Answers
804(1)
Exam Preparation Exercises
804(3)
Programming Warm-up Exercises
807(3)
Programming Problems
810
Appendices A1
Glossary A59
Answers to Selected Exercises A75
Index A95

An electronic version of this book is available through VitalSource.

This book is viewable on PC, Mac, iPhone, iPad, iPod Touch, and most smartphones.

By purchasing, you will be able to view this book online, as well as download it, for the chosen number of days.

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.

A downloadable version of this book is available through the eCampus Reader or compatible Adobe readers.

Applications are available on iOS, Android, PC, Mac, and Windows Mobile platforms.

Please view the compatibility matrix prior to purchase.