The Apache Modules Book: Application Development with Apache

By Nick Kew

"Do you learn best by example and experimentation? This book is ideal. Have your favorite editor and compiler ready you'll encounter example code you'll want to try right away. You've picked the right... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0132409674
• ISBN13: 9780132409674
• Release Date: January 2007
• Publisher: Prentice Hall
• Length: 558 Pages
• Weight: 1.89 lbs.
• Dimensions: 1.3" x 7.0" x 9.1"

Customer Reviews

Required Resource for Writing Modules in C

This should be considered a required resource if you need to learn about writing apache modules. It is the best introduction available to writing modules for Apache 2, and holds up well as a reference.

Consistent, well-written, but a bit gap toothed

This book easily earns five stars despite a few glaring issues. Why? It's the best, most consitent, and approachable guide you'll find to writing Apache modules. I spent two weeks scouring the net for APR examples and explanations. I started with the O'Reilly books only to find they are incredibly out of date. I moved on to Apache sanctioned module source code. I dissected source code for other modules only to find that the examples fluctuated on approach and, apparently, on the author's grasp of the entire APR libraries. Some folks wrote against previous APR version libraries and macros. Others used the updated APR. Still others rolled their own versions of functions that were already written, just not discovered. Tutorials varied in reliability with similar issues. And my desk quickly filled with highlighted and sticky-noted annotated examples. This book replaced all those loose inconsistent notes with a solid example-centric nicely bound guide. Five stars. Just for that. This book is not without problems though. First, it makes reference to programming paradigms which, frankly, I've never heard of before and which this book inadequately explains. Brigade buckets is an example. Bridage buckets are incrementally explained as a ring data store (eh?), a doubly linked list (okay, firm ground), and then a mechanism for passing data through layered IO (another eh?). I couldn't get much from the explanation. Googling "brigade bucket" led to IEEE DSP circuit design and a heated debate on using solid state delay effects for guitar pedals. Apparently brigade buckets don't quote share the same prolific status as, say, something more Knuth-ess. The book explained thread safety in a similarly gap toothed summary. It offers this fatherly advice: avoid shared memory and make sure functions are reentrant. That wasn't much help for me. I'd prefer to have a detailed explanation of why the APR libraries have both reentrant and non-reentrant versions of the same functions. Wouldn't any reasonable programmer always use the reentrant version? If not, I'd like to know why... with some precision. The final gripe: the book includes RFC 2616 in it's entirety. This needlessly adds 200 pages of non-original and otherwise easily (and FREEly) accessibe volume. Granted, the publisher formatted the RFC nicely. It's a bit easier to read than the fixed format of the real RFC. But why not add a few notes? The author could have taken the edge off of the RFC-legalese and made it a bit more approachable (think learning bible with more notes than text). At the risk of discouraging future books of this level, the RFC is a blatant copout and just a really disgusting way of bumping page numbers. So, those are the issues I had. I'm still giving this a solid five as it outshines any other information I've found to date.

The definitive source for Apache module writers

I tried to write an Apache module using only the documentation and reference material available on the net, and failed. The documentation you can find on the net (even on Apache.org's own website) is either completely out of date or maddeningly vague. If you spend enough time in trial and error you might get your module to work. Then again, you might not. If you're trying to write or maintain an Apache module, this book is an invaluable tutorial and resource. It saved me a great deal of time and frustration.

Perfect for any serious programmer's Apache reference collection.

Apache is more than a popular Web server; it's a versatile and complex platform covered well in THE APACHE MODULES BOOK, the first guide for developers who already work with Apache and want to make the most of its features. From code security and basic processing to C-based shortcuts and techniques, APACHE MODULES BOOK uses real-world code examples and techniques to provide an excellent manual of basics. Perfect for any serious programmer's Apache reference collection.

good old C programming for Apache

With all the buzz in recent years about various scripting languages like PHP or Perl, it is refreshing to see a book that takes an unabashed advocacy of plain old C. This is a solidly C programming book, showing how you can change a module or, more ambitiously, add a new module to Apache. It shows the conceptual framework of Apache; deliberately designed to permit third party extensions. The text also describes an important practical case, where you are making a module, but want to link to a pre-existing library. In essence, your module extends both Apache and that library. Then there are the usual complications, like several modules linking to different versions of a library. Kew suggests avoiding linking in libraries, because of reasons like this. But he allows that other opinions exist. Some programmers should look at the sections on filter chains. A very useful way to understand and arrange analysis. Decomposing an intricate analysis into different filtering stages can be useful in terms of writing and debugging the code. Apache is well suited to let you take this approach. Of course, those of you programming in C should be well aware that this runs into scaling limits as the source code lengthens. Which is one of the reasons that many C programmers moved to C++ or Java. But so long as your modules are under 100 000 lines [roughly], then using C should be fine.