API Design for C++ und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr


oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
oder
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an.
Jetzt eintauschen
und EUR 11,69 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Beginnen Sie mit dem Lesen von API Design for C++ auf Ihrem Kindle in weniger als einer Minute.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

API Design for C++ [Englisch] [Taschenbuch]

Martin Reddy
4.0 von 5 Sternen  Alle Rezensionen anzeigen (4 Kundenrezensionen)
Preis: EUR 37,18 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
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
Auf Lager.
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Donnerstag, 2. Oktober: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 30,08  
Taschenbuch EUR 37,18  

Kurzbeschreibung

14. März 2011
Though the design of interfaces can affect the behavior, capabilities, stability, and ease of use of end-user applications, the techniques of API design are rarely taught. Instead, programmers most often gain these skills through experienceby making mistakes and learning empirically what does and does not work. API Design for C++ is the first and only book that distills the strategies for designing a good API, with a focus on large-scale long-term projects. Extensive C++ code accompanies each concept, illustrating the qualities that make a good API. Martin Reddy draws on over fifteen years of experience at Pixar and Linden Lab to offer in-depth discussions of documentation, testing, and the advanced topics of scripting and plug-in extensibility. Throughout, he focuses on various API styles and patterns that will allow programmers to produce interfaces that are easy to use and last for the long term.

Wird oft zusammen gekauft

API Design for C++ + The C++ Standard Library: A Tutorial and Reference + C++ Concurrency in Action
Preis für alle drei: EUR 131,08

Die ausgewählten Artikel zusammen kaufen

Kunden, die diesen Artikel gekauft haben, kauften auch


