Customer Reviews (23)

c++ network programming
If you want to learn C++ network programming architecture , design patterns and want the source code to be portable , this is the book for you . If you cant afford to have your own copy at least suggest your company to buy it . If your in C++ network programmingand dont use ACE , think again , you might be reinventing the wheel.

Good ACE book
ACE becomes popular in the world of system programming these years because of it's portability, low difficulty by providing wrapper encapsulating the complexity of low-level thread usage. However, going on development on ACE without thorough knowledges of system level details is hazardous and therefore further readings are recommended.(e.g. Hart's book)

Quite not what I expected it to be
After reading the Vol. 1, I expected quite a bit from the volume 2. May be I am not there yet to understand what the authors are trying to emphasize here. I found some of the material from vol.1 covered to much deeper extend. But the framework from the reusability point of view is missing. Some of the topics covered here are great indeed, especially chapter 5, 6 and 7. Other than that I found this book to be a quick browse and keep it away.

Well-written book for eligant power code warriors
This is a well written book documenting many of the eligant and powerful frameworks and idioms used in the ACE library.I've been using ACE for over 7 years to implement portable, concurrent, networked, distributed applications and it's great to see a well-written book like this finally being published. I would highly recommend it as a must have reference for all serious ACE programmers who strive to develop powerful, flexible and portable networked applications.It is also an extremely valuable resource for programmers who want to get introduced and up and running on the concepts and application of some very valuable frameworks.

Open-Source Framework Facilitates Network Programming
Writing networked applications using modern operating
systems and languages looks like it should be easy, but it
is emphatically not. The na‹ve designer of networked
applications will encounter a thicket of problems including
lack of portability, distributed performance bottlenecks,
maintaining correctness during shutdown, and managing
recovery from partial failures.

"C++ Network Programming, Volume 2, Systematic Reuse with
ACE and Frameworks" by Douglas Schmidt and Stephen Huston

provides some powerful help in the design and implementation
of networked applications. This help comes in the form of
several frameworks.

A few words about the definition of "framework." The first
step up from writing applications that interface directly
with operating systems is to insert object-oriented wrappers
between the application and lower level services. These
wrappers are classes that encapsulate the low level,
functionally specified, services such as operating systems

and protocol stacks. This first step was taken in the
predecessor volume to the present book, "C++ Network
Programming, Volume 1: Mastering Complexity with ACE and
Patterns", by the same authors, where a collection of
wrappers, called the ACE wrappers, is provided that not only
raises the level of the application interface from
functional to object-oriented, but also provides portability
at the same time.

For example, consider an application that directly uses
sockets. This application would depend on the syntax and
functional details of that operating system's s operating
system's socket implementation. By inserting the ACE
wrappers, the application acquires an object interface to
socket capabilities, and in addition becomes portable across
a large number of compilers, operating systems, and
communication protocols.

But a set of wrapper classes does not solve the networked
application designer's problems, any more than a pile of
bricks is a house.

Frameworks, which are the subject of the present book, are
the next step up in power from wrappers. A framework is an
integrated set of classes into which application designers
plug code that is unique to their applications. The
frameworks described in the present book handle a large part
of the difficulty inherent in network programming, leaving
application designers to deal primary with their
applications' local functionality.

For example, one of the frameworks described in the book is
the Acceptor-Connector Framework. This framework relieves
the user of dealing with the numerous tricky details
inherent in the conceptually simple process of connecting
clients with servers, such as address formats, protocols,
initialization, and message queue locking.

Readers should be aware that the present book is not a
general-purpose text on network programming using C++; this
book is a focused exposition of the ACE frameworks. Readers
will be most comfortable reading this book if they are
already familiar with software design and architecture
patterns, including those described in "Pattern-Oriented
Software Architecture: Patterns for Concurrent and Networked
Objects, Volume 2" by Douglas Schmidt et al, and in the
famous Gang of Four book: "Design Patterns: Elements of
Reusable Object-Oriented Software" by Eric Gamma et al.

