Software Books

This an awesome book. This book is the to have for all web developers.

This text book is of very high quality and an engaging read. Apart from the expected target audience of web developers, I will suggest that website owners and non-developers should consider getting hold of this vital textbook.

The fact that it leaves you wanting more is a compliment to its quality. Even though it is bulky, I wished it had covered certain areas in more detail.

One small criticism relates to the javascript examples. The discussion of events refers to techniques that are questionable in terms of robustness and re-usability, issues that, to be fair, the author does point out. [Background; search for "addEvent considered harmful" in your favorite search engine.] Yet no definitive solution is given, and the reader is left hanging. More serious is the very poor quality javascript code sample given for the cssjs() utility function, which is poorly designed (needs to be repackaged, should be a class), is inefficient, and is fragile as it contains (at least) two immediately apparent critical bugs.

But such small gripes should on no account not put you off buying this text. The overall verdict, "Outstanding."

Anyway, the numerous authors are to be congratulated. Indeed, given the size of the field and the rapid pace of developments, a second "part II - advanced" volume would be a very good idea indeed.

If you are serious about accessibility (and you should be), this book will not dissapoint. The authors know what they are talking about, and do a good job and presenting both the facts and their opinions in a clear relavent way.

The only reasons I do not give it 5 stars is many items within the book are redundant (I think due to the great number of authors (11!), and perhaps they wanted the book to serve as a reference also), and because the presentation is generally dry. Good information, but not coffee-table reading.

Still in all, as a web developer I would highly reccomend this book to any other developer weather you just want a little understanding of accessibility, or a big dose.

Web Accessibility: Web Standards and Regulatory Compliance, written by eleven experts and released in July of 2006 by friends of Ed, is one of very few books about web accessibility. It is also the best. The writers include luminaries and pioneers in accessibility - Jim Thatcher, Cynthia Waddell; and technical experts - Christian Heilmann and Andrew Kirkpatrick, to name a few.

The book is an overview of accessible best practices in web technology, and the legal landscape it inhabits. It was compiled with several target audiences in mind.

Certainly, it is intended for developers - newcomers as well as veterans. This is the group that most needs to understand the technology, and unfortunately, seems to "get it" the least.

Another audience is the managers and administrators; that group that should be most adverse to risk and whose responsibility is to keep their government and corporate employers out of the courts and headlines (like those that have embarrassed [Target retailer]). Covered in some detail are the ADA section 504 and section 508 requirements, and in lesser detail international laws.

The technical information is very current. There is a chapter on accessible JavaScript (most would consider that term an oxymoron) even though it has only recently seen coverage in articles and blogs online. Likewise, there is good information on making Flash content accessible.

A book assembled as a compendium of contributions begs to be updated frequently. The next release, for example, could add much needed chapters on AJAX and Web 2.0, podcasting, and learning management technologies. Regardless, all practitioners of accessibility will find this book valuable.

Web Accessibility: Web Standards and Regulatory Compliance is the
perfect reference for any site development team. Everything you've
wanted to know about Accessibility and the Web is here in a single text.
Each member of the team will find necessary information and practical
solutions in one or more of the thorough discussions here. For the
designer/developer who works alone, Web Accessibility: Web Standards and
Regulatory Compliance is the all-in-one reference with the most
up-to-date information and techniques. Thanks to the clear organization,
two tables of contents, and index, all information is easy to find as
well.

For those of us who like background and theory, the book contains lively
discussions of accessibility standards, of the intent of the standards,
and suggestions for using the standards. For me, though, the heart of
the text is in the practical discussions and how-to guides in order to
improve accessibility of every common web technology -- from PDF to
Flash, from javascript to data forms. In addition, we finds clear
descriptions of the law and web accessibility. Importantly, these
discussions are international in scope.

The collective experience of the authors of this text is impressive.
These are the experts to whom we've turned to assist us with accessible
design and development for years. In this text, we have a collection of
the most knowledgeable voices on the subject of accessibility, who speak from a real-world
perspective. They share freely their best techniques, so that we can
create the "best possible experience for the greatest number of
visitors."

For me, Web Accessibility: Web Standards and Regularory Compliance is a
must-have.

I am not an expert developer but I have a fair amount of experience building financial applications in Java and C++. I spent quite some time looking for a book that would get me started with Web technologies. It is not easy. Yes, there are many books that describe one or another technology but I wanted to find one that puts these technologies in prospective. I was very pleased when I found this book. I can always dig deeper in one direction when I need to but this book helps me to understand how to get started and where to concentrate my efforts. I like it, I think it is very useful.

