Customer Reviews

Twisted Network Programming Essentials

5 star:		(3)
4 star:		(5)
3 star:		(3)
2 star:		(5)
1 star:		(4)

 

 

Check out the table of contents: The chapters are Getting Started, Building Simple Clients and Servers, Web Clients, Web Servers, Web Services and RPC, Authentication, Mail Clients, Mail Servers, NNTP Clients and Servers, SSH, and finally Services, Processes, and Logging.

That's a lot of distinct subjects in a two-hundred page book. The result is a good demonstration of how broad Twisted's domain is, but the chapters, for the most part, do not build on one another. While that allows you to skip the chapter on news servers and read the SSH chapter without much difficulty, it also means you're getting lots of separate chunks of knowledge that don't add up to anything greater than the sum of their parts.

I was hoping to see more material on general topics that apply to all Twisted programs. Interfaces are one example. Interfaces, as used in Twisted, are not a part of the Python standard library and I would not assume a reader to be familiar with them. But while Interfaces do come up in a number of the examples, nowhere does the author take the time to explain why you're importing from zope.interface or how and where Twisted uses them. Yes, there are examples, but nothing to help you understand the theory for when you have to write your own code.

Nowhere do we learn how to write tests for asynchronous functions. While the last chapter touches on the organization of services in a Twisted application, it fails to note basics like what method you'd want to implement to run tasks during a graceful shutdown. In all the attention to different network protocols, the framework aspect of Twisted seems to have been neglected.

So overall, if you want to embed an email server in your application, this book will give you a place to start. If you want a hard copy text to demonstrate the range of applications Twisted can reach, this book will do that. But if your main concern is that Twisted makes your head hurt and you want someone to make it seem less alien, I'm not sure this is the book you've been waiting for.

This book was disappointing to me. It does not cover Twisted fundamentals very well or comprehensively, but is rather a collection of few large code-examples and verbose commentary. For an introductory (or 'essentials' as the title state) material to Twisted, you are better off with the online manuals.

Granted, there are a few "oh - that's clever" moments in the book, but those are buried in the examples and hard to look up for future reference.

The bulk of the book shows examples for web clients and servers (simple stuff, not useful since easier-to-use and more powerful tools/libraries exist) and low-level pop, smtp, imap and nntp servers and clients (probably not very common in today's applications).

I haven't used Twisted extensively in a real project, but I have read the online docs and fiddled with small scripts - and the "new" things beyond them that I discovered reading this book can be counted on the fingers of one hand (namely Perspective Broker, authentication and SSH stuff).

I would have liked this book to be a more comprehensive overview of twisted's fundamentals and the base-protocols it provides - with more examples of custom protocols - since that's probably what most people turn to Twisted for.

This book is nothing more than a handful of code examples that you can just as easily get from the web. There's nothing in the way of overall architecture, insightful approaches to using Twisted in an application setting, etc. Save your money and read the web pages. Worst O'Reilly book ever.

When Twisted started to explode onto the scene, I was really intrigued by its varied capabilities and asynchronous model, but I was turned off by the then-scant documentation and the webapp framework transition that was just beginning (Woven was deprecated and Nevow was too new for any sort of coherent explanation). I just didn't have time to wrap my head around it, and so Twisted fell off my radar screen for a while. Eventually, I saw that a book was on the way, and I was excited to jump back in with it as my guide.

Twisted Network Programming Essentials is not an exhaustive reference to Twisted, nor does it even pretend to be. Rather, it's a pretty friendly, task-oriented exploration, providing examples of common tasks and insight into the key concepts and design patterns that are essential to grokking Twisted. Each chapter focuses on a particular topic, and they're arranged to build upon each other nicely. Sections within each chapter are broken down into a practical, easily digested structure--we're introduced to the task at hand, then the "How do I do that?" and "How does it work?" bits clearly and plainly walk us through an example solution and dissect its inner workings. At 202 pages of actual text, its eleven chapters make for a comfortable chapter-per-evening of reading and play. It's well worth either keying in or downloading the example code to see Twisted in action.

Covered topics include installing Twisted, the essential Twisted concepts; HTTP clients and servers; RPC; authentication; mail clients and servers (POP and IMAP); NNTP clients and servers; fun with SSH; and some practical, non-glamorous things like running your app as a proper daemon, adding administrative interfaces, and logging. You'll monitor download progress, make a simple blog, build an IMAP server, and more. You'll chain protocols together to make an email interface to Google. You'll be impressed by the power and cleanliness of Twisted's authentication model, and you'll have fun getting and using references to remote Python objects with Perspective Broker. There's also a pretty good explanation of REST, and plenty of links to useful reading.

All is unfortunately not shiny and delicious, though. I encountered what I consider quite a few programming errors in the example code, as well as several places where the explanatory text doesn't quite jive with the example. These errors are all fairly minor, and are probably artifacts of the evolution of the text and examples, but the frequency with which they crop up suggested that either no one had run the code before approving it for printing, or that errors were deliberately introduced to see if the reader is paying attention. As someone with a professional investment in web applications and frameworks, I was disappointed not to see any investigation of Nevow (not stable enough at the time of writing to be included, alas). The SSH chapter mentions but does not discuss or dive into the file transfer and connection tunneling concepts. I was also let down by the strict focus on programs that only used the basic Twisted reactor for managing events--the challenge of integrating Twisted's powerful capabilities into an existing event-driven program (eg, any GUI app) is entirely omitted. Furthermore, the book ends somewhat suddenly; I would have welcomed a "Great! What now?" sort of wrap-up that would provide a guidepost to more advanced topics.

These warts are quite forgiveable, however, and will hopefully be corrected in a future revision. The book is clean, friendly, and clear, and provides a nice entry into the world of Twisted. We are neither talked down to, nor beaten into submission by overly dense, inscrutable prose. For this printing, keep the errata handy to quickly resolve any issues with the example code (and submit anything new that you find). While the topics might be considered limited, it's clear that what's here is the tip of the iceberg; you can use these familiar topics to try to sell your boss on Twisted, and then your imagination is the only limit to what you can do. Since my initial experience with Twisted, the core documentation has improved immensely, but it's even stronger if you're already familiar with what's presented here; start with this book, then dive on into the online docs, and you'll be a Twisted guru in no time.

The book is a cookbook of twisted based clients and servers, with
almost no material on twisted's core concepts (e.g., as noted in a
previous review, almost nothing about Zope3 interfaces.) Also very
little use of object oriented ideas and visualizations (there is
one interaction diagram in the book), even those central to twisted
like reactor. Also some of the more subtle issues important to
writing real systems, like event loop bridges to GUI toolkits,
multiple threads, or exception handling, are not covered. As a
cookbook it is useful in helping one get running examples going
quickly (somewhat like the online POE cookbook does for POE novices.)
But a twisted fundamental concepts book still remains to be written.

