Rating:
Author: Martin Reddy
ISBN : B004NNUZ6O
New from $14.92
Format: PDF
Download file now Free API Design for C++ [Kindle Edition] from with Mediafire Link Download Link
The design of application programming interfaces can affect the behavior, capabilities, stability, and ease of use of end-user applications. With this book, you will learn how to design a good API for large-scale long-term projects. With extensive C++ code to illustrate each concept, API Design for C++ covers all of the strategies of world-class API development. Martin Reddy draws on over fifteen years of experience in the software industry to offer in-depth discussions of interface design, documentation, testing, and the advanced topics of scripting and plug-in extensibility. Throughout, he focuses on various API styles and patterns that will allow you to produce elegant and durable libraries.
- The only book that teaches the strategies of C++ API development, including design, versioning, documentation, testing, scripting, and extensibility.
- Extensive code examples illustrate each concept, with fully functional examples and working source code for experimentation available online.
- Covers various API styles and patterns with a focus on practical and efficient designs for large-scale long-term projects.
Books with free ebook downloads available Free API Design for C++ [Kindle Edition]
- File Size: 2699 KB
- Print Length: 472 pages
- Publisher: Morgan Kaufmann; 1 edition (March 14, 2011)
- Sold by: Amazon Digital Services, Inc.
- Language: English
- ASIN: B004NNUZ6O
- Text-to-Speech: Enabled
X-Ray:
- Lending: Not Enabled
- Amazon Best Sellers Rank: #295,914 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
Free API Design for C++
First, the summary: This is an outstanding book which covers a very large range of topics very effectively. Don't be fooled by the title - even though APIs are covered very thoroughly, the book contains a great deal of wisdom beyond the API (at least by my definition of "API") - it discusses the design and implementation of well-encapsulated software components, performance, design patterns, effective use of the C++ programming language, and much more. Important topics that are often overlooked by other books, such as documentation, testing, versioning and scripting, are also covered. The book is extremely well written, and the typesetting and layout of the book is very well done. The book never loses sight of the motivation for a solid API - the winners are your clients and your business.
Usually when I think of an API, I think of the interface to a library / component. You know, function prototypes, class documentation, maybe some man pages or background documentation. All of that material is covered in great depth, but what the book is really about is *everything* that goes into designing and implementing software components / libraries properly. When writing a library, only the API is exposed to the user, and this is where a lot of the hard work is. Deciding what needs to be exposed, and how it should be exposed, is often not easy. As the author states, you can always change the underlying implementation, but you really need to think through the API before unleashing your API on the world. That's why it's so important to "get it right the first time" - changes afterwards can be tremendously costly. This book will help you get it right the first time.
My job is maintaining and expanding a large cross-platform desktop application which was originally written in 1986 by highly intelligent but inexperienced developers, and whose code is also used for browser plugins. If only I could have sent back in time this book! My life would be easy. I wouldn't have spent years of my life getting the basics of maintainability in place, simple things like using accessor methods, but also more subtle concepts like the importance of decoupling objects and techniques to decouple. This book is nominally about putting together APIs, but along the way it encourages and demands the programmer choose the most maintainable, robust and professionally rigorous techniques in order to reach the goal of an easy to use, hard to screw up, predictable and stable external API.
I want to emphasize the importance of such software traits as modularity, implementation hiding, and decoupling in any large project, in my own case I see years of what the book calls "software debt" accumulating and coming due with a vengeance. If robust techniques are not mandated and enforced every day of the release cycle eventually the codebase will become daunting to modify or fix. Such techniques given in the book as factory methods, the observer/broadcaster pattern, and such off the shelf technologies like Boost to ease implementation of these techniques are just what you have to use in order to keep sane and keep your cash cow alive.
Not that I don't have quibbles with certain techniques. I'm no fan of the PIMPL pattern and prefer to solve the same problem of implementation hiding with virtual base class interfaces and class factory methods. But then again, I don't write libraries, I write applications and plugins, so I will defer to Mr.