I have to disagree with the reviewer who disparaged this book's emphasis on history. The background on TCP/IP protocols explained how HTTP came to be and why servers and browsers work the way they do. Discussion of how web development platforms evolved provided insight into the problems newer approaches tried to solve and the problems some of them created. The authors may have gone overboard spouting the merits of "separating content from presentation" and touting the praises of MVC approaches, but their point is a valid one you can really relate to if you've worked with page-centric platforms like ASP and JSP. The historical review of different approaches explained the authors' reasons for ultimately choosing an MVC approach with Struts and JSTL, and offered insights into how development platforms may evolve in the future. This is a book that starts with basics and builds on them, covering protocols, markup languages, and development platforms. The history helps drive the points home. Personally, I learned a lot from this book. I agree that they could have provided a CD-ROM, but it turns out their website (webappbuilders.com) is pretty good and has other good info aside from the app's source code, including some articles from the authors.

This book is an ideal text for providing intermediate-level web developers with a solid grounding in architectural principles and more advanced techniques. Before going into why I like this book I do want to offer one caveat - the authors' approach is towards the Model-View-Controller paradigm, and is based on Java Standard Tag Library, Jarkata struts and Apache. These are solid elements, but if you are working in a different environment you will not appreciate this book as much.

The historical material in this book is not fluff if you approach it with the intent to gain a fuller understanding of the major components of the Internet and web. This material is rich with details about why the core web technologies developed and evolved, including design choices the pioneers made in the face of constraints. In a subtle way this part of the book is a primer on design and architecture.

What makes this book so valuable is the non-trivial application that brings this book alive. This is a refreshing change from other books that use thinly contrived snippets of code or trivial applications. The code for this application can be downloaded from the book's supporting web site, which also contains errata (thus far there are only two entries), and articles that are valuable resources with or without this book.

Overall this is one of the better books on web application design and development, and one that dives into code and technical details.

I've been writing Windows-based mutlimedia applications since Windows 95 was released. I've been looking for a good book to help the crossover to web application development, and I found that this was just the ticket. Explanations were solid and presented in a way that made experimentation easy (both from the browser and server side). Quite simply, this book served as a great jumping off point for deeper exploration into session management, security, web services (both SOAP and Rest), etc. Definitely a great introduction for folks with a software engineering background.

I always thought Amazon search is good but I stumbled upon this book at a store. It's a useful summary, but not a reference. I particularly like the examples and the way they build up from trivial to complex. The level of detail is right. Altogether, very refreshing.

Kalpanik blends art, craft and wit into a narrative which teaches us lessons we did not know we know.

This book combines elements from good humor, a memoir, a scenic travelogue, a touching love story, science fiction and philosophy.

Whether you ever wondered about meaning of it all, or you want to read something light amusing, or want to see places like Seattle, San Diego, and Nashville from the eyes of the writer, or vicariously live the life of a
student at University of California, this book is for you!

The author, purportedly an Artificial Imagination computer program simulating a life/career journey through the Hi Tech and yet very scenic world of California and Washington (Settle) is witty still though down to earth and funny! The book is written in a very conversational style, as if you are reading a letter from a close friend!!

Great book, love it! It's hilarious! I could not stop giggling, I cracked up page after page. Really Nice!

And so many nice photographs. I felt I was traveling with the author, no, I was him, feeling his ambitions, his surprise, excitement and pain. And what a brave soul! He (yes, despite its claims to have been written by an AI program, this book is written by a loving, feeling, breathing human for sure!)--He is able to maintain his sense of humor even as he moves from one place to another, faces one set back after another! He always comes back!

Wow! What a story!!

This book transcends genres -- it's a good collection of memoirs, entertaining style, nice splash of humor, an extremely detailed travelogue with beautiful photographs, a good description of technology, a touch of Science Fiction (since it is purportedly written by a Artificial Imagination program) and suffused with philosophical musing and last but not the least, a moving love story.

Even though it's obviously written by a Technologist, the book is very human. It is primarily about the immigrant experience, but Kalpanik is extremely observant and has an eye to look for the unusual, notice what stands out and build humorous side of people, places and his own life.

Wonderful! I am specially moved by his bitter-sweet love story at the beginning.

Watch Video Here: http://www.amazon.com/review/R167JUBPRPS0DJ Entertaining and interesting!

