Editorial Review:
Cached date: AWS Called=true
You may also be interested in these products:
These categories may also be of interest to you:
Customer Reviews
Average Customer Rating: 
Good Intro to ACE framework 2008-06-17
This book provides comprehensive tutorial for networked applications. ACE was my popular framework before Boost.Asio framework. Even though ACE has little dated approach, it is still the best framework for multi platform distributed application development and this book provides very valuable contributions to people needing to develop this type of applications.
Introduction, not a reference  2008-05-14
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.
Just awful  2006-05-23
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:
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.
An issue in example code of section 7.6.3 2006-02-08
A good book for you to get into the world of ACE.
A good book for newer of ACE.
During the first 2 month I am using ACE, this book give me great help. But later I found a little issue of the example code in section 7.6.3 which will cause spin-lock when the output socket is blocked/flow-controlled.
I post my comments to this issue below, hoping you can avoid this mistake.
You know, so many people are using this book as guide for ACE, and may copy the example code ( just as me ) in their work with ACE.
Section 7.6.3 ACE_Connector
int Client::handle_output (ACE_HANDLE)
{
ACE_Message_Block *mb;
ACE_Time_Value nowait (ACE_OS::gettimeofday ());
while (-1 != this->getq (mb, &nowait))
{
ssize_t send_cnt =
this->peer ().send (mb->rd_ptr (), mb->length ());
if (send_cnt == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("send")));
else
mb->rd_ptr (static_cast (send_cnt));
if (mb->length () > 0)
{
// Here will cause message_queue notify reactor
// And get into handle_output again immediately
// which cause spin-lock
this->ungetq (mb);
break;
}
mb->release ();
}
if (this->msg_queue ()->is_empty ())
this->reactor ()->cancel_wakeup
(this, ACE_Event_Handler::WRITE_MASK);
else
this->reactor ()->schedule_wakeup
(this, ACE_Event_Handler::WRITE_MASK);
return 0;
}
What would you do with all this power?  2004-01-05
This book is yet another great example of how the ACE framework can save you a lifetime of development. Within this book is the knowledge and experience to excell your applications to the next level and become more productive then ever. If your code base deals with networking or even if you just need to have cross platform compatibility then this book is a must have to teach you the ways of ACE.
|
|
|
|
