Large-scale C++ software design / John Lakos.
By: Lakos, John
.
Material type: ![materialTypeLabel](/opac-tmpl/lib/famfamfam/BK.png)
![](/opac-tmpl/bootstrap/images/filefind.png)
Item type | Current library | Call number | Copy number | Status | Date due | Barcode | Item holds |
---|---|---|---|---|---|---|---|
General Lending | MTU Bishopstown Library Lending | 005.133 LAK (Browse shelf(Opens below)) | 1 | Available | 00112907 |
Browsing MTU Bishopstown Library shelves, Shelving location: Lending Close shelf browser (Hides shelf browser)
|
|
|
|
|
|
|
||
005.133 KRU Data structures and program design in C / | 005.133 KRU Data structures and program design in C / | 005.133 LAF Advanced Java : idioms, pitfalls, styles, and programming tips / | 005.133 LAK Large-scale C++ software design / | 005.133 LAN A primer on scientific programming with Python / | 005.133 LEE The apprentice C++ programmer : a touch of class / | 005.133 LEE Begining perl / |
Enhanced descriptions from Syndetics:
This is the definitive book for all C++ software professionals involved in large development efforts such as databases, operating systems, compilers, and frameworks. It is the first C++ book that actually demonstrates how to design large systems, and one of the few books on object-oriented design specifically geared to practical aspects of the C++ programming language. In this book, Lakos explains the process of decomposing large systems into physical (not inheritance) hierarchies of smaller, more manageable components. Such systems with their acyclic physical dependencies are fundamentally easier and more economical to maintain, test, and reuse than tightly interdependent systems. In addition to explaining the motivation for following good physical as well as logical design practices, Lakos provides you with a catalog of specific techniques designed to eliminate cyclic, compile-time, and link-time (physical) dependencies. He then extends these concepts from large to very large systems. The book concludes with a comprehensive top-down approach to the logical design of individual components. Appendices include a valuable design pattern Protocol Hierarchy designed to avoid fat inte
Bibliography: (pages 833-834) and index.
Introduction -- Part I: Basics -- Preliminaries -- Ground rules -- Part II: Physical design concepts -- Components -- Physical hierarchy -- Levelization -- Insulation -- Packages -- Part III: Logical Design Issues -- Architecting a component -- Designing a function -- Implementing an object.
Table of contents provided by Syndetics
- Preface
- 0 Introduction
- From C to C++
- Using C++ to Develop Large Projects
- Reuse
- Quality
- Software Development Tools
- Summary
- I Basics
- 1 Preliminaries
- Multi-File C++ Programs
- Typedef Declarations
- Assert Statements
- A Few Matters of Style
- Iterators
- Logical Design Notation
- Inheritance versus Layering
- Minimality
- Summary
- 2 Ground Rules
- Overview
- Member Data Access
- The Global Name Space
- Include Guards
- Redundant Include Guards
- Documentation
- Identifier-Naming Conventions
- Summary
- II Physical Design Concepts
- 3 Components
- Components versus Classes
- Physical Design Rules
- The Depends on Relation
- Implied Dependency
- Extracting Actual Dependencies
- Friendship
- Summary
- 4 Physical Hierarchy
- A Metaphor for Software Testing
- A Complex Subsystem
- The Difficulty in Testing "Good" Interfaces
- Design for Testability
- Testing in Isolation
- Acyclic Physical Dependencies
- Level Numbers
- Hierarchical and Incremental Testing
- Testing a Complex Subsystem
- Testing versus Tested
- Cyclic Physical Dependencies
- Cumulative Component Dependency (CCD)
- Physical Design Quality
- Summary
- 5 Levelization
- Some Causes of Cyclic Physical Dependencies
- Escalation
- Demotion
- Opaque Pointers
- Dumb Data
- Redundancy
- Callbacks
- Manager Class
- Factoring
- Escalating Encapsulation
- Summary
- 6 Insulation
- From Encapsulation to Insulation
- C++ Constructs and Compile-Time Coupling
- Partial Insulation Techniques
- Total Insulation Techniques
- The Procedural Interface
- To Insulate or Not to Insulate
- Summary
- 7 Packages
- From Components to Packages
- Registered Package Prefixes
- Package Levelization
- Package Insulation
- Package Groups
- The Release Process
- The main Program
- Start-Up Time
- Summary
- III Logical Design Issues
- 8 Architecting a Component
- Abstractions and Components
- Component Interface Design
- Degrees of Encapsulation
- Auxiliary Implementation Classes
- Summary
- 9 Designing a Function
- Function Specification
- Fundamental Types Used in the Interface
- Special Case Functions
- Summary
- 10 Implementing an Object
- Member Data
- Function Definitions
- Memory Management
- Using C++ Templates in Large Projects
- Summary
- Appendix A Protocol Hierarchy
- Appendix B Implementing an ANSI C-Compatible C++ Interface
- Appendix C A Dependency Extractor/Analyzer Package
- Appendix D Quick Reference
- Index
Excerpt provided by Syndetics
Author notes provided by Syndetics
John Lakos works at Mentor Graphics, a company that has written more large scale C++ programs than most other software companies and was among the first companies to attempt truly large-scale C++ projects. Lakos has been programming professionally in C++ since 1987, and in 1990 developed Columbia University's graduate course in object-oriented programming which he continues to teach.
0201633620AB04062001