Customer Reviews

Catalyst: Accelerating Perl Web Application Development

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

 

 

Catalyst is a flexible and powerful framework for writing web-based applications in Perl. But with power and flexibility you'll always get a certain amount of complexity and on the occasions that I have looked at Catalyst for a project, the complexity has got the better of me and I've always turned to a less complex (and therefore less flexible and powerful) system. I knew that Catalyst was something that I should take the time to learn, but it always seemed like such a daunting task.

For that reason, I was really looking forward to reading this book. I'm the kind of person who learns best from reading a book and I hoped that with a few tube rides reading this book, coupled with a few practical sessions in front of the computer, I'd soon have Catalyst. I'm sorry to report that having read the book, Catalyst is almost as confusing to me now as it was before.

I don't think that much of the blame can be laid at the feet of the author. Jonathan Rockway is a member of the core Catalyst development team. I've read his blog and his contributions to various mailing lists. He obviously knows his stuff. I think he's been badly let down by his editors.

The problems are at two levels. Firstly there are many typos and errors that should have been picked up at the copy-editing stage, and secondly (and more importantly) I don't think that enough thought has been put into the organisation of the book.

Let's start by looking at the typos. The problems start before the book really gets going. On the "About the Reviewers" page, each of the two reviewers gets a paragraph to say thank you to various people. For the first reviewer this is typeset as a blockquote, for the other it's a normal paragraph. You might think that it's too nit-picking to point this out, but I see it as an indication of either poor copyediting or as rushed production process. And neither of those options exactly inspires confidence in a book.

At other points, the typos are more serious. On page 32, it says "We'll also need two more CPAN modules for this chapter. These can be created using the following". An experienced Perl programmer will almost certainly mean that the author meant "installed" instead of "created", but a newcomer to the language might well find it confusing. There are also errors in code examples, so I strongly recommend keeping a close eye on the book's errata page.

All of these are simple enough errors that could have been put right with another couple of rounds of proofreading. There are, however, deeper issues that would be harder to fix.

The book takes the reader through a number of Catalyst projects of increasing complexity. But I don't think that anyone ever really sat down and planned how these projects work together to give a coherent introduction to Catalyst. A lot of the time it reads like a collection of completely unrelated articles about Catalyst. Good articles. Interesting articles. But completely unrelated to each other.

There are also important things missing from the book. The introduction to Model View Controller architecture is minimal to say the least. It might work to reconfirm what the reader already knows, but it certainly wouldn't be much use to someone who is coming to the concept completely new. The same is true of a lot of the Perl in book. Catalyst uses a lot of pretty advanced Perl syntax but none of it is explained in any detail. You can argue that a discussion of function attributes would be out of place here, but surely there's room for a mention of the right section of the Perl documentation.

In fact external references are almost completely missing from the book.There are no pointers to other books that might help you use Catalyst more effectively. If you look at all of the best Perl books, they have many references oto other Perl books and web sites. This book mentions the Catalyst web site and mailing list at the start, but that's about it.

The obvious rival to Catalyst is Ruby on Rails. And if you read books about Ruby on Rails, they are all friendly books which do all they can to draw the reader into their way of doing things. This book isn't going to convince anyone who isn't already a Perl programmer who understands MVC. I can't recommend this book to anyone outside of that group.p

In the index for "Catalyst" book, you'll find no entry for model, controller, action, dispatch, or ActionClass. These are some of the most fundamental concepts in Catalyst.

Many technical books suffer most because of those elements that are outside of the author's direct control: weird layouts, weird typographical conventions, and lousy indices. Knowing that, I'd never base my criticism of a technical book on the failings of its index. The failings of "Catalyst's" index, however, are telling about the failings of the book as a whole.

If it were only the index that lacked this information, it would be a minor problem. Unfortunately, there really is no comprehensive explanation of any of these topics. Though there is an entry for "View," it is explained in as little detail as the rest of these concepts.

