or
Sign in to turn on 1-Click ordering.
Trade in Yours
For a 8.50 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Colour:
Image not available

 
Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Large-Scale C++ Software Design (APC) [Paperback]

John Lakos
4.7 out of 5 stars  See all reviews (18 customer reviews)
Price: 47.99 & FREE Delivery in the UK. Details
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 8 left in stock (more on the way).
Dispatched from and sold by Amazon. Gift-wrap available.
Want it Tuesday, 22 April? Choose Express delivery at checkout. Details
Trade In this Item for up to 8.50
Trade in Large-Scale C++ Software Design (APC) for an Amazon.co.uk gift card of up to 8.50, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Book Description

10 July 1996 0201633620 978-0201633627 1
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, you will also need a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. 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 interfaces while minimizing physical dependencies; the details of implementing an ANSI C compatible C++ procedural interface; and a complete specification for a suite of UNIX-like tools to extract and analyze physical dependencies. Practical design rules, guidelines, and principles are also collected in an appendix and indexed for quick reference. 0201633620B04062001

Frequently Bought Together

Large-Scale C++ Software Design (APC) + Design patterns : elements of reusable object-oriented software
Buy the selected items together


Product details

  • Paperback: 896 pages
  • Publisher: Addison Wesley; 1 edition (10 July 1996)
  • Language: English
  • ISBN-10: 0201633620
  • ISBN-13: 978-0201633627
  • Product Dimensions: 23.5 x 19 x 3.3 cm
  • Average Customer Review: 4.7 out of 5 stars  See all reviews (18 customer reviews)
  • Amazon Bestsellers Rank: 321,022 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description

From the Back Cover

Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, you will also need a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience.

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 interfaces while minimizing physical dependencies; the details of implementing an ANSI C compatible C++ procedural interface; and a complete specification for a suite of UNIX-like tools to extract and analyze physical dependencies. Practical design rules, guidelines, and principles are also collected in an appendix and indexed for quick reference.



0201633620B04062001

About the Author

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

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more


Customer Reviews

4.7 out of 5 stars
4.7 out of 5 stars
Most Helpful Customer Reviews
9 of 9 people found the following review helpful
By A Customer
Format:Paperback
Have you ever noticed that none of your introductions to C++ ever mention things like header files? This book corrects that omission with a vengeance, taking us deep into the nuts and bolts of real software. It describes things no other book is going to mention (e.g. redundant external include guards, or static nonmember functions to replace private members) and things the object-oriented community prefers to be silent about (e.g., encapsulation in files, not in classes).
Lakos's great strength is in pragmatics; this is advice on programming from someone who has been there. If your project is large enough to need source code control, it's large enough to need this book.
Sometimes the book drifts away from its roots, assuming a dragging academic tone. However, this does not change the overall rating -- a book with no substitutes.
Comment | 
Was this review helpful to you?
8 of 8 people found the following review helpful
By A Customer
Format:Paperback
The vast majority of Programming books follow the latest technology trends - new languages, new products. However a book like this, published five years ago, will be useful for as long as C++ is used for professional software development. I've suffered the pain of worked on multi-million line software projects that don't follow the techniques outlined, and I've converted a medium sized software project to follow the guidelines outlined in the book, and I can confirm that this was one of the most practical computer books I've ever read.
In fact I'd have to say it is more useful and practical than the books of C++ tricks and tips that seem so popular, but focus mainly on intricate details of the language.
Unfortunately it is a heavy read, because Lakos provides the sorts of examples and justifications that you need to "buy in" to his suggestions.
I think the length and indepth nature would intimidate people from reading it. However it is very much worth the effort!
Comment | 
Was this review helpful to you?
5 of 5 people found the following review helpful
By A Customer
Format:Paperback
I second much of what has already been said in the previous reviews. This isn't a book for beginners, and its a tough read, but it contains many items that just aren't dealt with in any other book on C++ I've read. The most important point made is that _anything_ appearing in the C++ header file is part of the physical interface, and changing it will affect clients. As with most issues in programming, there's a trade off to be made between efficiency and insulation (and/or simplicity vs. flexibility), which this book tackles well. I certainly feel more confident about sucessfully translating an OOD into a workable C++ framework after reading and ingesting this book. Highly recommended.
Comment | 
Was this review helpful to you?
3 of 3 people found the following review helpful
Format:Paperback
This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.

There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.

The last part of the book drops down to more low level concerns, such as Schwarz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.

But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.
Comment | 
Was this review helpful to you?
2 of 2 people found the following review helpful
5.0 out of 5 stars If you think you're an expert, think again. 1 Dec 1998
By A Customer
Format:Paperback
I'm a single developer of about eight years who used to go around thinking that, being alone, the systems I write will always be small, and the interfaces between packages can be casual since I own both ends. Boy was I wrong! Lakos' book is the direct answer to the most persistent problems I've had with quality, maintainability and extensibility for the last year.
Even if you're a C++ genius, I'll bet the section on how redundancy (as in duplicated code) may be desirable will teach you something you didn't realize you needed to learn. And, the extensive coverage of physical insulation shows the path away from the dark side of development that logical design texts hardly even allude to. Read this book!
Comment | 
Was this review helpful to you?
2 of 2 people found the following review helpful
5.0 out of 5 stars a 'should read' for every programmer. 28 May 1998
By A Customer
Format:Paperback
This book contains a lot of good hints for things to think about and mistakes to avoid in designing and/or coding a large software projekt. John Lakos hints are very well documented and argumented, they are not just like 'make this, do that'. I really recommend this book to everyone programming something larger than 'Hello World'. Sometimes J. Lakos tends to get a bit long winded when getting to something he thinks is important, but the book is still easy to read and very good to understand.
Comment | 
Was this review helpful to you?
Would you like to see more reviews about this item?
Were these reviews helpful?   Let us know
Most Recent Customer Reviews
4.0 out of 5 stars Must read for software architects
Lakos really rubs your nose into the fact that every change to a header file has (potentially far-reaching) consequences. Read more
Published 22 months ago by Kris Slegers
5.0 out of 5 stars Great source of information on system design
If you are serious about nontrivial C++ system design you should buy this book. I have read many books on object oriented desing, design patterns, refactoring and so on. Read more
Published on 4 Oct 2010 by D. Baas
5.0 out of 5 stars God's own C++ book
John Lakos is God, and this is His Bible.
Published on 24 Jun 1999
3.0 out of 5 stars Helpful, to a point
The book offers a lot of tips early on explaining ways to avoid keeping everything in the headers to permit changes to occur without forcing a load of code to recompile. Read more
Published on 17 Feb 1999
5.0 out of 5 stars A 'Must have" for every serious programmer
Excellent book; covers both logical and physical design, as is very well documented.In these days, when is hardly impossible to find a serious book for professionals, Lakos has... Read more
Published on 20 Jan 1999
5.0 out of 5 stars One of a kind
After flipping through the pages of this book for two minutes, I knew that a miracle had occured. I have avoided buying many pathetically simple C++ books that introduce nothing... Read more
Published on 14 Dec 1998
4.0 out of 5 stars Solid real-world advice on physically putting together code
Many programmers, even if they have been in the industry for a while, still do not realize the importance of how a system physically fits together; what header files go where;... Read more
Published on 3 Aug 1998
Search Customer Reviews
Only search this product's reviews
ARRAY(0xaa063f78)

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   


Look for similar items by category


Feedback