The large amount of code that implements the wrappers of
volume 1 and the frameworks of volume 2 is available for
download for free. This code is in wide use today.

Designers of networked applications, when offered a large
pile of code that purports to do a lot of what needs to be
done, must trade off the anticipated saving in design and
implementation time against the anticipated time to
understand what the offered code is intended to do and what
it actually does. This tradeoff can lead a reasonable
designer to ignore existing code in favor of hand-writing an
entire application. In the case of the ACE wrappers and
frameworks, as documented and explained by the two books
mentioned here, combined with the open-source nature of the
implementing code and its widespread employment in real
applications, make the result of this tradeoff pretty clear:
read the books, use the code. ... Read more

Customer Reviews (12)

Not sure who this book is aimed at
The blurb for this book calls it authoritative. And it is authoritative in the sense that it is written by the people behind ACE. But it is not authoritative in the sense that it isn't a complete reference.

As somebody who has written native code for handling Sockets, process management, threading etc on various platforms, then over time integrated OO and patterns to make it easier to use (including across platforms), and slowly worked my way towards what I consider a definitive way of doing things, I find reading this book interesting in that it's like a tick list to which I can go "yeap, I found that too" with just the odd "ooh, actually I would do that differently in this specific situation, but for the general case yes that's how I do it too". So, for me this book is interesting now, but if I was new to ACE (I'm not) or new to the underlying platform APIs I am not so sure how interesting I would find it. It gives more of a taster of what ACE can do than providing a complete tutorial. It gives more of a justification of why ACE does things the way it does rather than provide a complete reference. So, interesting for me now, but I'm really not sure who the book is aimed at. It could be used as one step of a tutorial, giving familiarity of what ACE can do, if not enough detail to really do serious stuff. It could be used to persuade people that it's usually better to use ACE than invest time and money re-inventing the wheel... Otherwise, I just don't know...

Is ACE worth using? Most of the time, yes. If you need a book about ACE then this is probably the place to start, but online is the place to find the detailed information that you will need when using it.

2nd volume C++ network programming architecture
The 2nd volume is a complement to the first.The 1st one talks for portable source code and wrapper classes. The second one concentrates on deisgn patterns & all issues in C++ network programming architecture .
Again i say dont reinvent the wheel , give ACE a look.

Excellent reading for any network programmer
This is an excellent reading for any network programmer. More than ACE itself the concepts covered are of a great value. I am a beginner to intermediate network programmer, but an experienced programmer otherwise, and found this to be an extremely valuable resource in terms tackling large application frameworks from the ground up. The concepts are precise upto the point but extremely easy to read and digest. Of course, the book is assuming that you know quite a bit of every thing else that is not covered here. There are quite a bit of things that are totally missing or not correct based on the OS and the advances in Posix threading. Nevertheless this is an excellent source for any network programmer.

Wonderful book!
I discovered ACE almost two years ago after a coworker told me about it.As a developer in the networking / streaming media / distributed computing space, i've all too often run into the problems that are inherent in developing this sort of software -- scalability, maintainability, not to mention all of those bugs ...

ACE makes all of that much easier, and delivers the promise of true reuseability; not just classes, but common behaviors (patterns).This book explains why ACE was needed, the problems it solves, and how to use it.Though it's highly technical, it's not boring or overly verbose -- the problems developing networked apps are presented, and the solution ACE uses as well.Doug and Steve did an amazing job with this ... highly recommended.

Good ACE overview
I have been trying to learn ACE for the past few months now.Their docs are not that great.I ran C++ doc generator on the API's and that helped alot.The book really closed the deal for me.I work with many customers that are just begining to use ACE and I recomended this book to them as well. ... Read more

Book Description
Successful series - Ace the Technical Interview is a bestseller of over 36,000 copies in the last 2 editions.IT professionals are sought after and paid well ($60,000 average plus a 9% annual increase) - a growing number of workers are attracted to this new industry each year.Helps promote professional advancement - programmers change jobs on the average of every 4 years and they need information to bring them to the next level.Each chapter includes proven techniques from leading experts in their technical field. ... Read more

