Software Design for Engineers and Scientists.
Title:
Software Design for Engineers and Scientists.
Author:
Robinson, John Allen.
ISBN:
9780080474403
Personal Author:
Edition:
1st ed.
Physical Description:
1 online resource (429 pages)
Contents:
Cover -- Software Design for Engineers and Scientists -- Contents -- Preface -- Acknowledgements -- Errors -- 1 Introduction -- 1.1 Theme -- 1.2 Audience -- 1.3 Three definitions and a controversy -- 1.4 Essential software design -- 1.5 Outline of the book -- Foundations -- Software technology -- Applied software design -- Case studies -- 1.6 Presentation conventions -- 1.7 Chapter end material -- Bibliography -- 2 Fundamentals -- 2.1 Introduction -- 2.2 The nature of software -- 2.3 Software as mathematics -- 2.4 Software as literature -- 2.5 Organic software -- 2.6 Software design as engineering -- 2.7 Putting the program in its place -- 2.8 User-centred design -- 2.9 The craft of program construction -- 2.10 Programmers' programming -- 2.11 Living with ambiguity -- 2.12 Summary -- 2.13 Chapter end material -- Bibliography -- 3 The craft of software design -- 3.1 Introduction -- 3.2 Collaboration and imitation -- 3.3 Finishing -- 3.4 Tool building -- 3.5 Logbooks -- 3.6 The personal library -- 3.7 Chapter end material -- Bibliography -- 4 Beginning programming in C++ -- 4.1 Introduction -- 4.2 The programming environment -- 4.3 Program shape, output, and the basic types -- 4.4 Variables and their types -- 4.5 Conditionals and compound statements -- 4.6 Loops -- 4.7 Random numbers, timing and an arithmetic game -- 4.8 Functions -- 4.9 Arrays and C-strings -- 4.10 Program example: A dice-rolling simulation -- 4.11 Bitwise operators -- 4.12 Pointers -- 4.13 Arrays of pointers and program arguments -- 4.14 Static and global variables -- 4.15 File input and output -- 4.16 Structures -- 4.17 Pointers to structures -- 4.18 Making the program more general -- 4.19 Loading structured data -- 4.20 Memory allocation -- 4.21 typedef -- 4.22 enum -- 4.23 Mechanisms that underlie the program -- 4.24 More on the C/C++ standard library.
4.25 Chapter end material -- Bibliography -- 5 Object-oriented programming in C++ -- 5.1 The motivation for object-oriented programming -- Objects localize information -- In an object-oriented language, existing solutions can be extended powerfully -- 5.2 Glossary of terms in object-oriented programming -- Data structure -- Abstract Data Type (ADT) -- Class -- Object -- Method -- Member function -- Message -- Base types and derived types -- Inheritance -- Polymorphism -- 5.3 C++ type definition, instantiation and using objects -- Stack ADT example -- Location ADT example -- Vector ADT example -- 5.4 Overloading -- Operator overloading -- 5.5 Building a String class -- 5.6 Derived types, inheritance and polymorphism -- Locations and mountains example -- Student marks example -- 5.7 Exceptions -- 5.8 Templates -- 5.9 Streams -- 5.10 C++ and information localization -- 5.11 Chapter end material -- Bibliography -- 6 Program style and structure -- 6.1 Write fewer bugs! -- 6.2 Ten programming errors and how to avoid them -- The invalid memory access error -- The off-by-1 error -- Incorrect initialization -- Variable type errors -- Loop errors -- Incorrect code blocking -- Returning a pointer or a reference to a local variable -- Other problems with new and delete -- Inadequate checking of input data -- Different modules interpret shared items differently -- 6.3 Style for program clarity -- File structure: a commentary introduction is essential -- Explanatory structure: comment to reveal -- Visual structure: make the program pretty -- Verbal structure: make it possible to read the code aloud -- Logical structure: don't be too clever -- Replicated structure: kill the doppelgänger -- 6.4 Multifile program structure -- 6.5 A program that automatically generates a multifile structure -- 6.6 Chapter end material -- Bibliography -- 7 Data structures.
7.1 Structuring data -- 7.2 Memory usage and pointers -- 7.3 Linked lists -- 7.4 Data structures for text editing -- Arrays -- Arrays of pointers -- Linked lists -- 7.5 Array/Linked list hybrids -- Hash tables -- 7.6 Trees -- 7.7 Elementary abstract data types -- ADT Ordered List -- ADT stack -- ADT queue -- ADT priority queue -- 7.8 The ADT table - definition -- 7.9 Implementing the ADT table with an unordered array -- 7.10 Alternative implementations -- 7.11 Chapter end material -- Bibliography -- 8 Algorithms -- 8.1 Introduction -- 8.2 Searching algorithms -- Unordered linked list - sequential search -- Unordered array - sequential search -- Ordered array - binary search -- 8.3 Expressing the efficiency of an algorithm -- 8.4 Search algorithm analysis -- Unordered linked list - sequential search -- Unordered array - sequential search -- Ordered array - binary search -- 8.5 Sorting algorithms and their efficiency -- Selection sort -- Insertion sort -- Mergesort -- Quicksort -- Heapsort -- 8.6 Exploiting existing solutions -- 9 Design methodology -- 9.1 Introduction -- 9.2 Generic design methodologies -- 9.3 Reliable steps to a solution? - a sceptical interlude -- Brainstorming -- Sceptical design for designers -- 9.4 Design methodology for software -- 9.5 Design team organization -- 9.6 Documentation -- 9.7 Chapter end material -- Bibliography -- 10 Understanding the problem -- 10.1 Problems -- 10.2 The problem statement -- Examples -- Some solutions -- 10.3 Researching the problem domain -- Library research -- Getting information from the network -- 10.4 Understanding users -- 10.5 Documenting a specification -- 10.6 Chapter end material -- Bibliography -- Users and user interfaces -- 11 Researching possible solutions -- 11.1 Introduction -- 11.2 Basic analysis -- 11.3 Experiment -- Example -- 11.4 Prototyping and simulation.
11.5 Notations and languages for developing designs -- 11.6 Dataflow diagrams -- 11.7 Specifying event-driven systems -- 11.8 Table-driven finite state machines -- Example -- 11.9 Statecharts -- Basic statechart syntax -- 11.10 Using statecharts - a clock radio example -- Problem statement -- Understanding the problem domain -- Developing and specifying a solution -- 11.11 State sketches - using state diagrams to understand algorithms -- Example: binary search -- 11.12 Chapter end material -- Bibliography -- 12 Modularization -- 12.1 Introduction -- 12.2 Top-down design -- 12.3 Information hiding -- 12.4 A modularization example -- 12.5 Modularizing from a statechart -- 12.6 Object-oriented modularization -- Example -- 12.7 Documenting the modularization -- 12.8 Chapter end material -- Bibliography -- 13 Detailed design and implementation -- 13.1 Introduction -- 13.2 Implementing from a higher-level representation -- 13.3 Implementing with data structures and algorithms: rules of representation selection -- 13.4 The ADT table (again) -- A specific implementation -- Other scenarios and their implications -- 14 Testing -- 14.1 Introduction -- 14.2 Finding faults -- 14.3 Static analysis -- Code inspection -- 14.4 Dynamic testing: (deterministic) black box test -- Example 1 -- Example 2 -- 14.5 Statistical black box testing -- 14.6 White box testing -- Example -- Difficulties with white box testing -- 14.7 Final words on testing for finding faults -- 14.8 Assessing performance -- 14.9 Testing to discover -- 14.10 Release -- 14.11 Chapter end material -- Bibliography -- 15 Case study: Median filtering -- 15.1 Introduction to the case studies -- 15.2 Introduction to this chapter -- 15.3 Background -- 15.4 Why use median filtering? -- 15.5 The application -- 15.6 Approaching the problem -- 15.7 Rapid prototyping -- 15.8 Exploit existing solutions.
15.9 Finishing -- 16 Multidimensional minimization - a case study in numerical methods -- 16.1 Numerical methods -- 16.2 The problem -- Finding minima in 1D -- Finding minima in multidimensions -- 16.3 Researching possible solutions -- 16.4 Nelder-Mead Simplex Optimization -- 16.5 Understanding the method with state sketches -- 16.6 Experiment-driven development -- Basic working -- Learning from experiments -- Minimizing noisy functions -- 16.7 Program code -- 17 stable - designing a string table class -- 17.1 A perennial problem in data analysis -- Collating one type of table into another type -- Sifting and computing -- 17.2 Design approach -- 17.3 Rapid prototyping a framework -- 17.4 A quick fix -- 17.5 Reading and writing -- 17.6 Finding things -- 17.7 Matching the requirements -- 17.8 Generalizing stable to do more -- 17.9 Size flexibility -- 17.10 Yet more generality: using templates to store other types in stable -- 17.11 A final program before refactoring -- 17.12 Refactoring -- Appendix: Comparison of algorithms for standard median filtering -- Index -- A -- B -- C -- D -- E -- F -- G -- H -- I -- J -- K -- L -- M -- N -- O -- P -- Q -- R -- S -- T -- U -- V -- W -- Y.
Abstract:
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 book's 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.
Local Note:
Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2017. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.
Genre:
Electronic Access:
Click to View