Pages 6 and 7 provide about one paragraph each for the concepts of MVC, Model, View, and Controller. From there on, the book focuses on implementing specific tasks without explaining much of the concepts that are used to do so. Actions aren't so much explained as implied to be subroutines with attributes. While nearly all of dispatch in a simple Catalyst application is determined by a few named and attribute-laden subroutines, these are not even presented in a bullet list, let alone explained in any detail.

Instead of starting with an explanation of how the fundamentals works, Rockway works through specific, practical examples of application implementation. These provide a demonstration of quite a few of the things that one can do with Catalyst, and occasionally some explanation of why it works. The explanations are not systematic, however, and concepts are presented out of order rather than in a logical progression. By the end of chapter two, the first chapter with any specific examples, the reader is installing and using Template Toolkit, SQLite, and DBIx::Class. Views are defined as bits of code that produce output based on the content of the "stash" on page 20, but the stash itself is not given any explanation until five pages later. This kind of confusing presentation prevails through most of the book, and is sometimes rendered more confusing by the inclusion of huge code samples, some of which dominate three consecutive pages.

Some concepts are well explained. The section on chained dispatch was clear and concise, though basic actions and dispatch remained unexplained. The section on the REST ActionClass was clear, and I found it to be the most interesting section of the book.

The book desperately needs reorganization, both by inclusion of an explanation of the fundamental concepts used in Catalyst design and by reordering the presentation of material to present concepts in a logical order with no long gaps between items that belong together. Finally, a few segments could probably be dropped entirely, or at least moved further back into the book. Explanations of FormBuilder and BindLex, for example, might have been interesting and useful for the creation of serious web applications, but they are instead presented without much explanation in chapter three, where they just serve to further confuse the subject at hand.

The Catalyst::Manual documents seem to provide much of the same information, and at no cost. They also include some of the concepts that are missing from the book. Although I think a second edition of "Catalyst," or a second book on the topic, could be a very useful book to introduce new users to Catalyst, I don't think this book has much value beyond that of the existing free documentation.

Catalyst is a Web development framework that should not need an introduction. Thanks to Catalyst you no longer have to look towards Ruby on Rails if you want to develop Web applications in a flexible, efficient and effective way.

Personally I've stayed away from writing Web applications because it involved a lot of repetition, didn't produce very reusable code and was overall quite boring. Catalyst has changed that for me. It is well designed, encourages reusable code, extendable - everyone likes to write plugins -, and leads to fast application development.

This is the first book on Catalyst. The book author, Jonathan Rockway, is one of the main developers on the Catalyst project, so he knows what he's talking about. He takes you through a series of step-by-step tutorials in which you learn about how to develop ever more ambitious Web applications.

First of all, you learn how to install and set up Catalyst. This is a relatively straightforward process. Catalyst's core concept of MVC (Model-View-Controller) is explained next, and afterwards you're already creating a bare-bones Catalyst application and generating dynamic web pages. By the end of chapter two you've already created a simple database, used it as a model and set up a controller to forward the data to a Template Toolkit-based view. All of this took me less than fifteen minutes to read, write, setup, run, test and sort-of understand.

The next chapter shows you how to build a more ambitious address book application with basic CRUD (create, retrieve, update, delete) functionality, again in a series of easy-to-understand steps. Then you add sessions, authentication and authorization to the address book application.

You also learn how to write your own model classes, how to effectively test your Web application and how to deploy it to your web server. None of this is particularly difficult. Along the way, the author also introduces us to DBIx::Class, a flexible object-relation mapper that is held in high regard within the Perl community.

Catalyst is also Web 2.0 buzzword-compliant. One chapter of the book shows you how to add a REST API, how to interact with AJAX for a more responsive user interface, and how to create an RSS feed for your application's data.

You need to know a fair bit about the underlying technologies such as Perl or the Template Toolkit already; this book is a guide for competent developers to get into the Catalyst state of mind. It does not babysit you through every last step, which, for the record, I think is a good thing.