Customer Reviews (6)

Just awful
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
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?
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.

Tries to Decouple C++ from Specific OS details
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.

... no better way to learn ACE
... 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. ... Read more

Book Description
Has the critical information--Covers program structure logic and coding techniques that are used by experienced programmers and database administrators to get the job done more efficiently and effectively. Be an experienced programmer on your first day--Shows professional and quick ways to complete work assignments such as writing a new program, making changes or corrections to a current program, or testing changes. Proven techniques--Each chapter includes proven techniques written by recognized experts in their technical fields on how to get up to speed fast. ... Read more

Book Description
This digital document is an article from PC Business Products, published by Worldwide Videotex on November 1, 2002. The length of the article is 515 words. The page length shown above is based on a typical 300-word page. The article is delivered in HTML format and is available in your Amazon.com Digital Locker immediately after purchase. You can view it with any web browser.

Citation Details
Title: ACE LAUNCHES DSP COMMUNITY WEBSITE FOR DSP-C PROGRAMMING.(digital signal processor programming)
Publication: PC Business Products (Newsletter)
Date: November 1, 2002
Publisher: Worldwide Videotex
Volume: 14Issue: 11Page: NA

Distributed by Thomson Gale ... Read more

Book Description
Save valuable time, guard against common exam pitfalls, and find out how the MCSE game really works with MCSE TCP/IP Ace It!™ -- your inside track to certification. MCSE guru Jason Nash begins each chapter with a self-assessment quiz designed to gauge your preparedness. Nash also outlines the exam material covered in the chapter according to Microsoft objectives and his own experience so you'll know where you stand before reading the material.

MCSE TCP/IP Ace It! features chapter-ending skill labs and a complete Practice Exam at the end of the book with explanations to each answer and complete exam analysis. Certification has never been easier, thanks to MCSE TCP/IP Ace It! -- your all-in-one exam prep companion! ... Read more

Customer Reviews (8)

This exam is retired
The MCSE TCP/IP exam expired in February, 2001. Why on Earth are you guys still selling it???

This book and four days to passing the exam
I used this book, a visit to a cramsession website, and many many free tests available on the internet and passed with a score of 900!I only studied for four days and previously was only familiar with TCP/IP.I hadnever administered it.Great concise resource.

Just a tool for review, does not teach you
I bought this and the Exam carm series book for this test and the Exam cram book is ten times better. This book assumes you already or once new everything and just tries to help you review.

A well explained and straight hit book
This is a straight to the point book, the author highlighted what u need to know for the exam, what the exam will emphasize on. Furthermore, there is sufficient examples, explanations, reminders etc a well-written bookreally meant for the exam. The author had done his homework, and i believeis very experience in this subject. No wasted words, furthmore, it is smalland handy. So u can bring it out even when dating so that u can refer to itanytime, in this way u will naturally get the necessary knowledge withminimum effort. An ace to the author...I hope the other ace series of booksmaintain this standard, yet to find out...I just need ace it for exchangenow.

No other book needed
This book had all of the accurate information within one cover.Explanations are clear and the total book is organized.Makes sifting through other additional resources to find what you needed unnecessary. ... Read more

Book Description
Symposium held in San Francisco, California, January 1998.

This symposium is jointly sponsored by the ACM Special Interest Group on Algorithms and Computation Theory and the SIAM Activity Group on Discrete Mathematics. ... Read more

Customer Reviews (1)

A Typo
Dear Amazon,

I think the "Ace-Siam" in the title for this proceedings should be "Acm-Siam". ... Read more

