| |||||||||||||||
Did you know you can trade in your old books for an Amazon.co.uk Gift Card to spend on the things you want? Plus, get an extra £5 Gift Certificate when you trade in books worth £10 or more before June 30, 2012. Visit the Books Trade-In Store for more details. |
Frequently Bought Together
Product details
|
More About the Author
Product Description
Product Description
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.
From the Back Cover
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.
0201699710B10142003
Tag this product(What's this?)Think of a tag as a keyword or label you consider is strongly related to this product.
Tags will help all customers organise and find favourite items. |
Customer Reviews
ACE is a cross platform communications library. It's very good at removing compiler and OS differences: you can write clients and servers with it that can compile and run on a dozen compiler/OS combinations. It's freely available to download off the internet (do a google search for "Schmidt" and "ACE" and the URL will be one of the first).
The main problem with the distribution and all the associated web-sites is that the documentation takes a lot of getting used to, and it can be impossible to find out the simplest things without a lot of messing about. This book fills the introductory hole that I would have filled when I started using ACE - i.e. how to use the thing without reading loads of source, make and configuration files.
This book is meant to be an introduction to ACE for people who've never seen it before. After an introduction telling you why ACE is designed the way it is and some of it's philosophy it tells you how to build the thing and the nuts and bolts of getting applications to compile and link with it. The book then discusses some helper classes: the logger and collection classes (yawn, another set) to name a couple of categories before getting into the real reason you might want to use ACE.
The rest of the book is divided up into three chunks: Interprocess communications, process control and "advanced stuff."
Interprocess communications covers sockets, ACE's abstractions for streams and events and some of the high level application frameworks that ACE provides to save your fingers.
Process control covers starting, stopping and synchronising with threads and processes. It starts from the basics of using simple threads and ends up discussing how to implement the active object pattern and thread pooling using ACE.
Advanced stuff covers some things already mentioned (e.g. streams and timers) in depth and adds useful things like shared memory and the naming service.
Oh, and for those shy of downloading stuff over the internet, the CD on the book comes with a mid 2003 distribution of ACE.
Overall this isn't a bad introduction. The writing is generally clear and unambiguous. Most of the clunky English comes from the ACE libray itself ("configurator" and "proactor" anyone?) It's fairly selective in what it covers (there's no detailed coverage of the OS abstraction layer for example - which isn't bad as it encourages you to program at a higher level) but should get you up and running with the basics. More importantly it shows you how to combine the raw components to implement solutions to trickier problems, hopefully helping you come up with your own solutions along the way.
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 real/complete reference work rather than just introductory texts and overviews.
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:
http://www.cs.wustl.edu/~schmidt/ACE_wrappers/examples/APG/
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.
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.
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.
Listmania!
Look for similar items by category
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
|