It is a relatively thin book - based on the table of contents I've read online I would have expected a much heavier volume. But after working through the book, I'm impressed about how many topics are covered in an easy-to-understand format. Like Perl, Catalyst makes easy things easy, and hard things possible. A lot of interesting topics are only touched upon, though; again, you're expected to explore on your own, using Catalyst's own documentation, its tutorials, and the CPAN, where you will find loads of plugins to extend every aspect of Catalyst.

The layout of the book isn't overly inspiring, but it also doesn't get in your way.

To conclude, if you're interested in what Catalyst has to offer, you need to read this book. It contains more information, and in a lot more coherent form, than can be found in Catalyst's own documentation.

In a time when less experienced users are experimenting with web frameworks for development, Ruby on Rails has gained notable marketshare in the area of easy set-up and minimal configuration. As one of many Perl-based frameworks, Catalyst operates in the same space and for many new users will be measured by this same quick-configuration criteria. So it follows that many users will want a book that will get them up and running quickly.

The Catalyst book succeeds in getting to the point quickly and diving in. Chapter 1 gives you a very quick overview of Model-View-Controller (MVC) architecture. Chapter 2 then starts with a simple Catalyst application, essentially a 'Hello, World' application. Keeping with the goal of easy configuration, the initial set-up involves running a script to create the core application framework. The rest of the chapter then walks through each directory that script created. I liked this high-level description because it's common for MVC frameworks to have many files in many different places and you don't often find a comprehensive overview in most documentation.

Even with tools for fast configuration and convenient interfaces, the reality is that there are still many decisions you need to make when creating even a fairly simple web application. And each decision offers plenty of wrong choices to an inexperienced user. "Catalyst," the book, does a good job of presenting the common best practice for decisions ranging from basic database setup to reusable code design.

These design decisions are presented in a quick matter-of-fact way without going into full discussions of every area. This was the right decision to make for a book helping you to get running fast. If you're looking for more in-depth disussion of different options for session handling, authentication/authorization, database design, or other web technologies, you'll need to look in books dedicated to those topics.

There is no question about the credentials of the author. Jonathan Rockway is a key member of the core Catalyst team and has been giving Catalyst presentations for years. This experience shows as the advice and best practices offered throughout the book are solid.

The first real sample application described is an address book. This is a good choice as it is something anyone can relate to and naturally fits a CRUD framework. It also builds nicely, starting from very simple features, like getting data in and out of your address book, to other typical features like external configuration files, sessions, and authentication and authorization. Many of the features demonstrated here could be easily re-implemented in any web application you might be building.

The book then transitions to a more complex sample application, a tool to track opinions on IRC. It can track people with multiple different nicks across multiple different channels. Once it has some data, the book shows how to build interfaces that can show various data on the positive and negative comments around various topics.

While the example did a good job of demonstrating Catalyst features, I was puzzled by the choice of IRC as the problem space. My impression is that IRC is very much still a tool used rarely outside technical communities. If the book hoped to reach a wider audience, some of whom may be new to programming, this example could be a stumbling block. For someone not familiar with IRC, I think it would be difficult to focus on the Catalyst code because they would be trying to wrap their head around what IRC is and exactly what the sample application was doing.

As with any techincal book, it contains a significant amount of raw code. Of course it needs to show you the code to demonstrate how to do things and describe what's going on. However, I found myself wondering if there were a different way to provide some of the code samples, perhaps as an appendix, at the end of the chapter, or as a download. For completeness, you want all of the code provided in the book, but I think people seldom type everything in from a book, so it seemed some sections could have been pared down.

As with any technical book, examples can become out of date after printing, and there are some cases here. Errata are posted on the Packt Publishing website and there is also a wiki hosted on the Catalyst website. I imagine it could be frustrating for a new user working through the early examples (in Chapter 3, for example) without referring to these resources.

Any book has it's share of typos that get past the editors, but I seemed to notice a few more than typical, especially toward the end of the book. I don't know that any of these would cause any serious issues in understanding, but they can be distracting.

