Facebook Twitter Pinterest <Einbetten>
  • Statt: EUR 67,49
  • Sie sparen: EUR 0,50 (1%)
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
The Ace Programmer's Guid... ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Sehr gut | Details
Verkauft von betterworldbooks__
Zustand: Gebraucht: Sehr gut
Kommentar: Versand aus den USA. Lieferungszeit ca. 2-3 Wochen. Wir bieten Kundenservice auf Deutsch! Sehr guter Zustand fuer ein gebrauchtes Buch, minimale Abnutzungserscheinungen. 100%ige Kostenrueckerstattung garantiert Ueber eine Million zufriedene Kunden! Ihr Einkauf unterstuetzt world literacy!
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Alle 2 Bilder anzeigen

The Ace Programmer's Guide: Practical Design Patterns for Network and Systems Programming (Englisch) Taschenbuch – 14. November 2003

5.0 von 5 Sternen 1 Kundenrezension

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 66,99
EUR 33,51 EUR 2,37
7 neu ab EUR 33,51 12 gebraucht ab EUR 2,37
click to open popover

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.




The ADAPTIVE Communication Environment (ACE) is an open-source toolkit for building high-performance networked applications and next-generation middleware. ACE's power and flexibility arise from object-oriented frameworks, used to achieve the systematic reuse of networked application software. ACE frameworks handle common network programming tasks and can be customized using C++ language features to produce complete distributed applications. This book will teach developers how they can use the ACE framework to develop their software. It will also show real-world uses of design patterns and C++. Benefits: Reduces the ACE learning curve, gain a clear understanding of how to use ACE to produce high-performance software using less time and effort; Provides a cookbook for solutions to common software engineering problems.


"If you're designing software and systems that must be portable, flexible, extensible, predictable, reliable, and affordable, this book and the ACE toolkit will enable you to be more effective in all of these areas. Even after spending over a decade developing ACE and using it to build networked software applications, I find that I've learned a great deal from this book, and I'm confident that you will, too."
--Douglas C. Schmidt, Inventor of ACE, from the Foreword

"This book is a must-have for every ACE programmer. For the beginner, it explains step-by-step how to start using ACE. For the more experienced programmer, it explains in detail the features used daily, and is a perfect reference manual. It would have saved me a lot of time if this book had been available some years ago!"
--Johnny Willemsen, Senior Software Engineer, Remedy IT, The Netherlands

"With a large C++ code base, we rely on ACE to enable a cross-platform client-server framework for data quality and data integration. ACE has improved our design and smoothed over OS idiosyncrasies without sacrificing performance or flexibility. The combination of online reference materials and printed "big picture" guides is indispensable for us, and" The ACE Programmer's Guide "earns top-shelf status in my office."
--John Lilley, Chief Scientist, DataLever Corporation

"In SITA air-ground division, we are one of the major suppliers of communication services to the airline industry. We started using ACE about a year ago and are now moving most of our new communication-related development to it. I can say that using this toolkit can reduce the development and testing time by at least 50% in our type of application."
--Jean Millo, Senior Architect, SITA

The ADAPTIVE Communication Environment (ACE) is an open-source software toolkit created to solve network programming challenges. Written in C++, with the help of 30 core developers and 1,700 contributors, this portable middleware has evolved to encapsulate and augment a wide range of native OS capabilities essential to support performance-driven software systems.

" The ACE Programmer's Guide " is a practical, hands-on guide to ACE for C++ programmers building networked applications and next-generation middleware. The book first introduces ACE to beginners. It then explains how you can tap design patterns, frameworks, and ACE to produce effective, easily maintained software systems with less time and effort. The book features discussions of programming aids, interprocess communication (IPC) issues, process and thread management, shared memory, the ACE Service Configurator framework, timer management classes, the ACE Naming Service, and more.

The accompanying CD-ROM contains the complete ACE toolkit, including installable kits for Windows, Solaris, and HP-UX; complete reference documentation for all of the ACE classes; and source code for every example in the book.

Alle Produktbeschreibungen


5.0 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Stern
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel


Format: Taschenbuch Verifizierter Kauf
Preis/Leistung s.gut
Buch ACE 5.x basiert - etwas veraltet (ACE 6.1.7 Dez. 12)
Inhalt gut und stimmt immer noch für aktuelle ACE Version. Guter Leitfaden, wie man in the Thematik Middleware ACE reinkommt...
Lieferung ein paar d früher als Termin (2.5w) - viel schneller als über Buchhandlung hier (Dauer ca. 1 Monat, da Bestellung in USA).
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 4.1 von 5 Sternen 9 Rezensionen
28 von 29 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Just awful 23. Mai 2006
Von caelumvox - Veröffentlicht auf Amazon.com
Format: Taschenbuch
ACE is great, no doubt. This book is not. If I had been scanning ACE code for years and needed a reference, this book might be great, but like a kid in a foreign land, this book only confused me more than it helped. Here's why:

READS LIKE AN UNABRIDGED NOVEL. In order to understand each example, you must read the book from cover to cover. There is so much detail in ACE that there are almost no "trivial examples" and a thorough understanding is required. What if I'm not writing a high-performance server application? What if I want to work with small examples and work my way up incrementally? This book makes it difficult to do that.

EXAMPLE CODE IS CHOPPY. Each example is presented in such a way that code is provided piecemeal, along with paragraphs of explanation. This is ok, but it is very difficult to piece the examples together and write code. Also, it's not listed in the book, but the examples are online, here:


This link is not in the book.

THIS BOOK JUMPS EVERYWHERE. For instance, check out section 7.5, Timers. We're given a quick intro on Timers while we're kneed deep in talking about the omniscient Reactor that ACE provides. Now, section 8.5 talks briefly about timers and to reference further documentation in reference to Reactor/Proactor, which is unhelpful and unnecessary. Finally, section 10 gives great detail into using Timers. Chapter 7 should have been called Reactor.

My biggest interest was writing a client/server application in ACE. Chapter 6 started with a terrible example of socket communication, saying that Chapter 7 is a better pattern for the client/server. By the time I got done with Chapter 7, there was so much rambling of hypothetical situations that I completely forgot what I was trying to learn. The big picture is often lost.

NO API REFERENCE. Maybe it is not appropriate to put in an ACE API reference in here. I think it should be put in as an appendix. When examples are presented, the new data types come out of nowhere. What is an ACE_Time_Value, specifically? What other parameters can it provide? ACE Doxygen documents can't provide enough detail and neither can this book.

What I would love to see in a second edition:

- More descriptions of the standard types.

- Description of ACE_TMain and other OS functions.

- A better mapping of types to GOF patterns and better UML.

- An API reference, even if it is small

- Table mapping Unix/Windows/VxWorks functions to ACE functions.

- A more readible text. The code blocks could be encapsulated in gray to take it out of the text somewhat.

Also, most of the other reviews on this book shown above talk about how great ACE is for development, and I agree. However, isn't this the section where we are supposed to be commenting on the BOOK (APG) and not the TECHNOLOGY? These reviews hardly talk about the book at all!