Book Description
Performance tuning is increasingly important as desktop applications move to a Web-centric, software-as-a-service model. Performance analysis and turning ensures that .NET-based applications perform as well as or better than traditional desktop applications. Direct from a team at Microsoft that has analyzed hundreds of Web-based and .NET-based applications, this book shows developers how to plan and execute performance tests, configure profile tools, analyze data from Microsoft Internet Information Services, analyze transaction costs, and more. ... Read more

Customer Reviews (6)

Too Shallow
Most of this book is a high level introduction to various Microsoft tools (ACT, perfmon, netmon, IIS sever logs, ASP.NET tracing, SQL Server query analyzer, SQL Server profiler) and a little coverage of Compuware's tools.There are 2 chapters on performance prediction: one covering extrapolation (known as TCA) and one covering modeling (Indy).

The problems this book attempts to address are not easy; solving them requires a lot more than a tools overview.The chapter on extrapolation is misleading, implying that you can focus on a single metric, and not explaining prediction involving multiple metrics.The chapter on modeling is very unsatisfactory: they show off this cool looking tool (Indy) but never explain where to get it from.

The only but Best Book I have seen
This is the First book that discuss testing web application using Microsoft ACT (which I find not the best testing tool, see Astra Load Test, it is perfect).
the book will divide the testing to phases and tiers, for example it dicusses how to optimized and find bottle neckin web tier (ASP.net Code), managed code and SQL server.

I didn't find anther book that discuss "Stress Testing ASP.net" application.

The will tell you how the found the "Memory Leakage" and they will tell you their exprience in finding problems with web sites.

If you r intented to "know" how to stress test you application, buy this book now

Good, but not great
I had pretty high hopes for this book and was therefore a bit disappointed.The book focused heavily on several testing suites (ACT, Application Expert, Indy) which good from the standpoint of learning about the tools that are out there.Of course, it's not terribly useful if you can't get your hands on those suites.

The parts of the book that focused on non-application specific performance testing concepts were generally weak and didn't go into enough detail.It would have been nice to see some of the testing documentation that the book refers to, but no such luck.

One thing I found particularly annoying was in the description of the various Performance Monitor objects.The various descriptions offered in the book were EXACTLY the same as the text that is produced by clicking on the "explain" button in the "Add Counters" dialog of perfmon.

With that said, the book is cheap and a quick read.It's probably worth buying, but don't get your hopes up that you'll be doing any serious performance testing after reading it.

Great Approach and Tips For Performance Testing
Although I have not read this book extensively, I have still found sound advice in its pages.This book is a great guide to anyone who wishes to learn more about, or conduct Performance Testing.From Bottle necks to security, this books covers a broad range of subjects.For a reliable source of testing information, directed towards web applications and more, refer to this book.Thank you.

Good Practical Advice on Load Testing using ACT
This books contains information about using ACT that I couldn't find in other documentation.It also contains practical advice for how to structure load tests and how to troubleshoot performance bottlenecks. ... Read more

Book Description
Now you can benefit from the many lessons Microsoft has learned about testing Web applications for security bugs. A must-have reference for every Web developer and tester, this book presents a comprehensive, structured methodology for identifying and addressing the most common, real-world security issues for Web applications throughout the development process. Written by the principal, front-line Web security assessment team at Microsoft, this guide walks you through each of the critical stages for effective security testing, including designing for and assessing security features; identifying security vulnerabilities and executing the assessment; and enhancing infrastructure security before application deployment, including best practices for locking down Microsoft® Windows Server™ 2003, Microsoft Internet Information Services (IIS), and Microsoft SQL Server. Get the entire book's sample code via the Web—and easily apply this expert author team's techniques and tools to your own programs. ... Read more

Book Description
This sourcebook offers adult education scholars and practitioners in academic, community, and work-related urban settings insight into the education and learning problems and needs confronted by low-income residents of inner-city communities. Additionally, it offers fresh perspectives and approaches to practice that can assist these residents in crossing the socioeconomic and race-ethnicity borders that separate them from more affluent urban communities.

This is the 101st issue of the quarterly higher education series New Directions for Adult and Continuining Education. ... Read more