Finally, if you are interested in some newer web development technologies like AJAX, REST, and RSS, the author has you covered. There is a chapter devoted to these technologies and additional supporting technologies outside the Catalyst framework to get you going.

As an introduction to Catalyst, and MVC web development, this book succeeds in getting you going and explaining all of the key features you need for web application development. However, some might find the cost a bit steep (list US $39.99, $35.99 on Amazon) for a fairly slim volume. My recommendation is if you know you are going to be doing development with Catalyst, "Catalyst" the book would probably be a useful reference and you'll find many of the examples reusable. If you are just dabbling with Catalyst, you can probably get the introduction you need from the online documentation available on the Catalyst website and the Catalyst framework documentation.

Many of the criticisms in other reviews are very true. The book does gloss over alot of the concepts of catalyst or skips them entirely, it does use alot of the same information that you can get from the online docs and forums, and it does read like a tutorial. But the last criticism is also a point of strength from the book; it's a tutorial or a cookbook, depending on how you look at it.

I've started catalyst projects twice in the past based on the online tutorials and docs and twice I stopped for various reasons, but both times I felt a little daunted by the advanced perl concepts. Apparently I wasn't as advanced of a perl programmer as I thought. When this book came out, I bought it right away from the publisher and was dissappointed when I first looked at it, but I was determined to build a catalyst app. I followed the 'tutorial' and consulted the perldocs for the missing pieces until I understood all the concepts.

A few things that make this book relevant:

1. Rockway is a member of the core Catalyst team, so the stuff he mentions are proven and best approaches. Catalyst allows developers to choose different modules for major components, so following the books example prevents false starts.
2. The book is new with current topics, like REST and AJAX. It's also current on perl modules, choosing what I would assume are the best choices and shortcuts, like using FormBuilder.
3. There isn't any other books out there on Catalyst. Hopefully, this book may popularize Catalyst enough that other books might start popping up.

Catalyst should be read as a tutorial on how to get started with the Perl web application framework, but it's not a reference. For example, it doesn't list all the action types, but just goes ahead and uses those which fit the purpose of the example. In fact, rarely will you find any sort of reference dissertation in the book. The reader should also be more than familiar with Perl.

How to benefit from this book:

1. if you've played with Catalyst before, the book is a very good way to make your Catalyst knowledge more well-rounded
2. if you're new to Catalyst, you can see what it can do; in that case, you'll encounter many aspects that the book doesn't explain, or only glosses over. Either skip them, or consult online references

[...]

I think I might have given this book less than three stars if it weren't for the fact that it is the only book on the Catalyst MVC Framework in publication as of this writing, and it is helpful at least. Catalyst is just an awesome web development tool, and unfortunately there just isn't anything else out there in publication right now.

That said, there are typos in the book, some of the code is deprecated, and some of the Perl modules that Jonathan Rockway uses in his examples were not intended for production use. Trying to run some of the sample code in this book is an exercise in frustration, although I did manage to get it working eventually.

The real problem with this book is that it appears to be intended as a plain-language introductory book, but realistically if you don't already know your way around mod_perl and either the Template Toolkit or HTML::Mason you will probably have a very difficult time following what's going on. However, if you're a veteran Perl web developer who wants to learn Catalyst then this book is probably worth owning.

Below a comment not only on reading the book, but on reading and using it.

Context: After 4 years of Perl homemade site, I have been looking for a more structured framework to move our web site. We have a 10 million web pages view per month web site, representing 4 years of work, so having the old site and the new one running at the same time was mandatory.

I first looked at the Perl frameworks and as always in Perl, you have the choice between 5 CPAN modules doing the same thing and all in version 0.5 without a clear visibility on which one to choose or even on which one is really working. (Is it what the Perl community describe as "There Is More Than One Way To Do It." ?)

Catalyst draw my attention but I got worried when I saw this was the second attempt from the main developer to build a framework, and that this main developer had stopped working on it to try building a third framework. They were still people working on Catalyst, but the free online tutorial was directly using a plugin which first documentation line is "HTML::Widget is no longer under active development".
Moreover Catalyst is proud to say that once you have chosen Catalyst you still have the possibility/work to choose a module for each layer of Catalyst, which leads you each time to another module selection. So I got scarred and bought the Rails book.