Huston, et al, I encourage you to come out with a second edition. I still want to learn about ACE, but I need a more organized reference and clearer examples.
27 von 32 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Great way to learn the ACE Framework 21. November 2003
Von Amazon Customer - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This is probably the most practical book ever written on this topic. I have read the C++ Network Programming books, and I believe that this Programmer's Guide is even better.
ACE, the ADAPTIVE Communication Environment, has been around since the early 90's and thanks to over 1700 contributors over the past decade or so, it has become a very powerful, reusable, Object Oriented, beautifully engineered, designed, and developed framework that is creeping its way to the hearts of developers, project leads, and managers all around the world and in many industry verticals.
ACE has made one of the hardest things to do as a developer, network programming much simpler, but that's not all. That's where this book comes into play. The other books focus on the network programming of ACE, and even though they cover the topic VERY well, they don't convey the other powerful features that ACE has:
ACE Logging Facility
ACE Runtime and configuration facility
ACE (STL like) containers, allocators, etc...
Right of the bat, this book covers those details and shows the reader concrete examples and ways to apply these examples in real life.
The author spends the next 4 chapters (6-9) going over the IPC facilities of ACE. It starts from basic SOCKET programming, to SIGNALS, to the use of TIMERS and it ends with the odds and ends of IPC. These topics were covered in the C++ network programming books before, but this book, instead of talking about it, SHOWS the reader how things are done. The Reactor and the Proactor frameworks are covered in chapters 7 and 8. As the author mentions in chap 7:
The ACE reactor framework was designed to implement a flexible event-handling mechanism is such a way that applications need never write the central, platform-dependent code for their event-handling needs.
Then the author goes into an extensive detail of how this is done, and in its closing remarks, he says the following:
With little ingenuity, your reactor-based application can turn on the foyer light when someone pulls into your driveway or mute the television when the phone rings.
The Proactor framework is covered in full detail in the following chapter. The author does a great job at telling and showing the differences between the two design patterns and when to use one vs. the other. When all said and done, the author explains how these two design patterns can make a killer combo.
The book is more like a personal notebook that you would create for yourself in that you write down notes, hints, do's and don'ts and few lines of code at a time telling yourself how you made something to work properly.
In Part III, Processes and Threads are covered. Even though the author has included these chapters after the IPC section, a great deal of detail was spent on showing the reader that these classes are not necessarily related to the IPC set of classes. The reader can literally read part III of this book, and gain a good understanding of how to use the thread and the process management classes - remind you that these two topics are difficult to grasp and programming is a bit difficult, but the author shows how cleanly these two topics were covered in ACE. The icing on the cake is the last chapter in Part III: Thread Pools. Two threading models are covered:
Half-sync/half-async model
Leader/follower model
I will leave the details of these two models to the reader.
Part IV covers the "advanced topics" such as shared memory, the configuration framework, timers, and the naming service. Again, for each section an extensive example is given, which makes the topic easy to understand and to follow. The configuration framework is a very well covered section, as it is something that any of us can benefit from in our next design.
18 von 21 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen ... no better way to learn ACE 3. Dezember 2003
Von John Michael Zorko - Veröffentlicht auf Amazon.com
Format: Taschenbuch
... than from the experts -- those who design / maintain / extend / port it, and some of those very same people were involved in the creation of this guide.
OK, we've all seen the problems with networked application development -- Windows does it differently than Solaris, which does it differently than Linux, which does it differently than VxWorks, which does it differently than Mac OSX , which does it differently than ... etc. Sockets, threads, timers, mutexes, synchronization primitives, etc. are the bane of developers who want to make their applications connect and communicate with one another in heterogeneous environments. Even the technologies that are cross-platform more or less (BSD sockets, pthreads, shared memory, etc.) are sometimes difficult to use and easy to introduce bugs with. What is a networked application developer to do?
Enter ACE -- the ADAPTIVE Communication Environment, which aims (and largely succeeds) in providing a cross-platform, pattern-based systems framework that hides the platform specifics without sacrificing speed, makes BSD sockets, threads, and system APIs object-based, and allows the same code to be used on a variety of platforms. ACE is used in many large projects around the world which needed to be highly scalable, predictable, portable and easily maintainable, all at once. Enter this book, which does an admirable job both introducing ACE and many of the design patterns it implements to the newcomer, and making some of the finer points of ACE more cogent to those of us who have been working with it for awhile. Each chapter has an introduction (which pattern we're covering now, what problems it solves, how ACE implements it), lots and lots (and lots and lots) of easy-to-read source code examples, and plenty of plain-english explanation as to how this stuff works. In my continuing ACE education, this book (as well as the C++NP books and the ACE-users list) truly helps me to understand ACE, patterns, and all that they are capable of. I am a far better developer as a result, and I cannot give this book any higher praise than that.
16 von 20 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Tries to Decouple C++ from Specific OS details 4. Dezember 2003
Von W Boudville - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Network programming can be very difficult, given such issues as latency and different hardware/operating systems on your net. At the very least, the latter can have different byte orderings an datatype sizes, if you write in C or C++. Now in C, by the late 1980s, such headaches caused several unix vendors (mainly Sun) to converge on supporting a key utility, rpcgen (and affiliated routines). This let you write common C code for client/server applications, and compile these on various platforms. Lo, things usually worked!

But as software projects grew in complexity, writing in procedural language like C became harder. Hence the rise of C++. Well, wouldn't it be nice to reimplement and extend rpcgen? (It had numerous limitations.) The idea was to finesse/bury OS specific details at a lower level of the code, where you could often ignore it. You can imagine ACE as filling this need. I'm not saying that this is how or why ACE was developed. But I am trying to argue from YOUR background, which I assume is C++ and C.

The book describes significantly more functionality in ACE than merely an extension of rpcgen. Even if you don't have a C++ networking application, but are writing a standalone application, ACE may be useful. It increases your chances of writing portable code. For one thing, it heavily downplays the use of OS-supplied compiler macros. In both C++ and C code that will be maintained on several platforms, this is a notorious source of bugs. Very brittle. Just having ACE subsume these issues should give a maintenance productivity gain. You won't see this immediately when coding the first version of your application. But experienced developers should see the payoff.

Plus, ACE also offers higher level design patterns. Here, I don't know how applicable they might be to your specific problems. But just having the patterns increases your coding arsenal.
3.0 von 5 Sternen Introduction, not a reference 14. Mai 2008
Von J. S. Hardman - Veröffentlicht auf Amazon.com
Format: Taschenbuch
The ACE libraries are useful for developing cross-platform code, providing functionality such as loggers, configuration handling, communications, threading etc. Where ACE itself falls down is that the documentation supplied does not provide enough information about how best to use it and what it does under the covers. You might think that you don't need to know about what happens under the covers and for a simple application that could be true, but when you go multi-threaded and discover that in parts of the ACE library the code checks which thread you are calling from and behaves differently depending on what it finds, then this is something you need to know. Unfortunately the documentation doesn't give that level of information and neither does this book. Life-times and ownership of objects are areas likely to cause issues too - this book mentions an example of that relating to the logger, but there are others too. A library that decides ownership based on whether you pass a pointer to a method or a reference to that method is one where you want/need a good reference book, not just an introductory text.

"The ACE Programmer's Guide" is a reasonable introduction to ACE, but it is certainly not a reference (despite the quote on the back cover calling it exactly that). Unfortunately, when using ACE the old adage about a little bit of knowledge is true. You can work from the documentation, this book and the books by Schmidt, and if writing reasonably complex systems you will still hit issues using certain parts of ACE resulting in you stepping through the library code to find out what is going on. I've therefore only given this book 3 stars. It's a reasonable introduction, but if you are doing anything significant with ACE, particularly if multi-threaded, you are likely to end up wishing there was a complete reference work (no, the HTML help is not thorough enough either) rather than just introductory texts and overviews.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.