» » The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming

Free eBook The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming download

by James CE Johnson,Umar Syyid,Stephen D. Huston

Free eBook The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming download ISBN: 0201699710
Author: James CE Johnson,Umar Syyid,Stephen D. Huston
Publisher: Addison-Wesley Professional; PAP/CDR edition (November 24, 2003)
Language: English
Pages: 544
Category: Technologies and Future
Subcategory: Networking and Cloud Computing
Size MP3: 1223 mb
Size FLAC: 1668 mb
Rating: 4.5
Format: lrf mobi azw mbr


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.

The ACE Programmer's Guide is a practical, hands-on guide to ACE for C++ programmers building networked applications and next-generation middleware. 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 ACE Programmer's Guide is a practical, hands-on guide to ACE for C++ programmers building networked .

ACE frameworks handle common network programming tasks and can be. .It will also show real-world uses of design patterns and C++.

This book will teach developers how they can use the ACE framework to develop their software. 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.

Stephen D. Huston, James Johnson, Umar Syyid. 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. This book will teach developers how they can use the ACE framework to develop their software

The ACE Programmer's Guide is a practical, hands-on guide to ACE for C++ programmers building networked applications and next-generation middleware.

Smoothing the Differences among C++ Compilers. Stephen D. Huston is President and CEO of Riverace Corporation, a provider of technical support and consulting services to companies who want to keep software projects on track using ACE. Steve has nearly ten years of experience with ACE, and more than twenty years of software development experience, focusing on network protocol and C++ networked application development in a wide range of hardware and software environments.

You're getting the VIP treatment! With the purchase of Kobo VIP Membership, you're getting 10% off and 2x Kobo Super Points on eligible items. Your Shopping Cart is empty. There are currently no items in your Shopping Cart.

A practical guide to ACE for C++ programmers building networked applications and next-generation middleware

A practical guide to ACE for C++ programmers building networked applications and next-generation middleware. It first introduces ACE to beginners and then explains how you can tap design patterns, frameworks, and ACE to produce software systems with less time and effort. ~~~ Welcome to my Blogs ~~~~ Do not forget to check it every day! If You should find any files not found, please PM me. ~ Download Download: Best Software for All ~ Tomorrowland2: Video Training ~ Pluralsight Tutorials: All Pluralsight Videos ~ EbookSA: Best Ebooks ~ Graphic World: Best Graphics.

A practical guide to ACE for C++ programmers building networked applications and next-generation middleware. It first introduces ACE to beginners and then explains how you can tap design patterns, frameworks, and ACE to produce software systems with less time and effort.
User reviews
Gavinranadar
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.
Wymefw
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.
Agalas
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.