I understood why Rails is so popular: because their book is one of the clearest programming book I have ever read. Clear and simple from 1+1=2 to real production.
Problem started when coming down to our application: the Rails conventions had so many impacts on how my database columns should be formatted that it seemed impossible to me to have Rails work on top of my current database without highly modifying it, and this was not an option as current code had to keep running.

So I let this 'framework' idea down a few months until this Catalyst book came out. The major information of this book is: Catalyst is alive and working and there are people really working on it. Only this is huge and I thanks J. Rockway for this and bought the book to know more.

I found there other key information:
- Catalyst might work with plenty of different modules for each layer, but using the default ones was ok. No selection nightmare (except the form part... see below)
- Catalyst uses an ORM (link to the database) called DBIx which takes my database as it is (opposite to Rails). I can therefore use it without having to rewrite my legacy code first.

Digging around in modules documentation I also found that Catalyst was working Unicode and I18N::Maketext. This was great news for me as those are mandatory if you really want to build a international web site as we do (17 languages on our site www.green-acres.com). (I personally consider Maketext 'quant' operator as the best reason to choose Perl, and any perl developer should use it right away if he believe one day his application might go abroad)

This book really helped me as it is a real tutorial and this is a "can't do without" if you really want to use Catalyst (and not just reading a book). But I do understand all the criticism I have read about it.

The problem of the book is in fact very simple to explain and curiously, you do not need to open it to see it: This book is 186 pages, which is very thin if we want to take the time to see everything clearly. The Rails basic book is 789 pages (and you have an advanced book). Do not think you will read the Catalyst 186 pages book faster: if a concept is hard to understand, you will prefer to have 5 detailed pages in your book rather than having it on one page, and then spend days looking in Catalyst modules documentation (and be happy if modules documentation is enough as for myself I too often needs to go to module code directly).

The biggest problem I have had so far when coming down to production is the form generation part of the book. It appears to me more like a Catalyst problem than a book problem, but this is where I have lost most of my time:
HTML::Widget form management module in the online tutorial is not maintained. FormBuilder as far as I could understand has no correct internationalization support (I might be wrong thus, but I never found a documentation on how to make a form label depend of the language). So after hesitating between 10 forms module, I went on the Catalyst IRC where they told me the alpha version 0.02 of `Formfu' was the best one to use... Which I did as this was the only one which had real internationalization support, but lead down hours of debugging as `Formfu' as particularly the `Formfu-DBIC' part is really alpha also there is a lot of work on it at the time of this writing and it might be a great module once over and documented.

Conclusion: Catalyst is really great but not that easy as documentation or books are at their early stages. If you just want to see how Catalyst works, the free tutorial is enough. If you really want to work with Catalyst, buying the J.Rockway book is mandatory. But the day J.Rockway writes a 789 pages book focused on pedagogy, watch out as Catalyst will then becomes a superstar framework. (And please J.R. add a section on how to I18N / Unicode Catalyst, as this is the best Catalyst feature against many framework out there)

Benoît Galy

This is an excellent guide to Catalyst as a solution to web application development. The content and presentation are excellent: clear, concise, and correct - everything builds nicely on what came previously. The examples work, are explained well, and go well beyond the standard "here's a toy database-backed application, isn't that nice?" - the book additionally covers form-building, sessions, building custom models (not necessarily database-backed) REST, AJAX integration, and goes into significant detail on testing and deployment. There are some minor errors, but these are fairly easily spotted and corrected by an intermediate Perl programmer. The few that might derail the beginning reader have been documented at the Packt Publishing website with corrections; I suggest picking these up to save time.

As to style, it's clear and concise. One interesting difference from similar books is that sometimes commands are inlined in the text, and sometimes shown in the code sections. Initially, I found this a little odd, but after reading a while and working through the examples, I found that it actually forced me to read the text carefully instead of just typing things in, and led to a better learning experience. I actually picked up much more because I had to read in detail.

