Programming and Problem Solving With Ada 95

by Dale, Nell; Weems, Chip; McCormick, John W.

• ISBN13: 9780763707927
• ISBN10: 0763707929
• Edition: 2nd
• Format: Paperback
• Copyright: 2000-03-16
• Publisher: Jones & Bartlett Learning

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