Produktinformation

  • Taschenbuch: 472 Seiten
  • Verlag: Academic Press (14. März 2011)
  • Sprache: Englisch
  • ISBN-10: 0123850037
  • ISBN-13: 978-0123850034
  • Größe und/oder Gewicht: 23,4 x 18,8 x 3 cm
  • Durchschnittliche Kundenbewertung: 4.0 von 5 Sternen  Alle Rezensionen anzeigen (4 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 37.554 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Pressestimmen

Martin Reddy draws from his experience on large scale, collaborative software projects to present patterns and practices that provide real value to individual developers as well as organizations. API Design for C++ explores often overlooked issues, both technical and non- technical, contributing to successful design decisions that produce high quality, robust, and long-lived APIs. - Eric Gregory, Software Architect, Pixar Animation Studios "Intended for programmers with intermediate to advanced skills in the C++ programming language, this guide to the building of useful and robust application programming interfaces (APIs) provides practical instruction for software engineers developing systems on which downstream software engineers depend. The work provides a methodical approach to API design covering solution based API design, performance, versioning, documentation, testing, scripting, extensibility and libraries. The work includes numerous illustrations and code examples and access to additional online resources is provided. Reddy is a software development consultant."--Book News, Reference & Research

Über den Autor und weitere Mitwirkende

Dr. Martin Reddy is the founder and CEO of the software consultancy firm Code Reddy Inc. He holds a Ph.D. in Computer Science and has over 15 years of experience in the software industry. During this time, he has written 3 software patents and has published over 40 professional articles and a book on 3D computer graphics. Dr. Reddy worked for 6 years at Pixar Animation Studios where he was lead engineer for the studio's in-house animation system. This work involved the design and implementation of various APIs to support several Academy Award-winning and nominated films, such as "Finding Nemo", "The Incredibles", "Cars", "Ratatouille", and "Wall-E." Dr. Reddy currently works for Linden Lab on the Second Life Viewer, an online 3D virtual world that has been used by over 16 million users around the world. His work is currently focused on a radical redesign of the Second Life Viewer, putting in place a suite of robust APIs to enable extensibility and scriptability.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Hier reinlesen und suchen:

Kundenrezensionen

4.0 von 5 Sternen
4.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Tolles Buch 20. Mai 2013
Format:Kindle Edition|Verifizierter Kauf
Das Buch ist wirklich sehr gut. Mir gefällt (im Gegensatz zu meinem Vorredner) die Mischung mit verschiednen Gebieten wie z.B. Scripting sehr gut da es die verschiedene Sichtweisen einer API gut wiederspiegelt.
Für Einsteiger und Fortgeschrittene empfehlenswert, da es einen sehr guten Überblick über die Thematik schafft.

Kindle-Edition ist gut lesbar. Die Code-Teile springen zwar manchmal ein bisschen durch die Gegend - stört aber meiner Meinung nach nicht so stark.
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen Bin begeistert 27. Dezember 2013
Format:Taschenbuch|Verifizierter Kauf
Habe mir das Buch vor einigen Monaten gekauft und zum großen Teil bereits durchgelesen.

Bisher bin ich zwar nicht auf eine Welt-Neuheit an Wissen/Erkenntnis gestoßen, aber ich wurde an viele Kleinigkeiten erinnert die man meistens ohne zu überlegen macht. In dem Buch werden schöne und verständliche Beispiele aufgeführt wie man eine API bauen sollte und was man besser weglassen sollte - obwohl es technisch möglich ist. Das Thema des Buches lässt sich in weiten Teilen auf das Thema "Einheitlichkeit" zusammenfassen. Aber es gibt in dem Zusammenhang soviel was man zu beachten hat (Einheitliche Benutzung, Namensgebung, Ablauf etc.) und in dem Buch werden die meisten der Punkte mit guten Beispielen erklärt.

Ich wollte wissen wie man eine wartbare, lesbare und einheitliche API baut und das Buch hat mir aufjeden Fall sehr gut geholfen. Einige der Ratschläge muss ich erst in der Praxis ausprobieren und kann man sagen wie es sich anfühlt. Das Buch ist auf jeden Fall zu empfehlen und hat meine Erwartungen an ein C++-Buch mit diesem Thema übertroffen.
War diese Rezension für Sie hilfreich?
3 von 6 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Erste Schritte im API Design mit C++ 7. Juli 2012
Format:Taschenbuch
Das Buch ist eine hervorragende Einführung in die Implementierung von APIs mit C++. Die Stellen, an denen sich der Autor tatsächlich mit API-Design bzw. Implementierung befasst sind hervorragend und 5 Sterne wert.

Aber: Thematisch grenzt das Thema "API Design" an verschiedene Bereiche der Software-Entwicklung, wie z.B. Entwurfsmuster, Anforderungsanalyse, Architektur, Performance-Optimierung, Dokumentation, Test-Driven-Development und Scripting.

Leider hat hier der Autor den Weg gewählt diese Themen ebenfalls in diesem Buch zu behandeln. Daher kommt das API Design zu kurz und die Einführungen in z. B. das Test-Driven-Development sind nicht ausführlich genug, um damit schon sicher arbeiten zu können, so dass man hier auf weitere Literatur angewiesen ist.

Völlig unverständlich für mich ist es, ein Kapitel über die Anbindung von Python und Ruby im Umfang von 30 Seiten in das Buch aufzunehmen.

Es ist also ein gutes Buch für Einsteiger, die C++ verwenden. Wer sich mit den Fallstricken von C++ allerdings bereits auskennt, z. B. Templates oder boost::shared_ptr regelmäßig benutzt und schon das ein oder andere Buch über "Do's and Don'ts" in C++ gelesen hat, sollte vorher genau prüfen, ob sich die Anschaffung des Buches lohnt.
War diese Rezension für Sie hilfreich?
2 von 21 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Kindle Edtion nicht gut 29. Dezember 2011
Format:Kindle Edition
Hier ist wieder das Problem mit dem Code und die Kommentare die durcheinander gehen! Die UML Diagramme sind auch nicht gut lesbar!

Ich werde die Taschenbuch Version bestellen!
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.7 von 5 Sternen  36 Rezensionen
34 von 36 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A good overview of how to write good C++ code 7. März 2011
Von M. Wilson - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
A good book, but I don't think an experienced C++ programmer would find anything too surprising in it. It IS a very good tutorial for newer programmers, or someone coming from Java API design. The author does a nice job of explaining a lot of what has been discussed in Meyers' and Sutter's book; none of the lengthy set up and quizzing, he just explains it and shows the reader why it is important. He concisely explains things like Liskov, Open-Closed, etc., the PIMPL idiom, and creation patterns, and gives some good advice on how to version your API, and control development in a source control system. It's basically a pretty complete look at the whole process of writing an API.
37 von 40 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A must-have for serious C++ software developers 4. August 2011
Von D. Smith - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
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.

In my work, I spend a lot of my time re-factoring software components & their interfaces to make them less fragile, more re-usable, more testable, and easier to use correctly. This book taught me a couple new tricks that will help me do that better. And no doubt, in the rare case where I actually get to create a library/API from scratch, I'll also do a better job going forward. (If enough people buy this book, I might have to start looking a lot harder for clients!)

You can browse the Table of Contents yourself to see the range of topics covered - it's broad. There isn't a weak chapter in the book. I don't think I found a single technical mistake or inaccuracy in the book. The code examples are small, concise, illustrative and clean. The writing is stellar. Rather than just dictate a bunch of rules, the author provides the rationale for the suggestions. The author also cites references and sources for further reading throughout the book.

Another nice aspect of the book is how the author's real-world experience on very large & complex development projects shines through when discussing certain topics. The information in the book has been obtained by lots of hard work, and seeing what works and what doesn't.

I liked the book's treatment of C++-specific features that can contribute to writing a good API. Language features such as templates, namespaces, inheritance and const correctness are discussed very effectively. Even features in the upcoming C++0x (or whatever it's called these days) standard, at least those that can help improve your API, are covered too.

