Software Design for Engineers and Scientists

by Robinson

• ISBN13: 9780750660808
• ISBN10: 0750660805
• Format: Paperback
• Copyright: 2004-10-01
• Publisher: Elsevier Science

Summary

Software Design for Engineers and Scientists integrates three core areas of computing: . Software engineering - including both traditional methods and the insights of 'extreme programming' . Program design - including the analysis of data structures and algorithms . Practical object-oriented programming Without assuming prior knowledge of any particular programming language, and avoiding the need for students to learn from separate, specialised Computer Science texts, John Robinson takes the reader from small-scale programing to competence in large software projects, all within one volume. Copious examples and case studies are provided in C++ and students can access complementary examples in Java on an accompanying website. The book is especially suitable for undergraduates in the natural sciences and all branches of engineering who have some knowledge of computing basics, and now need to understand and apply software design to tasks like data analysis, simulation, signal processing or visualisation. John Robinson introduces both software theory and its application to problem solving using a range of design principles, applied to the creation of medium-sized systems, providing key methods and tools for designing reliable, efficient, maintainable programs. The case studies are presented within scientific contexts to illustrate all aspects of the design process, allowing students to relate theory to real-world applications. All listings are available on this books companion website. Core computing topics - usually found in separate specialised texts - presented to meet the specific requirements of science and engineering students Demonstrates good practice through applications, case studies and worked examples based in real-world contexts Additional website resources are available, including useful links and further worked examples using Java

Table of Contents

