- Buy this product and stream 90 days of Amazon Music Unlimited for free. E-mail after purchase. Conditions apply. Learn more
Multi-Paradigm Design for C++ Paperback – 13 Oct 1998
- Choose from over 13,000 locations across the UK
- Prime members get unlimited deliveries at no additional cost
- Find your preferred location and add it to your address book
- Dispatch to this address when you check out
Special offers and product promotions
Customers who viewed this item also viewed
Customers who bought this item also bought
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Would you like to tell us about a lower price?
If you are a seller for this product, would you like to suggest updates through seller support?
Coplien offers insight into an analysis and design process that takes advantage of C++'s multiple paradigm capability, including classes, overloaded functions, templates, modules, procedural programming, and more. The book uses understandable notation and readable explanations to help all C++ programmers-not just system architects and designers-combine multiple paradigms in their application development for more effective, efficient, portable, robust, and reusable software. Multi-paradigm design digs deeper than any single technology or technique to address fundamental questions of software abstraction and design.
From the Back Cover
C++ is a programming language that supports multiple paradigms: classes, overloaded functions, templates, modules, procedural programming, and more. Despite the language's flexibility and richness, however, there has previously been little effort to create a design method that supports the use of multiple paradigms within a single application.
This book presents a coherent framework for approaching multi-paradigm design, offering an advanced set of design practices that form the foundation for a formal multi-paradigm design method.
Multi-Paradigm Design for C++ offers insight into an analysis and design process that takes advantage of C++'s multiple paradigm capability. It uses understandable notation and readable explanations to help all C++ programmers--not just system architects and designers--combine multiple paradigms in their application development for more effective, efficient, portable, robust, and reusable software.
Readers will gain an understanding of domain engineering methods that support multi-paradigm design. This book reveals how to analyze the application domain, using principles of commonality and variation, to define subdomains according to the most appropriate paradigm for each. Multi-paradigm design digs deeper than any single technology or technique to address fundamental questions of software abstraction and design.
All of the concepts and techniques that form the groundwork for domain engineering are presented. These concepts include an in-depth look at commonality and variability analysis, how domain engineering interacts with commonly used design patterns, how to find abstractions in the application domain, and how the principles of domain engineering can be used as a basis for the abstraction techniques of the object paradigm. Most important, this book discusses how to apply analysis techniques that are the most appropriate paradigm to be implemented during the design phase.
0201824671B04062001 See all Product description
Customers also shopped for
There was a problem filtering reviews right now. Please try again later.
The main message is that OO is only one of several choices when building software in C++. The author presents the following alternatives: generics, classes without virtual functions, overloaded functions and using the preprocessor. Clearly, some of these suggestions are more niche than others. Some extended examples are provided, involving a text editor/buffer, a function differentiator and a finite state machine.
The other big idea is the concept of commonality and variability analysis. The process goes along the following lines:
1. Create a domain dictionary defining all terms used in the domain.
2. Analyse the domain using experience or intuition to group the domain into subdomains of commonality.
3. For each subdomain, analyse the variabilities with respect to their common core.
4. Decide which paradigm to use, depending upon whether the variability needs to be specified at run time, compile time, etc.
I worked hard to like this book, really I did. One of the biggest problems for me is that I just can't get along with James Coplien's writing style, which reads like a stuffy academic research paper. I find it extremely ponderous and obfuscated, whole sentences flow by without imparting any meaning.
Perhaps as a by-product of my difficulties with Coplien's style, I found it hard to extract much usable content from the book. The four points I outlined above all seem entirely reasonable to me, but reading this book hasn't given me any further insight into them. It's particularly frustrating that Coplien has little to say about how to go about finding commonalities in a domain, apart from appealing to notions of experience and intuition, which is unhelpful. At least he doesn't suggest underlining nouns. There is some mention of design patterns, so if you're looking for more examples in C++, you may get some value from that.
It seems that lots of people liked this book (including the authors of the excellent Design Patterns Explained, where I first heard of it), so maybe if you find Coplien's writing style a bit more readable, you should give it a go. Personally, I got fairly low returns from it.
Most helpful customer reviews on Amazon.com
I got turned on to this book by a presentation at TechEd. According to the speaker, C# is capable of at least five different coding paradigms, only one of which is Object Oriented. In the enterprise development world, OO is viewed as the "right" way to do things, with no understanding of the tradeoffs being made by following the OO approach. Worse, object models are getting created by people that have no idea how to validate the design. What is "right" and "wrong" is decided mostly by gut feel. If you ever hear the phrase, "well, I had to do some refactoring in the classes that were inheriting from mine because the change I made broke some stuff," you know the design was bad.
When I review code, I see developers drifting in and out of the OO style, mixing in bits and pieces of Functional programming, a bit of event-driven/message-based programming, and absolutely no idea of why or how to decide which paradigm to follow in a given situation. Worse, if they know any theory at all, it's only for the OO approach. Not good when trying to use the Functional programming features in C#.
If you just thought to yourself that C# is only an OO language, then you REALLY need to read this book.
I found this book to be an excellent starting point for anyone trying to educate themselves on the appropriate use and selection of a programming paradigm. It has enough theory to get you started, and will build enough of a vocabulary to let you find more focused books.
The computer book market is flooded with how-to guides. This isn't one of them. As developers, we are pretty good at getting things done. However, that still leaves us a far cry from treating our profession as a craft, worthy of deep understanding. I suspect this may be part of the reason why 80% of software development costs occur after a product has gone to production, even in the corporate world.
Yes, this book can be hard. In fact, it can be very hard, especially for an experienced developer that is reading quickly while looking for the "how-to" bits. The book challenges you to go back to first princples, which is hardest for folks that have made a career of getting the job done and slinging code as needed. Read the book like a college text book, and it might help. Read each chapter twice. If you can get your head around it, it's worth the effort.
First off, where has this book been hiding? When I first read Coplien's Advanced C++ in 1992, it blew me away. I read and reread it like it was epic poetry (oh wait, that's because, well, it IS). Coplien is everything you want in an author: first, he is literate. Unlike junior who can only hold the book w/one hand (since they took away his pacifier, he has to use his thumb), he has clearly read and digested a LOT of stuff. Science people, too often have zero literary sensibility at all. Funny that the great scientists seemed to. Oppenheimer read in several languages and quoted the Baghavad Gita, Greek scholars, and was into poetry. Anyway, Coplien can also claim to have been, to borrow the Dean Acheson phrase 'Present at the Creation' (though, lucky for Cope, he was there and took part in the birthing of the most important software dev movement in the last 25 years, while Acheson helped cement the modern police state). Finally (on this front), this book is not only readable, it reads like the wind. And believe me, friends, I was almost suckered into believing the whiney tail of my hero's demise.
Now, here are a few more things I'd like to say about this book:
1. I have been reading a lot about PLE lately, and this book plugs into this so well, it's bizarre. For instance, this book takes some serious time to talk about how to do variability analysis, but also discusses things like the mapping of domain variability requirements to language features, the various codifying tools that enable substitution, but also substitution w/variation (e.g. parameterization, virtualization, etc.), but then, in a bonus turn on this vector, he talks about how this meshes with patterns, showing for instance how cases of negative variability (where the deriver wants to erase part of the base) can be refactored to Bridge, etc.
2. Don't get too thrown by the multi-paradigm angle the title implies: this book is not just a screed espousing the use of functional sideshoots, or procedural deviations.
In summary, this is a great book and I can't believe I did not know it existed until recently. If you are doing product oriented development especially, and variation at more than just the simplest level is a daily demand, this is one of the best wells to visit.
This book is not about C++ per se. It is about the design process for C++ programmer. The language choice of C++ is simply because C++ supports all the paradigms in question.
I would further comment that this book is quite hard to read. A quick browse possibly won't get you anywhere. There doesn't seem to be any logic behind the flow of the book. This is why I said that you have to know the material already to feel entertained by it.
However, the concept that the book talks about is very important that I think every good programmer should be aware of.
The other complaint I have is that if you've already read that much about C++, then you have to wade through a lot of stuff that you've already figured out just to dig up the dozen or so nuggets of new insight. (Admittedly, I'm prejudiced against dissecting methodology, so you might take this view with a grain of salt.)
This book isn't bad, but for the average C++ programmer there's probably a lot of fruit out there that hangs lower than this one. "Design Patterns" (Gamma), "The C++ Programming Language" (Stroustrup), "Exceptional C++" (Sutter) and "The C++ Standard Library" (Josuttis) come to mind.