The book does a good job of showing you what's to be done and how, and is precise about why you are doing any particular thing, doing an excellent job of keeping your understanding in sync with what you're doing. Anything that directly relates to getting your work done is there; detailed (and not particularly useful) descriptions of every possible option are not. This is a book for the reader who wants to get work done now.

Catalyst extensions and other CPAN modules are introduced a few at a time; as you work through the examples, you build up a nice toolbox of techniques and modules that make developing with Catalyst much easier. The pacing of this is quite natural and works very well.

Summary: Solid and recommended. Slimmer than most technical books (183 pages) but densely packed. You'll learn a lot, and what you'll learn is quite useful. Beginning Perl programmers will probably find it difficult; I'd personally recommend it to intermediate-to-advanced Perl programmers (with a basic understanding of Perl object-oriented programming) who want to get their teeth into a Rails-like Web development system, and who want a comprehensive and useful book. The book is definitely Unix-centric; Windows users may not find it useful unless they choose to use a Unix-like environment.

Recently I was contacted by a publisher from Packt publishing about reviewing this book. Note that while I was asked, I wasn't paid for this review, this is my personal opinion.

The book is written by Jonathan Rockway, who is one of the core team members of the Catalyst team, which gives the book a solid technical background. The book's text is easy to read and understandable.

Catalyst starts by giving a brief introduction to the MVC methodology and instructions for downloading and installing the Catalyst run-time. One thing to note is that this book is not for readers new to Perl, the book assumes you have a solid knowledge of Perl intricacies and experience using CPAN, which is required to install the multitudes of modules required for Catalyst development. I found that a certain level of problem-solving was required, as not all CPAN modules installed cleanly. I had to force-install a few of the modules and manually resolve a number of dependencies in order to get all the required modules. This barrier to entry might discourage some beginners just starting out with Perl and Catalyst. Other than that, all the installation instructions were very clear.

Developers don't learn very well with just theory, so Catalyst does a good job of providing a sample application to develop and extend throughout the book. The bulk of the development centers around creating an Address Book application, which is then extended to have features like authentication and AJAX later on during the book. Personally, I'm happy the same application is used, rather than switching applications every chapter. The book does change applications for a couple of chapters (which I find is good, to give a different app's perspective), then returns to the first application afterwards.

The book discusses a lot of the cool features of Catalyst, such as FormBuilder, templates, REST APIs, Jemplates, AJAX and RSS feeds. The book describes ways to use these features to help speed up development and move away from repetitive code creation. In chapters 8 and 9, testing and deployment are discussed. Personally, I would have liked to see the testing and deployment chapters moved up and integrated into the earlier chapters to enforce a methodology that includes testings from the beginning of development, but I can understand moving it to the end to make entry into the framework a little easier.

One other thing to note, as with almost any programming book, syntax and spelling errors can be killer when attempting to replicate code written in a book, the Catalyst book has a list of errors pertaining to the code in the book, which caused me a great deal of frustration until I looked up the errata. I recommend that anyone use the code example either downloaded from the website or directly from the book take a look and make sure they get the correct syntax. The only other thing I would have liked to see was a chapter on security concerns of the Catalyst framework (being concerned about security myself), I was disappointed they didn't show up in the book, perhaps in the next edition. I have noticed (from googling for errors I ran into), that Jonathan is very vocal on forums about helping people, so I have no doubt that the syntax errors will be corrected in a future edition :)

Alright, enough blathering from me, here's the short and sweet summary: This book is great for Perl or Ruby programmers who are already familiar with MVC development and are interested in the Catalyst framework. The book is not exhaustive by any means, and is not overly long (I would say this is a good thing), it provides a very solid foundation to work with, and a developer should be able to develop his/her own app after reading it. If you're a Ruby developer interested in a Perl alternative to Rails, or if you're a Perl developer jealous of Rails, I encourage you to check it out.