Preface	xi
Acknowledgements	xiii
Errors	xiv
Introduction
Theme	1	(1)
Audience	2	(1)
Three definitions and a controversy	2	(1)
Essential software design	3	(1)
Outline of the book	4	(2)
Foundations	4	(1)
Software technology	5	(1)
Applied software design	5	(1)
Case studies	6	(1)
Presentation conventions	6	(1)
Chapter end material	7	(1)
Bibliography	7	(1)
Fundamentals
Introduction	8	(1)
The nature of software	8	(2)
Software as mathematics	10	(4)
Software as literature	14	(4)
Organic software	18	(5)
Software design as engineering	23	(4)
Putting the program in its place	27	(6)
User-centred design	33	(2)
The craft of program construction	35	(1)
Programmers' programming	36	(1)
Living with ambiguity	37	(1)
Summary	38	(2)
Chapter end material	40	(3)
Bibliography	40	(3)
The craft of software design
Introduction	43	(1)
Collaboration and imitation	43	(2)
Finishing	45	(1)
Tool building	45	(1)
Logbooks	46	(2)
The personal library	48	(2)
Chapter end material	50	(1)
Bibliography	50	(1)
Beginning programming in C++
Introduction	51	(1)
The programming environment	52	(2)
Program shape, output, and the basic types	54	(5)
Variables and their types	59	(3)
Conditionals and compound statements	62	(3)
Loops	65	(2)
Random numbers, timing and an arithmetic game	67	(3)
Functions	70	(4)
Arrays and C-strings	74	(4)
Program example: A dice-rolling simulation	78	(4)
Bitwise operators	82	(2)
Pointers	84	(5)
Arrays of pointers and program arguments	89	(3)
Static and global variables	92	(1)
File input and output	93	(4)
Structures	97	(3)
Pointers to structures	100	(2)
Making the program more general	102	(2)
Loading structured data	104	(1)
Memory allocation	105	(3)
typedef	108	(1)
enum	108	(1)
Mechanisms that underlie the program	109	(2)
More on the C/C ++ standard library	111	(3)
Chapter end material	114	(1)
Bibliography	114	(1)
Object-oriented programming in C++
The motivation for object-oriented programming	115	(4)
Objects localize information	115	(2)
In an object-oriented language, existing solutions can be extended powerfully	117	(2)
Glossary of terms in object-oriented programming	119	(4)
Data structure	119	(1)
Abstract Data Type (ADT)	120	(1)
Class	121	(1)
Object	121	(1)
Method	122	(1)
Member function	122	(1)
Message	122	(1)
Base types and derived types	122	(1)
Inheritance	122	(1)
Polymorphism	122	(1)
C++ type definition, instantiation and using objects	123	(9)
Stack ADT example	123	(3)
Location ADT example	126	(3)
Vector ADT example	129	(3)
Overloading	132	(6)
Operator overloading	134	(4)
Building a String class	138	(7)
Derived types, inheritance and polymorphism	145	(15)
Locations and mountains example	145	(6)
Student marks example	151	(9)
Exceptions	160	(3)
Templates	163	(3)
Streams	166	(5)
C++ and information localization	171	(1)
Chapter end material	171	(1)
Bibliography	171	(1)
Program style and structure
Write fewer bugs!	172	(1)
Ten programming errors and how to avoid them	173	(11)
The invalid memory access error	174	(1)
The off-by-1 error	175	(1)
Incorrect initialization	176	(2)
Variable type errors	178	(1)
Loop errors	178	(1)
Incorrect code blocking	179	(1)
Returning a pointer or a reference to a local variable	180	(1)
Other problems with new and delete	181	(1)
Inadequate checking of input data	181	(2)
Different modules interpret shared items differently	183	(1)
Style for program clarity	184	(3)
File structure: a commentary introduction is essential	185	(1)
Explanatory structure: comment to reveal	185	(1)
Visual structure: make the program pretty	185	(1)
Verbal structure: make it possible to read the code aloud	186	(1)
Logical structure: don't be too clever	186	(1)
Replicated structure: kill the doppelganger	187	(1)
Multifile program structure	187	(1)
A program that automatically generates a multifile structure	188	(4)
Chapter end material	192	(2)
Bibliography	192	(2)
Data structures
Structuring data	194	(1)
Memory usage and pointers	194	(2)
Linked lists	196	(1)
Data structures for text editing	197	(6)
Arrays	197	(1)
Arrays of pointers	197	(1)
Linked lists	198	(5)
Array/Linked list hybrids	203	(2)
Hash tables	204	(1)
Trees	205	(5)
Elementary abstract data types	210	(6)
ADT Ordered List	210	(1)
ADT stack	210	(1)
ADT queue	211	(2)
ADT priority queue	213	(3)
The ADT table -- definition	216	(1)
Implementing the ADT table with an unordered array	217	(3)
Alternative implementations	220	(1)
Chapter end material	221	(1)
Bibliography	221	(1)
Algorithms
Introduction	222	(1)
Searching algorithms	222	(2)
Unordered linked list -- sequential search	222	(1)
Unordered array -- sequential search	223	(1)
Ordered array -- binary search	223	(1)
Expressing the efficiency of an algorithm	224	(1)
Search algorithm analysis	225	(1)
Unordered linked list -- sequential search	225	(1)
Unordered array -- sequential search	225	(1)
Ordered array -- binary search	226	(1)
Sorting algorithms and their efficiency	226	(7)
Selection sort	227	(1)
Insertion sort	227	(2)
Mergesort	229	(1)
Quicksort	230	(2)
Heapsort	232	(1)
Exploiting existing solutions	233	(2)
Design methodology
Introduction	235	(1)
Generic design methodologies	235	(1)
Reliable steps to a solution? -- a sceptical interlude	236	(3)
Brainstorming	237	(2)
Sceptical design for designers	239	(1)
Design methodology for software	239	(1)
Design team organization	240	(1)
Documentation	241	(1)
Chapter end material	242	(2)
Bibliography	242	(2)
Understanding the problem
Problems	244	(1)
The problem statement	245	(3)
Examples	246	(2)
Some solutions	248	(1)
Researching the problem domain	248	(2)
Library research	248	(2)
Getting information from the network	250	(1)
Understanding users	250	(3)
Documenting a specification	253	(1)
Chapter end material	254	(1)
Bibliography	254	(1)
Users and user interfaces	254	(1)
Researching possible solutions
Introduction	255	(1)
Basic analysis	255	(1)
Experiment	256	(1)
Example	256	(1)
Prototyping and simulation	257	(1)
Notations and languages for developing designs	257	(1)
Dataflow diagrams	258	(1)
Specifying event-driven systems	259	(1)
Table-driven finite state machines	259	(4)
Example	262	(1)
Statecharts	263	(3)
Basic statechart syntax	264	(2)
Using statecharts -- a clock radio example	266	(2)
Problem statement	266	(1)
Understanding the problem domain	266	(1)
Developing and specifying a solution	267	(1)
State sketches -- using state diagrams to understand algorithms	268	(6)
Example: binary search	271	(3)
Chapter end material	274	(2)
Bibliography	274	(2)
Modularization
Introduction	276	(1)
Top-down design	277	(1)
Information hiding	278	(1)
A modularization example	279	(1)
Modularizing from a statechart	280	(2)
Object-oriented modularization	282	(2)
Example	282	(2)
Documenting the modularization	284	(3)
Chapter end material	287	(1)
Bibliography	287	(1)
Detailed design and implementation
Introduction	288	(1)
Implementing from a higher-level representation	288	(3)
Implementing with data structures and algorithms: rules of representation selection	291	(1)
The ADT table (again)	291	(7)
A specific implementation	292	(4)
Other scenarios and their implications	296	(2)
Testing
Introduction	298	(1)
Finding faults	298	(2)
Static analysis	300	(2)
Code inspection	301	(1)
Dynamic testing: (deterministic) black box test	302	(2)
Example 1	303	(1)
Example 2	303	(1)
Statistical black box testing	304	(1)
White box testing	305	(2)
Example	306	(1)
Difficulties with white box testing	306	(1)
Final words on testing for finding faults	307	(1)
Assessing performance	307	(1)
Testing to discover	308	(1)
Release	309	(1)
Chapter end material	309	(1)
Bibliography	309	(1)
Case study: Median filtering
Introduction to the case studies	310	(1)
Introduction to this chapter	310	(1)
Background	311	(1)
Why use median filtering?	311	(1)
The application	312	(1)
Approaching the problem	312	(1)
Rapid prototyping	313	(3)
Exploit existing solutions	316	(7)
Finishing	323	(6)
Multidimensional minimization -- a case study in numerical methods
Numerical methods	329	(2)
The problem	331	(1)
Finding minima in 1D	331	(1)
Finding minima in multidimensions	331	(1)
Researching possible solutions	332	(2)
Nelder--Mead Simplex Optimization	334	(1)
Understanding the method with state sketches	335	(2)
Experiment-driven development	337	(3)
Basic working	337	(1)
Learning from experiments	338	(1)
Minimizing noisy functions	338	(2)
Program code	340	(13)
stable -- designing a string table class
A perennial problem in data analysis	353	(1)
Collating one type of table into another type	353	(1)
Sifting and computing	353	(1)
Design approach	354	(1)
Rapid prototyping a framework	355	(4)
A quick fix	359	(1)
Reading and writing	359	(3)
Finding things	362	(2)
Matching the requirements	364	(2)
Generalizing stable to do more	366	(1)
Size flexibility	367	(1)
Yet more generality: using templates to store other types in stable	367	(1)
A final program before refactoring	367	(11)
Refactoring	378	(20)
Appendix: Comparison of algorithms for standard median filtering	398	(7)
Index	405