Chapter 1, Programming versus Software Engineering, discusses the differences between programming (merely writing code), and software engineering—the discipline, mindset, and ramifications of them.
Chapter 2, The Software Development Life Cycle, examines a detailed software development life cycle, with particular attention to the inputs, needs, and outcomes that relate to software engineering.
Chapter 3, System Modeling, explores different ways of modeling and diagramming functional, data-flow, and interprocess-communication aspects of systems and their components, and what information those provide with respect to software engineering.
Chapter 4, Methodologies, Paradigms, and Practices, delves into current process methodologies, including a few Agile process variants, looking at the advantages and drawbacks to each, before reviewing object-oriented programming (OOP) and functional programming paradigms.
Chapter 5, The hms_sys System Project, introduces the concepts behind the example project used through the book to exercise software engineering design and development mindsets.
Chapter 6, Development Tools and Best Practices, investigates some of the more common (or at least readily available) development tools—both for writing code and for managing it in ways that reduce ongoing development efforts and risks.
Chapter 7, Setting up Projects and Processes, walks through an example structure that could be used for any Python project or system, and the thought processes behind establishing a common starting-point that is compatible with source control management, automated testing, and repeatable build and deployment processes.
Chapter 8, Creating the Business Objects, starts the first iteration of the hms_sys project, defining core library business-object data structures and capabilities.
Chapter 9, Testing the Business Objects, closes the first iteration of the hms_sys project after designing, defining, and executing repeatable automated testing of the business object code defined during the iteration.
Chapter 10, Thinking about Business Object Data Persistence, examines the common need for data persistence in applications, some of the more common mechanisms, and criteria for selecting a "best match" data-storage solution for a variety of implementation requirements.
Chapter 11, Data Persistence and BaseDataObject, starts the second iteration of the hms_sys project with the design and implementation of a common, abstract data-access strategy that can be re-used across any of the project's components.
Chapter 12, Persisting Object Data to Files, continues the second iteration's efforts with a concrete implementation of the abstract Data Access Layer (DAL), which persists business-object data into local files.
Chapter 13, Persisting Data to a Database, implements a concrete DAL that stores and retrieves data from a commonly used NoSQL database—MongoDB—and compares that approach with the requirements of an equivalent SQL-based DAL.
Chapter 14, Testing Data Persistence, concludes the second iteration of the hms_sys project by implementing automated tests against the varied implementations of both DAL strategies built during the iteration.
Chapter 15, Anatomy of a Service, analyzes the common functional requirements for free-standing services, and works through the construction of abstract service/daemon classes, which are reusable for creating a variety of concrete service implementations.
Chapter 16, The Artisan Gateway Service, starts the third iteration of the hms_sys project with an analysis of the communication needs of the system components, several options for implementing those communications, securing them, and finally working them into the concrete implementation of the core service for the project.
Chapter 17, Handling Service Transactions, considers all of the necessary business-object communications between hms_sys components, extracts some common functionality for all of them, and walks through the processes required to implement them.
Chapter 18, Testing and Deploying Services, wraps up the hms_sys development in the book, and investigates and resolves some common automated-testing concerns for service/daemon applications.
Chapter 19, Multi-Processing and HPC in Python, walks through the theory and basic practices involved in writing Python code that can scale to multiple processors on a single machine, or to multiple machines in a clustered-computing environment, and provides starting-point code-structure variations for executing Python code on common high-performance computing systems.