Software Design for Engineers and Scientists

Software Design for Engineers and Scientists

by John Allen Robinson
Released October 2004
Publisher(s): Newnes
ISBN: 9780080474403

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

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

Table of contents

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

Product information

  • Title: Software Design for Engineers and Scientists
  • Author(s): John Allen Robinson
  • Release date: October 2004
  • Publisher(s): Newnes
  • ISBN: 9780080474403