New book review: "Railo 3: Beginner's Guide"
Note: This blog post is from 2012. Some content may be outdated--though not necessarily. Same with links and subsequent comments from myself or others. Corrections are welcome, in the comments. And I may revise the content as necessary.As some of you may know, there's been another new book recently in the CFML world, this time Railo 3: Beginner's Guide.
It's from four folks who many in the CFML community will know: Mark Drew, Gert Franz, Paul Klinkenberg, and Jordan Michaels. Mark and Gert work for Railo, while Paul and Jordan are active in the Railo community. I was given a review copy from their publisher, Packet Publishing (and thanks to an arrangement by Mark). With a title like Beginner's Guide, one may wonder what to expect. As a contributor myself to several CF books (carehart.org/contact.cfm#books), I appreciate the challenge in deciding the intended audience for a book, and keeping it in mind as we are writing. And having been a co-contributor on now 10 multi-author books (not all on CF), I appreciate the challenge in keeping a consistent voice among all those authors throughout a book, as well as each keeping that intended audience front and center. It's not easy, although it can be aided greatly by careful editorial control and editing.
What to expect from the book?
So, as a "Railo 3: Beginner's Guide", what would you expect? Something for people making the move (or considering it) from CF to Railo ("beginners to Railo")? Or something for those coming to CFML anew, where Railo is their first CFML engine ("beginners to CFML and to Railo")? In that case, should that audience be presume to be "beginners to web apps" as well, or just to CFML? Indeed, might someone expect such a title to be appropriate for those coming from a Java server background who may have been persuaded to consider CFML and Railo ("beginners to CFML and Railo, but not to programming")?
The subtitle is "easily develop and deploy complex applications online using the powerful Railo Server", and the back cover starts by calling it "a practical guide for developing web applications with Railo". Of course, different people may read "complex applications" differently. Let me go ahead and point out what the Preface says about the audience:
"If you want to develop your own dynamic web applications using CFML, then this book is for you. No prior experience with Railo or CFML is required, although you are expected to have some experience in web application development experience and the knowledge of HTML, basically, how websites work in general."
And from reading the book I'd concur, so it's not intended as a "how or why to transition from CF to Railo" book. And the title should clarify that, but some will inevitably wonder, so we should make that clear right from the outset. Might it still be valuable to you, someone who already knows CFML? Maybe. There are various topics that are indeed Railo-specific.
Considering the Table of Contents
Let's look at the list of topic in the table of contents (I've added the approx number of pages for each):
Chapter 1: Introducing Railo Server (18)
Chapter 2: Installing Railo Server (19)
Chapter 3: CFML Language (47)
Chapter 4: Railo Server Administration (50)
Chapter 5: Developing Applications with Railo Server (39)
Chapter 6: Advanced CFML Functionality (19)
Chapter 7: Multimedia and AJAX (20)
Chapter 8: Resources and Mappings (21)
Chapter 9: Extending Railo Server (38)
Chapter 10: Creating a Video-sharing Application (44)
That's quite a wide-ranging set of topics. :-) Note that the biggest chapters are on the "CFML language", and "Railo Server Administration". They're certainly both going to be vital for someone coming to CFML anew. And at the same time certainly someone moving from CF to Railo will still benefit from understanding how Railo Administration works. Same for the other chapters that would be unique to Railo, especially chapter 9, and some of the other chapters where Railo-specific things are mentioned. To be clear, though, they're not really pointed out as different from ColdFusion. That's not the book's intent, and the authors (being Railo folks) are reasonably focused more just on "here's how to use Railo to build CFML apps" for those new to doing CFML apps.
Going beyond the TOC to details per chapter
Still, you may reasonable wonder, then, what are the various subtopics of each chapter. The good news is that you can find the detailed ToC online at the book's site. Click on the "Table of Contents" tab midway down the page. (I couldn't find a way to offer a URL that added something that would make that tab open. I'm really not a fan of tabbed interfaces in web apps, for this very reason. Another challenge is that often a search engines will show a page, indicating it had content you sought, yet when you do a find on the page, you can't locate it--because it's under a tab that you've not thought to click. Grr.)
That said, when it comes to looking at that detailed table of contents, the online version suffers from an unfortunate problem, and the print version has another. If you look at the online version, you'll notice that the real "sections" and "subsections" in each chapter don't stand out in any way. They're all at the same level, with no bolding or anything.
The print one is a little better. But in both, the section headings are also lost in the weeds of as many or more "time for action" sections (where the book walks through doing something, which is itself a commendable feature).
I just wish they would have either done something else for the "time for action" text in the TOC, like have an acronym instead, like TFA, or better yet an icon. It's just hard to perceive the organization--which may be as important for someone standing in the store, as someone later using the book, or as someone contemplating whether to buy it while reading an online review. :-)
FWIW, neither of these issues is a problem for the two other Packt Publishing CF books: John Farrar's ColdFusion 9 Developer Tutorial and Matt Gifford's Object-Oriented Programming in ColdFusion. I know, some will think I'm being pedantic for having gone on so about this. Hey, it's my review. :-) Seriously, though, it's a usability issue that could be addressed, online and in any reprints.
Finally, as long as I'm talking about the book site, it's a bit of a shame that it does not list both of the other CF books, not even in its "alternative books" widget at the bottom. (There is a special offer to buy the book with John's CF9 book, but no mention of Matt's OOP book, which seems unfortunate for the authors, the publisher, and the readers.
About the Content
So what about the content itself, whatever your place in the prospective "audiences"? Well, recalling that it's a "Beginner's Guide", there's the ever-present challenge of whether a book speaking to them will teach simple techniques (cfquery/cfoutput) or will stretch them from the beginning to use CFCs and cfscript syntax, and use that throughout. There was a recent brouhaha in the CFML community as some castigated the CFWACK books for failing in that regard. Well, those folks won't be happy: the book is pretty much all tags. At least until Chapter 6, which opens with discussing the issue, and from that point through the rest of the book, there's a fairly even split of both types of coding.
On a related matter (and good news for that aforementioned camp of folks concerned about how CFML is taught), I will note that after introducing cfquery (albeit pretty late some may say, on p 74, in Chapter 3 on CFML), the book does at least immediately move in the very next section to talking about using CFCs (on p80, which ends that chapter).
Separately, some may note that the book then proceeds right to chapter 4, on Railo Server Administration. If one assumes, "well, that's because you have to show how to create DSNs in the Admin", that's actually not the reason. The book did step into the Admin just prior to the cfquery discussion, on p72. That that was using the Railo Web Administrator, whereas chapter 4 is on the Railo Server Administrator. Here again is where folks coming from CF may be a little confused.
The chapter does explain the difference between server and web contexts (something foreign to CFers) which does have benefits for true separation of applications, and it goes on to explain those benefits and how to manage things differently, including the nice remote sync feature for keeping admins synced across multiple instances. And the 2nd chapter talks about installing Railo, which is also different from CF and has some useful advantages that are discussed. (Sadly, while the unique cluster scope in Railo is mentioned a couple of times, there's no dedicated discussion to running Railo in a cluster. But let's remember my initial point: this is a "Beginner's Guide".)
What about development topics?
So back to its coverage of development topics: the book does cover the basics of CFML, as expected, mostly in Chapter 3. It then covers more advanced and modern topics many would like to see, such as ORM, caching, and more (in Chapter 5). An interesting point about caching (made in Chapter 5) is how Railo supports a pluggable architecture, so that you can use either built-in caching (ramcache or ehcache lite), or switch to any of several alternatives (memcached, couchdb, infinispan, and more).
And while I noted earlier that Chapter 4 is on administration, that chapter also covers various development-oriented features that are controlled by the Admin and (in a somewhat eccentric approach) the chapter shows CFML code demonstrating those there, in that chapter. (These might be missed if a developer chose to skip a chapter on "administration".) Such topics include things (which it may interest some to know are supported) such as text searching via Lucene (from which Solr is built), event gateways and more. It also discusses what Railo calls "magic functions", which is basically like the implicit getters/setters for CFCs that were added in CF9.
On the other hand, it's perhaps unfortunate that the "advanced CFML" chapter (6) is about looping and scripted coding. But front-end developers will enjoy Chapter 7 on Multimedia and AJAX. And despite not being quite so obvious from its name, Chapter 8 ("Resources and Mappings") is mostly about accessing the file system, working with zips, as well as working with Amazon S3. Chapter 10 wraps things up with a complete video-sharing app, leveraging especially the ORM and video features introduced earlier.
Still other topics, especially unique to Railo
Other chapters touch on various unique features Railo supports like archives (packaged applications), the easy admin update mechanism (coming now also to CF10), and so on. Chapter 9 is about various ways to extend Railo, ranging from the ability to create new tags and functions (that you can call just as if they were built-in ones, for better or worse), as well as to package up them or indeed complete applications that can be bundled and shared with others (or even sold in a Railo extensions store). Indeed, besides overriding CFML functions in CFML code, you can also just change the underlying Java source for any tag or function (or of course the entire engine), since it's an open source product.
Chapter 1 also mentions still other features that Railo supports, some uniquely. Again, the focus of the book is not really "how is Railo different than CF", though CFers will indeed find discussions of things that are different. Chapter 1 could be useful as an intro to Railo for CFers. You can read that first chapter online at the book site. I will note that many of these topics are not developed further, but you can find more at the Railo sites, getrailo.org, getrailo.com, and blog.getrailo.com.
Some nits, yet opportunities
If I have one other nit to pick with the book, it's with the index. If you're not careful, you could think content did not exist. For instance, there's no mention of ORM--you have to think of looking at Object Relational Mapping. That may seem petty, but a good indexer should have seen how often the term ORM was used on its own and offered a cross-reference (because many people do in fact only know it by the acronym.) There's a similar problem with CF tags: don't go looking for them under the letter C. They're instead in front of the index, as
But let me make lemonade from those lemons: if you visit the Amazon page for the book, you'll find it's been enabled for the "see inside this book" feature, so you can easily search for a topic of interest and see how the book covers it. That should help a lot if you're a CFer trying to decide if you may find value in the book. (Of course, that Amazon feature often does not show many pages beyond what you find, so you can't read it entirely there, let alone even much about a specific topic.)
So, is Railo 3: Beginner's Guide a book for you? I can't make that decision for you, of course. It really depends on where you are in your understanding of Railo, and indeed CFML. It's certainly not geared toward those with CFML experience, in that it starts from square 1, but then it also covers a lot of ground way beyond square 1. For those willing to dig through to find what will be new, they may not only learn things new to Railo but also things existing in CF that perhaps they've not paid attention to. Then again, some of my readers will wish it covered more about what is specifically different (or may wish that it was made more clear). While others will think it's great that it just "rolls with Railo", which suits a reader not coming from CF.
You really will need to decide for yourself, or whether you may recommend it to others you know. I hope I've given you some motivation to consider it further, and both information and additional resources to help you do so.
For more content like this from Charlie Arehart:
Need more help with problems?