The book reads very well. Anyone who's opened Stroustrup's "The C++ Programming Language" knows that poor typesetting can have a large negative impact of the book's readability. This book is just the opposite. The fonts are clean, code is well-formatted, tips are called out in highlight boxes, and diagrams are clear and uncluttered. Boldface, bullet items and numbered lists are used effectively to guide the reader's eyes throughout the reading. To me, this is very important - I've come across several books that appeared to be nothing more than Word documents printed out & bound. The content is well-organized and the topics flow well. It never feels like something was just "shoehorned" into a chapter because there was no better place to put it.

The bottom line: if you're writing C++ (or even C) code for other people to use, you need this book.
11 von 12 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Great Book on Writing Maintainable C++ 20. Dezember 2011
Von Glenn R. Howes - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Vine Kundenrezension eines kostenfreien Produkts (Was ist das?)
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. Reddy's judgement for when it comes to libraries.

There is a very clear chapter on various topics in using the C++ language such as best practices for using templates. Now, I avoid templates (other than using STL and boost) like the plague; I don't like the syntax, and I don't come across many interesting cases where I need to share methods amongst different data types, so yes, I'm not a generic style programmer, but I will admit that the template techniques as the author puts them forward seem clear and useful enough, including the Curiously Recurring Template Pattern which he tucks into the last pages of the last chapter.

The book has interesting chapters on such topics as adding scripting interfaces in either Python or Ruby. Once it's all lain out, it almost seems simple to create one, especially if you are using pre-existing frameworks like Boost or Swig to do the heavy lifting. There is an Appendix devoted to library packaging technologies which would have been useful to know back in the day.

So my recommendation is that if you are a C++ programmer and you want to improve yourself, to learn from a master, and be able to call yourself a professional coder, then you need to read this book. It is the best technical book I've read in years and I've recommended it to everyone on my team.
6 von 6 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen outstanding -- one of the best programming books I've read 17. November 2012
Von William Sommerwerck - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Vine Kundenrezension eines kostenfreien Produkts (Was ist das?)
Anyone who's read my reviews of technical books knows the low esteem I hold them in. Most are terrible -- poorly organized, badly written, and (/if/ edited), edited by someone who knows next to nothing about the subject matter. To find one that is merely "good" produces a brief flash of joy. To read a superb one -- as "API design for C++" is -- is a cause for elation.