Steve Heller does it again, this time pushing the envelope. It continues where his Introduction to C++ left off in Who's Afraid of C++, and gets into more complex topics. The book provides another great stepping stone into the world of C++ programming. Its a great book, and worth the read if you are a bit more than a novice, or you have read the previous one. It not only tells you how to program in C++, but explains why you do certain things, something which other C++ books skip on because they assume you've already learned C. You don't have to learn C to program in C++, this book proves it, and if you know C++, then its a snap to do a little C programming.

1. Steve writes VERY well. 2. The interplay between Steve, and Susan is very engaging (it ought to be, ... they got married) 3. Steve uses iterative improvement to demonstrate how software really gets written. 4. He admits to his mistakes, at least some of them ;-) 5. He presents the material in a way for the reader to add new knowledge to a solid foundation.

Steve, you done good!

I've read some of the more technical language references for C++, but I'd always end up just using them to look up stuff when I got stuck. This book (and the first Who's Afraid...) both have a casual and clear tone that makes complex and abstract concepts seem to make perfect sense if you slow down and especially if you read the questions asked by the "student". About 1/2 to 2/3 of the time I had the same question. Some people won't like the fact that it's not purely a technical book, but a little story goes a long way in making a book interesting enough to read through instead of wade through.

Following the lead of the first book, "Who's Afraid of C++?," this latest volume does not skip a beat. While most books _show_ you how to write _code_, this one _teaches_ you how to be a _programmer_. The two are not synonymous. Through the object-oriented development of a realistically sized application, the reader is engrossed in the software design process. Features of the C++ language are introduced as their need arises in the program, giving the reader a great perspective on why they exist and how they are used effectively in real programming situations. You will learn how to truly utilize C++ as the tool for solving problems and designing great software. At the end of this book, you will have the tools necessary to advance in the world of C++ with great confidence. Without reservation, enthusiastically recommend the two "Who's Afraid of..." books to anyone interested in truly learning C++. I pity those who have to learn it any other way!

The genius of Steve Heller has created a masterful sequel to his original work "Who's Afraid of C++." His treatment of complex topics like encapsulation, inheritance, and polymorphism demonstrates an understanding of the difficult process of learning advanced C++ concepts. Steve's goal is to help the reader understand how to create his or her own class as opposed to simply referencing classes created by others. His writing style, which includes using a student-teacher dialogue, is unique in the world of C++ instruction. All of the topics covered follow a logical progression of thought. His in-depth treatment of memory addresses and program instructions enables the reader to see at a glance the complex workings of the execution of a C++ program. The highpoint of the book has Steve teaching a unique method for the creator of a class to hide pointers from the user of a class in order to prevent many of the common memory-allocation problems associated with C++. As he did in the original "Who's Afraid of C++", Steve encourages the reader to build a working example of the techniques covered in the book. The software included with the book has the source files used and a C++ compiler on CDROM. There is also an e-mail discussion group that allows the reader to contact other readers and Steve himself regarding issues covered in the book. In addition to all the C++ covered, Steve offers his thoughts on the Y2K problem and its consequences. If you really want to understand C++ and develop your general programming skills, you can't go wrong with this volume.

I was told about this book by a co-worker who took classes with Professor Giannini. We were discussing a new project I am starting which required some internet and database access code, which (since I have done mostly GUI programming) I wanted to brush up on quickly.

This book was very well written, and seemed to address exactly what I needed. I found the sections on CGI and COM very helpful on the Internet side (part of our project is a ColdFusion page using a COM object), and the comparison of various database approaches like ODBC vs. DAO very helpful. The sample programs comparing the different database technologies was a great idea.

My only complaints would be that the index was a bit hard to use, and there was no CD provided. But, I was able to locate the source code for download on the authors FTP site.

I recommend this book for anyone familiar with programming, that needs to get working quickly with some new specific aspect, like Internet or database.

I got this book because I was tired of diddling around with the MFC Socket classes, and none of my other books seemed to have much material outside the predefined classes (CInternetSession, CHTTPFIle, etc.). I was very glad to see the source code for the CPNSocket class, and it explained a great deal. Seeing the MFC classes just completely bypassed, seemed to prove my own frustrations.

Then, looking at the other chapters, which is rich in MFC examples, I decided I had made an excellent purchase. If you are an MFC programmer at any level, I highly recommend this book.

This book covers a lot of material on both API and MFC programming for Windows. I got it mostly for the Internet topics, since it seemed to have a pretty wide range of topics, including ISAPI extensions.

The sample programs, an FTP program, an emailer, a link lister, and others, were all very neatly written, and the source code described them in good detail. The socket class described in the book as a replacement for the MFC classes, was an amazing piece of work, and discussed each function in a clear understandable manner. I got everything I wanted out of this section, without having to purchase multiple books.

I'm glad to say that I now feel comfortable with several new technologies (to me), and have some excellent sample source code to help me understand it all. Increasing your knowledge in as many possible directions is important in this field, and this book helped me.

It's hard to say where this book fits in exactly, but it does several things nicely. One, it has a very broad range of topics. Going from basic windowing into database and internet programming, but showing the code and step-by-step instructions for each. I didn't read any of the beginning chapters, but then happened to find an interesting section on MFC subclassing with a great demo, and decided that I should probably go back and read the first part.

I especially liked the chapter on database access, and the fact that there are 3 programs that are identifical in every way except how ODBC, DAO, and ADO work with the data. That gave a great chance to compare the various methods. The introduction on database access was good for a beginner, but also had some interesting observations and hints for the more advanced.

The section on the Windows Installer, and creating installation programs is also a topic I hardly see anywhere, so having it all in one nice package was great.

If I had to nitpick, maybe there could have been more on Active Directory for Win2000. But, Win2000 was covered enough to get you started, and the PocketPC programming was covered in a bit more detail.

Summary: I liked it alot. It is right on my shelf now with the Kruglinski and Petzold books.

You can't go on a holiday to Portugal armed with only a Portuguese dictionary and grammar book and hope to converse with the local people. You will be forever turning the page here and there to construct the sentence you want to say. What you need is a phrase book: a book containing common and useful phrases such ` Where is the nearest tourist office please?' or `When is the next train to Lisbon?'.

That's what this refreshingly straightforward and intelligently laid out book, written by Keogh&Giannini, is. It is a phrase book for Windows programmers. The most common scenarios are discussed, with full code given. You won't find obscure situations such as those found in Petzold's oversized Windows Programming book like how to draw an elliptic circle in a window! What you will find in this concise book is useful code such as creating an application where the main window is a dialog box used for data entry through edit boxes. (This very common and fundamental of situations is not addressed in Petzold's book).

Each example is explained sufficiently enough for any programmer to build on or tailor to their needs. And the core explanations are embedded within the code so you won't have to laboriously cross reference with the main body of the text. How refreshingly intelligent is that?!

Whats more, for those new to the Visual C++ environment, step by step instructions on how to use it to enter the code and build it are given in list form e.g. 1) Select File/New menu choice 2) select the Win32 Application project type, and so forth. Most Windows programming books often make the assumption that you know your way around the environment.

And you will find each example written in both MFC and Windows API! Name me a book that has done that?!

The problem with so many Windows programming books on the market including Charles Petzolds and Joseph Newcomers is that they are basically dictionaries, grammar references of the Windows language. They are inaccessible. If these books were to be useful to anyone it would only be to a seasoned Windows programmer who already has a feel for the language, but definitely not for a beginner. These books are not practically organized and don't fit the needs of today's developers. For example, discussions on essential topics such as dialog boxes are left until chapter 11 in Petzold's classic; in Keogh&Giannini's book, it is discussed in chapter 3. And Petzold's book misses a number important programming issues. These are not my own criticisms by the way. These criticisms are those of Dr Dobbs Journal, arguably the most technical journal in computing, certainly more so than those that Petzold decided to quote on the back cover.

In Keogh&Giannini's book , there are bonus chapters on database programming (ODBC), internet programming, Windows CE and 2000 programming, threads, ActiveX controls and lots more.

I am giving this book 5 stars because it is head and shoulders above the rest in terms of accessibility, completeness, conciseness, modern refreshing style, and its use of novel approaches to speed up learning for the impatient novice Windows programmer.

This book delivers exactly what it promises - namely, to provide the reader with the necessary tools to use VBA against the various Access 2007 object models to amplify the capabilities of a custom Access 2007 solution. You will be shown the differences between using the DAO and ADO data access technologies, as well as the costs and benefits of using the older mdb file types versus the new accdb and project-related adp file types. A cogent explanation of the additional security features embedded in Access 2007 is also nicely covered.

The authors present a broad coverage of the subject matter which is amplified by their substantial real world experience - a nice benefit considering the myriad of texts that simply offer a better organized rehash of the help files.

A final comment will address the number of helpful sidebars presented in the text dealing with such issues as: using the "SQL Server Profiler", how to programmatically add, delete, and modify registry entries to persist user related variables; and receiving insider's expert information on undocumented legacy functionality.

An excellent text for what it sets out to accomplish.

This books was a TREMENDOUS help in writing a Human Resources application for my company. I'm no programmer--but this book helped me a great deal with some of the VB that was needed for the database. I did also rely on the internet a lot but this was a handy tool that covered a majority of the basics--the internet was for more advanced scripting. I highly recommend the book for those who work with Access often...and even for those who want to take advantage of the cool things code will enable you to do.

Access 2007 VBA is a great book for experienced and novice programmers alike. It is thoroughly detailed and yet covers the VBA basics at the beginning. What I like about this book is that it covers details that other books seem to always miss. This would include Microsoft Office integration. Or, in other words, the code that lets you work with other Office applications like manipulating Excel from Access or Word from Access. It also goes into working with Outlook and even SharePoint, which are two of the hardest to find information on when working with Access VBA. I am finding this book to be a great addition to my library and I believe you will too.


Bob Larson
Access World Forums Super Moderator
Utter Access VIP

I starting developing with Access 97 and have used each version since. I specialize in accounting applications and there have licensed several Access accounting applications for modification. This book addressed (easy to understand format) the areas that affect developers most (the U.I., code, classes). It is definitely for the experienced. It is a welcome addition to my library.

I've been using Access off and on since Windows 95 and Access 2. This is absolutely one of the best texts on VBA I have read. Examples are clear, and appropriate; and explainations are complete without being longer than the need to be. The coverage of Access 2007's new features appears to be right on the money.

Access is, of course, a database program. Unlike many of the big database programs, it is closely integrated with a quite sophisticated front end package to enable the creation of easy to use input forms and quite good looking reports to take the data stored in the database and present it to the outside world in a clear and useful format.

A database is useless unless you have a way to put data into and take it out of the database. This book mostly covers the setting up of input forms and output reports. It obviously won't be your only Access book, because you'll need something to describe how to set up a database. So this is a specialty book, that does an excellent job of covering this important aspect.

Selecting data out of the database to then present is sometimes a problem. Most beginning books just use the Access QBE to produce the data. Often this is enough, but this book goes just a bit into SQL that allows you to do so much more. While this is not a book on SQL, this is a good start to give you enough information to know if this is a direction you need to go.

All in all, this is a very useful book to enable you to get more utility ot of an Access database.

First, it is important to realize what this book is not. It is not a complete Access reference book. It will not teach you database theory and all aspects of data normalization. It does not cover advanced techniques such as VBA programming, the ADO object model or using the Windows API.

So what do you get from this book? A fantastic introduction to developing forms, reports and queries. In the tradition of the Dummies series, the author gently guides the novice towards building expertise in this narrow but all important aspect of Microsoft Access. With a conversational style, each step in creating a report, form or query is clearly explained. Also, the reasons for creating a report or form, and the differences between the two are presented. Although the title doesn't mention queries, because they are integral to producing reports and forms, several chapters deal with queries. Finally, two chapters discuss enhancing queries with SQL and troubleshooting those queries when things go wrong.

In summary, by spending a few days with the author, via this book, a beginning Access programmer can quickly become adept at designing forms and generating reports.

I bought a bunch of Access books, but this one is by far the most helpful one yet. It shows me how to do a lot of things I've wanted to do, but simply couldn't figure out on my own (or from any of those other books). You really need to add this one to your collection!

I use Access daily and thought I knew it pretty well. But this book really showed me a lot of new tricks I couldn't find anywhere else. This is by far the most useful book on Access I've found!

I have shelves filled with computer "How To" type books and in the past have stayed away from the "Dummies" series thinking them to be a bit too simplified. However, recently I needed to get up to speed with Microsoft's Access, specifically in order to prepare reports. So I bought Access Forms & Reports for Dummies by Brian Underdahl. I found this book to be a refreshing diversion from the normally dry and sometimes obtuse computer books of the past. Mr. Underdahl has a colloquial writing style which is not only entertaining but highly informative. Within a very short period of time I found myself successfully creating Forms and Reports which made my work go much smoother. I highly recommend this book to anyone who needs to understand Access and quickly create Forms and Reports.

If you are working with Filemaker Pro files on the web, this book is essential. Although the title says, "Advanced," I think it would be perfect for beginners also.

I particularly appreciated the expository style of the book. In a way that I haven't found in many other computer manuals, the authors start with a real problem the reader has and show how to solve it, adding interesting general commentary along the way. For example, I had a problem developing an XSLT document to import variable numbers of repetitions of a field - there, on pp. 330-333 is a brief statement of the problem, specification of a solution, and clear explanation of the code. I recommend this book to any FMPro user who wants to work with FMPro and CDML, PHP or XML/XSLT. Well done! I hope these authors produce other books of the same calibre.

This is a very good book, and if you're looking to web-enable your FileMaker 6 application, this is pretty much the only source for in-depth information that's available.

However, this book definitely left me wanting more. I have been building a fairly sophisticated web application in CDML using the Web Companion, the web toolkit that comes built into FileMaker 6. This topic gets less than 50 pages, and feels light. Many of my questions went unanswered. This topic could have been 100 pages, easily.

Two other toolkits, Lasso and PHP, while great options, require you to acquire and install add-on software. Each gets 60+ pages in the book. It's great that there's additional information (possibly required to cover installation), but devoting that much space to things not built into FileMaker, while not giving enough depth to the built-in component, seems like the wrong focus.

Another flaw with the book is that it doesn't really cover larger-scale applications. You get information about how to access, search, modify, and delete data, but you don't really get advice about how to structure a full-blown web application. Things like managing user sessions, authentication, etc., really are not covered at all. You'll need another book (which won't use FileMaker as an example at all) to get information about these basic web application topics.

In the end, this book gave me enough information that I could get started, and a good enough CDML reference that I've been able to figure out a lot more on my own. That makes it quite a good book, well worth the money spent. I would love to purchase an expanded 2nd edition.

I should note that it remains to be seen how well this book will hold up after FileMaker 7 Advanced Server is released. There's a lot of changes in FileMaker 7, and all of the web functionality has moved to the Advanced Server (not yet released), so many things may change...

This is more than a book, it is really a course in web development. The authors communicate the material in a way that is easy to understand, and the book is filled with examples that you can do as you read. Although the focus is on FileMaker, the knowledge you'll glean will apply to web development efforts with other databases as well. I reviewed and skimmed the chapters out of sequence in order to get a sense of what the book had to offer. Once I had that overview, I began to read the chapters in sequence and I think that's the best approach, as material in succeeding chapters builds on the previous chapters. No stone is left unturned as XML/XSLT, Instant Web Publishing, CDML, Lasso, PHP and Web Services are covered concisely, yet in depth. Take your time with this book; after working through the material you'll be prepared to do web development using any of the aforementioned technologies.

This is one of the first books that goes beyond a mere rehash of the manual, like most FileMaker books out there. This book is a treasure trove for those who already have their feet wet in FileMaker and are looking to go to the next level.

Although the title suggest otherwise, Advanced Rails is really required reading for anyone using Rails - beginners and gurus alike. The information provided is excellent, with essential tips and sound advice. In particular, the chapters on routing, security, internationalization and database issues are well worth the purchase price. Like Obie's The Rails Way (Addison-Wesley Professional Ruby Series), this book should live on your desk in your workspace. What's missing? Well, it would have been nice to see information on Git considering the effort put into covering source control systems. It's also surprising that there is not more on testing techniques and issues. But overall, this book is fantastic, and chocked full of juicy info you won't find in any of the other Rails books currently available.

This book is almost worth it just for the first chapter's dive into Ruby metaprogramming, but the rest of the book doesn't disappoint. Ediger delivers useful advice regarding available methods, alternatives and considerations that all serious web developers should take into account.

This book should be non-optional for all Rails development teams, as it has some of the most sane and sober treatment of relevant topics I've ever read in a single book. From security to databases to deployment, this book gives the reader a solid foundation in nearly all of the major disciplines involved in building web applications.

As Ruby on Rails rocketed into the development community's hearts and minds a few years ago, the number of books on the subject climbed with it. However, a lot of these books were introductory in nature (Agile Web Development with Rails, Beginning Rails, Build Your Own Rails Applications, etc.). What's a budding Rails-head to do once they've gotten the basics down? Books like Advanced Rails -- which was released late last year by O'Reilly - aim to fill this void.

Author Brad Ediger has been kicking around the Rails scene since the pre-1.0 days. Though not a Rails "luminary" necessarily, he certainly qualifies as an advanced user. He is CTO for a Real Estate tech company called Tasman Labs and runs a web design (and Rails consulting) firm called Madriska Media Group. He seems like a sharp cookie and a decent writer.

Advanced Rails covers quite a bit of territory, going for breadth rather than depth most of the time. Each chapter covers a classic, pivotal development concern... well, at least most of them do. The chapters are as follows:

1. Foundational Techniques
2. ActiveSupport and RailTies
3. Rails Plugins
4. Database
5. Security
6. Performance
7. REST, Resources, and Web Services
8. i18n and L10n
9. Incorporating and Extending Rails
10. Large Projects

By "Foundational Techniques", Ediger is referring to Ruby and Rails techniques, principals and patterns like Metaprogramming, Don't Repeat Yourself, and Functional Programming techniques. The chapter also goes into a fair amount detail about the Object/Class/Module relationship. A bunch of this may not be particularly new material for most Rails users who've been at it for at least a few months. However, it's still nice to have all this stuff in one forty page chapter... good to have handy to refer to. Also, there are some nice nuggets in there that could save you some head-scratching. For example, what's the difference between Kernel#lambda and Proc.new? The answer is that, if you *return* a value from the block passed to Proc.new, the calling method is exited as well, abandoning any code that you might have after it.

If the first chapter feels like it's leaning towards a reference work, the second chapter -- which digs into all the goodies offered by ActiveSupport and RailTies -- pretty much falls over right into reference-land, complete with a method-by-method listing of features added to standard library classes. This may seem even more like just putting api docs available online into print, but Eidger defintely adds a bit more explanation. And, I haven't really seen anyone give a rundown of just what the heck RailTies does. That's the library that provides the glue to pull together the more famous Rails libraries to make it all work together as rails: generators, initializers, etc. There is definitely some interesting and not necessarily readily available information here.

Chapter three covers Rails Plugins, and is quick and painless. It explains the common files and directory structure in a plugin and talks about how Rails loads them. It also talks about using Piston instead of svn:externals to manage plugins and show some example plugins.

The following three chapters cover more of the classic eternal problems faced in running high-traffic sites: databases, security, and performance. These really make the most sense in an "advanced" book; they are the "brass tacks" that everyone must get down too if they go beyond the "toy app" stage. Ediger talks about the strengths and weaknesses of the various popular database systems. He also goes into the benefits of using the filesystem to store data, which is largely because web servers can make use of fast system calls to dump files straight into the TCP socket. He also covers some advanced db features like composite keys, stored procedures and clustering.

The security chapter isn't all that long and a lot of the info it covers can be found in beginner Rails books... SQL injection, cross-site scripting etc. However, the book would be remiss to not include this material and it is presented in a concise and complete manner. This would be good to refer back to now and then to make sure you haven't slipped in your security awareness. Ediger also doesn't hesitate to make specific recommendations, like "whitelist rather than blacklist".

He also jumps right into recommendations while writing about performance optimization in the next chapter: "Algorithmic improvements always beat code tweaks", "As a general rule, maintainability beats performance", "Only optimize what matters", "Measure twice, cut once". He then goes on to cover specific tools and techniques for uncovering your bottlenecks, from a quick explanation of basic statistics to using httpperf, benchmark, and Rails Analyzer Tools, improving database calls (using indexes and "include" on finders), and the various caching solutions. There is plenty of good information in this chapter; also a good bit of reference next time you need to track down a logjam.

Chapter seven covers RESTful Rails, from the very basic theory as outlined by Roy Fielding to exactly how Rails has chosen to use these concepts, and is the longest chapter in the book. The amount of coverage REST gets seems questionable since Rails has been very heavily into the RESTful approach for over a year and embraced the philosophy so thoroughly that it's hard to imagine anyone using Rails today without being exposed to the concepts.

On the other hand, one can still wire up verb-oriented actions in routes.rb and might be able to get away with ignoring all the RESTful goodness. So maybe there are some out there that can benefit from this chapter. Plus, having such thorough, theory-to-practice coverage allows the chapter to stand on its own as a solid reference to the whys and hows of RESTful Rails. It also has one of the better sections on RESTful routing that I have seen (routes being one of the more mysterious and sometimes frustrating pieces of Rails).

Rails has gotten plenty of grief for its lack of official support for Internationalization and Localization, but in Chapter eight, Ediger lays out the options, such as gettext, Gibberish, and Globalize. He is most enthusiastic about this last library and it does appear to be quite powerful, including support for translating strings, translating model fields, localizing numbers and dates, and even recording what needs to be translated by saving them in the database. Creating multi-lingual websites is a hard problem in any web-development framework and most other frameworks have plenty of head start. However, Ruby and Rails certainly isn't without options and it will only get better.

The next to last chapter of Advanced Rails runs through a number of alternatives to the standard components of the Rails framework. On the database end, it covers DataMapper, Ambition, and Og, giving this last one the most attention. For alternatives to ERB templates, Ediger talks about Markaby, Liquid and Haml, all in a very brisk fashion. He also talks about using traditional Rails components -- like ActiveRecord and ActionMailer -- outside of Rails applications. The chapter closes with a discussion of how to contribute to Rails (hint: submit a patch... don't just bitch!).

The last chapter is called "Large Projects" and covers some useful information about working on a Rails project with a team, beginning with version control (though anyone who is writing code that covers more than a single file and *not* using version control is just plain insane). This starts with a quick overview of Subversion, however this feels like it is really a set up for making a case for "decentralized version control". Ediger does a good job of explaining these concepts, using Mercurial for his examples. This seems a bit unfortunate, since many people on the Rails core team have embraced Git and it is looking like Rails will eventually move its repository to Git. However, Mercurial has a reputation of being more user-friendly, so that may have influenced his decision. And it's useful information regardless.

Chapter ten continues on to discuss avoiding migration numbering collisions, issue tracking, keeping Rails and required gems within a project, web servers, load balancers, production architecture and deployment tools like Capistrano. This is all covered in a fairly quick fashion so don't expect a lot of depth.

That last sentiment came up often while reading this book. It often felt like Ediger was trying to get every possible Rails-related topic into the book that he could, but didn't want to come out with some 1000-page behemoth. Plenty of the topics mentioned don't have much more coverage than you could get with a quick "googling". However, there is something to be said for being exposed to a lot of tools, projects and concepts in one go, even if the exposure is sometimes superficial. I definitely found reading this book worthwhile and will keep it around to refer back to now and then. I don't know if I'd go so far as to label it required reading, but then again books on web frameworks rarely are.

With 'Advanced Rails' the O'Reilly family of Rails books is looking to add a Rails book that talks about some of the extra stuff you can do with this great technology. At 300+ pages long this isn't a book with 'Learning' in the title, rather it assumes that you have some fundamental Rails knowledge and are looking to improve your skill set.

Chapter Overview:

01. Metaprogramming
02. ActiveSupport and RailTies
03. Rails Plugins
04. Database Stuff
05. Security
06. Performance
07. REST and Web Services
08. i18n and L10n
09. Incorporating and Extending Rails
10. Large Projects (Source Control and the like)

Rails is a powerful framework but it isn't an easy one to always understand and get working. If you are looking to use Rails in your web app and want to get better at understanding the ins and out of it, this book can really help fill in the blanks.

If you want to become a better Rails developer/admin pick up this book and get better immediately.

**** RECOMMENDED

For a programmer who doesn't work in an office full of rails gurus this book answers a ton of questions I would like to ask, but have no one I could ask.

Half of the book is bits of rails wisdom mixed in with recipe like code snippets.


A very timely book for me. I especially like the further reading sections at the end of each chapter. The book is new enough that all the links are current, and I have learned a few nuggets of knowledge from these as well.

The section on globalize was immediately useful on one of my current projects and returned my investment in the book many times over.

No wonder amazon only has one left today.

This is a great commentary. In an expository manner, he explains each book of the Bible in detail. Wiersbe gives background information on topics that help make each passage more clear. It is always beside my Bible when I study! I highly recommend it.

I have found Wiersbe's commentaries very helpful in my study of the New Testament and in particular our recent study of Revelation - the Commentary on Revelation had many very helpful thoughts which I found very useful as I prepared Bible studies for my group.

I have not completed reading these books but so far they are exceeding my expectations. Great books for anyone wanting a greater appreciation of the word of GOd and seeking to know him(God) better.

As a Bible college graduate and youth pastor, I could not do without this commentary set. Wiersbe uses everday illustrations and gives a good explanation of the text. However as with many commentators, some difficult passages are skipped.

I use these all the time in my studies. Wiersbe writes at a level anyone can understand and provides many insights that his years of study and devotion have provided.
I would recommend both volumes to anyone wanting to gain a deeper insight into the New Testament.