When I first received this book, I saw that it was short and rejoiced. I usually never get through a 400 or 500 page programming book, because I get the early concepts, and then go off on a tangent, using the concepts in some way or another.

This book disappointed me. It went through some of the concepts of Twisted without really going into the details about some of the best parts of Twisted. The concepts of deferreds and the reactor event loop were skimmed over too quickly, and I never felt like I knew enough to implement any sort of server in Twisted.

There are better resources on the web to learn to develop with Twisted than this book provides.

The book was a very basic introduction to twisted. For the most part it will really only benefit someone who is relatively new to Python and needs to perform some quick network programming.

The tutorials described were good to get someone familiar with the syntax and to show the basic implementation of twisted, but more time is spent reading the book then it would take just to get the documentation and learn it hands on. Any programmer that has poured a few hours into researching code and documentation would feel that this book was a waste of time.

So if you are new to Python and need to learn network programming this book should be able to point you in the right direction, but if you are an experienced programmer, just use the documentation on the website and donate some money to the maintainers instead.

The only thing wrong with this book is that it needs an update. If your familiar with python and the changes that have taken place in the language you can easily adapt the examples to the current versions of python. I'm currently working with Python 3.1 and I am able to adapt the examples quite easily. It gives good explanations of the major components of the Twisted framework. The writing style is accessible. The information on the framework itself is not really outdated, it's just the language itself has undergone some change.

On the upside, this book is obviously written by someone who knows Twisted well, and shares the values of its developers.

On the downside, one of those shared values seems to be "documentation doesn't matter."

Twisted is well-known for being very poorly documented, forcing developers to regularly scan through mountains of abstracted source to find out what they need. I was hoping that this book would address that issue, by clearly documenting how and why Twisted works, what the different interfaces are, etc.

Unfortunately, it doesn't; instead, it only leads you through a number of canned examples. As soon as you want to step outside of any of the capabilities that's covered in them, you're on your own.

The book gave a much clearer initial picture (to me) of the Twisted system than the online documentation did. That said, this isn't the sort of book that I'll need to reference in the future. Perfect for bootstrapping, and now I'm off and running with the technical documentation.