When I first opened the book, my thumb fell propitiously on the first page of of Chapter 9, "Documentation" -- "Well-written documentation is ... a critical element of your API." My heavens -- a programmer who understands that documentation is as important as the product itself, a component that's a necessary, irreplaceable part of the product, absolutely critical to understanding and using it.

The rest of the book did not disappoint.

Reddy goes into great detail about the rules of writing APIs -- one of the most-important is the need to keep /everything/ hidden from other classes and calls, and the developers who use the API. There are plenty of other rules (which Reddy explains well and justifies by referring to other experts), but their goal is to produce bug-free code that is easily maintained, without the need to continually rewrite it so that it doesn't break existing applications. Reddy emphasizes that, although good design sometimes has to be ignored to get a product to market, poor initial design ultimately wastes far more time and money than it saves.

Do I need to say that Reddy is (other than occasionally using trendy jargon) a solid writer? If other technical books are trashy potboilers, Reddy's work is -- if not Cormac McCarthy -- an approximation of Larry McMurtry. His thinking is almost always easy to follow -- you rarely have to reread a point to understand it. As a long-time fan of Charles Petzold's books, I can confirm that Martin Reddy is at least as good a writer.

"API design for C++" is not just about writing good APIs, but writing good code. /Anyone/ who's a professional programmer -- even if they don't program in C, C++, or C# -- should read this book.
6 von 6 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Just wanted to add another 5-star rating for this book 14. Februar 2012
Von R. D Johnson - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
There's not much to say that previous reviewers haven't already mentioned, but I'll say them anyway because I love this book. I'm in awe at the way this book presents the most useful concepts from many of the other seminal works (GoF Design Patterns, the Effective C++ series, Code Complete, etc.) and distills them into readable, understandable design practices in each and every chapter. It doesn't replace the other books if you need extensive details or background theory, but for experienced C++ programmers this book encapsulates the most-commonly-used daily techniques. Like another reviewer notes, the book's title is 'API Design' but don't let that fool you into thinking this book is about creating libraries. The reality is that good programming practice involves creating interfaces (APIs) to blocks of modular re-usable code and then tying those blocks together into a functional application. Even if your code will never be seen by a third party, the concepts in this book will help you write far more maintainable, re-usable in-house code.

This book is also chock-full of little gems of knowledge that typically require scouring the web and then sorting the wheat from the chaff. For example, pages 195-197 contain a concise list of the C++ operator syntax, showing the operator name, the typical syntax, and the recommended operator declaration to use (both free-function and member forms) if you want to overload that operator while maintaining compatibility with the standard C/C++ usage of that operator. This is the table that should have been included in Stroustrup's 'The C++ Programming Language' but wasn't.

Last but not least, the breadth of topics discussed is outstanding. Everything from how to begin the design of an interface (API), through the most commonly-used implementation design patterns, coding conventions, version numbering, performance, documentation, testing, script binding and plugin architectures, to creating library packages on all three major architectures (Linux, Mac and Windows). All three major platforms are discussed in equal depth when appropriate, eg.,the different debugging tools available on each platform, but this book isn't platform-specific. Most of my coding is for embedded systems on Linux, and I didn't feel slighted in the least by the content in this book.

This is not a beginner's book for learning C++. It's also not going to replace the need for the GoF Design Patterns book or teach you template meta-programming. It's for experienced C++ programmers with a project or two under their belt, and for those folks it's probably not going to teach them something they didn't already know. What this book does is remind you--that experienced C++ programmer--of all those things you've forgotten, those good practices you knew you should have used on that last project but didn't, or show you why the way you've been doing it really isn't the best approach. This book reminds you to be a better programmer.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar