About 3 or 4 weeks ago, John offered a free copy of his new book The Referral Engine to a handful of bloggers in exchange for an honest review of the book. I sent John my information and was lucky enough to be picked – so here we are.

Disclaimer: I am not being paid for this review, and I do not have any affiliation with John Jantsch. However, I did receive a free copy of the book.

The Referral Engine: Teaching Your Business to Market Itself

Overall, I would definitely recommend this book to any small business owner. At 230+ pages it’s a quick read and very easy to follow. I would say that 75% of the book is basically common sense – be honest and trustworthy, offer excellent service, communicate with your customers – but The Referral Engine also highlights the most effective strategies for getting referrals.

John starts the book by outlining the realities and qualities of referrals. Why do people make referrals? There’s a handful of obvious reasons, but many companies don’t capitalize on the fact that their customers want to refer business to them. John then explains the 4 C’s of Marketing (Content, Context, Connection, and Community) and explains the Customer Life Cycle.

At this point (and we’re only 55 pages in!), the reader ought to have a solid understanding of the referral process. But John doesn’t stop there – he goes on to give us a real marketing strategy for generating referrals.

What I Liked Most

If I had to pick a chapter I liked the most in The Referral Engine, I would probably choose Chapter 12: Snack-sized Suggestions. Throughout the book, John gives a variety of examples and anecdotes that illustrate how real-world businesses utilize their referral strategies. Chapter 12 contains 14 pages of industry-specific ideas for generating referrals and sales leads, and each would be simple to apply to any small business.

My favorite idea from The Referral Engine (which I’ve already started doing) is to promise your clients they’ll be so satisfied with your work that they will tell everyone they know about you. It’s a brilliant idea… assuming you actually deliver on that promise.

Conclusion

Now that I think about it, John’s approach to marketing The Referral Engine is to simply generate referrals. He asked me for an honest review – and I will happily recommend this book to anyone. It’s a fantastic book, a quick read and full of simple (but effective!) marketing ideas. Kudos!

ASP.NET 3.5 Application Architecture and Design was written by Vivek Thakur and published in 2008.

Who This Book is For

This book is intended for developers who have “basic understanding of the ASP.NET framework, and programming knowledge of either C# or VB.NET”, although it looks to me as if every example is written with C#. The word basic is a relative term, but Vivek seems to use it accurately – you don’t need to know that much about ASP.NET in order to comprehend this book.

Furthermore, Vivek states that “if reading about application architecture usually confuses you or sends you to sleep, then this book will be perfect for you!” He’s not lying. Vivek does an outstanding job explaining complicated concepts using everyday analogies.

Getting Started

Vivek starts the book by introducing the reader to the world of software architecture. He uses the analogy of an automobile company, where mechanical engineers, design engineers and the assembly line staff all have clearly defined roles – roles separated from each other for a variety of reasons. Vivek equates this process to that of the software “project life cycle”, and then moves into a discussion on software tiers and layers.

From there Vivek dives into n-Tier software architecture, giving some great examples along the way. I loved his approach to this topic because he starts at the beginning (a 1 Tier, 1 Layer application) and moves step-by-step towards a fully n-Tier application (his example uses 6 Tiers). The author also sticks to the same example (an order management system, or OMS) which helps the reader easily understand how a 1 Tier application is different from a 4 Tier.

I also really appreciated Vivek’s instruction on how to add new class libraries to Visual Studio. For readers who aren’t well versed in VS, this is definitely something useful.

Lastly, I thought it was a great idea to introduce the concepts of Data Transfer Objects (DTOs), Lazy Loading and distributing assemblies across multiple machines. Vivek’s explanations of each subject were clear and concise – perfect for readers with only “basic understanding of the ASP.NET framework.”

Moving On

About halfway into the book, the author moves into discussions of MVC and SOA design patterns. The only thing I really didn’t like was the introduction of the Windows Communication Foundation (WCF) in chapter 7, and that’s because Vivek only spent 4 pages on the subject. WCF is also the only .NET-specific topic in the entire book; I understand why it was introduced, but it felt rushed and (as someone who isn’t an expert ASP.NET developer) I didn’t get much out of it.

On the other hand, I really enjoyed Chapter 8 (Database Design). Vivek’s conceptualization of the domain model vs. the logical data model is spot-on, and I would recommend that any developer looking to build a database read it. I particularly liked the author’s example on page 197 for data normalization: who knew that the members of Metallica wrote books on ASP.NET? Sweet!

The Final Verdict

I definitely enjoyed reading ASP.NET 3.5 Application Architecture and Design. Overall, I think I would say that anyone interested in software architecture and design (regardless of the language used in development) could get a lot out of this book, minus a handful of exceptions (see my comment on WCF above).

Nice job Vivek!

ASP.NET MVC 1.0 Quickly was written by Maarten Balliauw and published in early 2009. The book caught my eye as I’m currently working on a project using ASP.NET MVC and I decided I could probably benefit from reading this book.

Who This Book is For

This book is intended for “ASP.NET developers who want a fast-paced guide to building powerful web applications using the ASP.NET MVC framework.” I’ve been using .NET for a few years now, though admittedly I never learned Webforms. Although I consider that a blessing, a knowledge of Webforms is somewhat assumed in this book. All of the code examples are written in C# so you should be familiar with that as well.

Beginners may want to shy away from this book until they’re really familiar with web development concepts and know their way around Visual Studio.

Let’s Dig In

Chapter 1 discusses what MVC (model-view-controller) architecture actually is and dives into reasons why a developer may want to choose ASP.NET MVC over traditional ASP.NET Webforms. My only complaint about this chapter is that the author gives any reason to use Webforms. Yes, Webforms have a lot of built-in controls and event handlers – but let’s be honest, they’re not really very good tools. As a JavaScript guy, I’ll be the first to point out that you can develop data-driven solutions with frameworks like ExtJS that are cross-browser compatible and W3C compliant… plus your application will simply look better out-of-the-box.

Chapter 2 has the reader create a new MVC Application. Maarten shows us what a new MVC project contains by default (he calls it “inside the box”), which is a rather helpful introduction to ASP.NET MVC as it’s complete with screenshots from Visual Studio. I particularly like the “Employee” example, and Maarten does a good job showing the reader how the model/view/controller interact with one another. That being said, the author changes things in each class as the chapter progresses without highlighting or bolding the code sections which have changed – which makes it a bit hard to follow. Maarten also shows us how to build a Unit Test but doesn’t tell us how to run the tests.

The Train Runs off the Tracks

When I got into the third chapter, I have to say that I very quickly became frustrated with the author. Maarten says the following phrase at least 4 times in this chapter: “The examples in this section… can be found in the sample code for this book.” Translation: Go and download the code if you want to follow along, because I’m not going to explain what happens next very well. The book is less than 200 pages (not counting the appendices), and I really wish Maarten had simply pasted the code samples into the book.

I also felt like the author used too many customized examples (extending a built-in class to do X, Y or Z). I’ll agree that this kind of information is useful, but this approach forces the user to endure tangent after tangent. All I wanted was to learn how the MVC framework works – but the use of advanced examples prevents the reader from learning ASP.NET MVC 1.0 “quickly”.

Lastly, Maarten doesn’t talk about unit tests (one of the best reasons to use an MVC framework…) for most of the book. It’s mentioned in Chapter 2, but then we don’t hear about it again until Chapter 9. Personally, I think the author should have asked the reader to build a unit test for every example in the book – but maybe that’s just me.

Some Things I Did Like

Chapter 5 (Routing) had some useful information in there, specifically with regards to creating route patterns. I also enjoyed Chapter 7 (Using Existing ASP.NET Features), where Maarten explains how to use built-in ASP.NET features (like security, globalization, etc.) into an MVC application.

I’m mildly impressed that the author took the time to write Chapter 8 (AJAX and ASP.NET MVC) using jQuery in addition to ASP.NET AJAX. Good concepts, though Maarten again failed to tie any of this back into the previous 7 chapters.

Final Thoughts

I did get some good information from this book, and it’s probably worth reading if you want to learn ASP.NET MVC. I say “probably” only because I don’t know of any books which explain the concept more clearly or in a more organized fashion.

In my opinion, it would have been much smarter to have had the reader build a single application – adding features and parts as each chapter introduced a new concept. But Maarten Balliauw didn’t do that, and I think it really hurts the book. The reader is forced to jump from concept to concept, and not all of the examples follow the “best practice” for an MVC application – to separate functionality into complimentary models, controllers and views.

For example, Chapter 3 has a “Contact” model which interacts with the “Home” controller. There is no “Contact” controller in the author’s example, and we never actually create a view. (I take that back… it might be there in the book’s sample code – but I, like many readers, will never bother to download it.)

The biggest problem for this book is that it reads like a college textbook. It’s full of good information, but students want to learn by doing rather than memorizing definitions and abstract concepts.

Overall, I’d give the book a 3 out of 5 stars. Not terrible, but far from great.

Disclaimer: I am not getting paid for this review, but I did get the book for free. I don’t work for ExtJS or Packt Publishing.

Who this Book is for

ExtJS 3.0 Cookbook is definitely geared towards JavaScript developers who have some basic understanding of and experience with ExtJS 3.0. If you’re brand-new to ExtJS, you may want to wait a few weeks until you’ve spent some time playing with the various components and layouts that ExtJS offers.

As an experienced ExtJS developer, I can say with absolute certainty that I learned some new tricks while reading this book.

Let’s Start with the Bad

I want to start by pointing out the things I didn’t like about this ExtJS 3.0 Cookbook. Why? Because you should read this book, and I want you to walk away from this post remembering the things I liked!

Overall, a general complaint I have about the examples is that many of them are similar to those given on the ExtJS website. If I were writing my own book (which I haven’t done…) I would try to come up with more unique examples. Jorge did spend some time doing that – but not enough time for my liking.

Chapter 1 (DOM and Data Types, the ExtJS Way) seemed a bit all-over-the-place. While the examples and explanations were well written, topics like building custom ExtJS extensions are complicated. For developers new to ExtJS, a more in-depth focus will absolutely be necessary. Topics like sniffing the user’s browser or OS aren’t advanced enough to interest seasoned ExtJS developers. Overall, I thought Chapter 1 was a bit of a waste.

Chapter 2 (Laying Out a Rich User Interface) doesn’t mention HBOX and VBOX layouts – two of the most useful layout containers. These layouts were new features in ExtJS 3.0, and I’m disappointed that Jorge didn’t give any explanation of them.

Chapter 6 mentions a drag/drop implementation between two grids (basically the example seen here) – which is a great introduction – but only spends 4 paragraphs explaining the example. Drag-and-drop is one of the most useful (and often confusing) concepts in ExtJS, and I’m disappointed that this example wasn’t expanded. In fact, Jorge probably should have devoted an entire chapter to this example, maybe even adding some extra functionality.

I also thought it was odd that Chapter 7 (Keeping Tabs on your Trees) covered TabPanels and Trees at the same time. Although I often use the two together when building my user interfaces, I think the topics could have been covered separately and each given more attention. Specifically, I don’t have much experience with the ColumnTree extension or drag/drop between TreePanels… I don’t know why they’re in the same chapter as the TabPanel.

Lastly, I don’t know why Jorge added the Ext.Slider() to Chapter 9 (Well-charted Territory). The Slider() isn’t a chart, and he doesn’t add it into an example using a chart. It’s just out-of-place.

Things I Really Liked

Throughout the book, Jorge Ramon shows the reader examples using three distinct headers:

1. Name of the concept
2. How to do it…
3. How it works…

Ramon’s approach to explaining the examples is virtually flawless, and the box-style headers make it easy to follow. I haven’t seen too many coding books use this technique, so kudos to whoever thought of it!

Chapter 2 (Laying Out a Rich User Interface) has a lot of good stuff. I was particularly impressed when I saw the Portal drag/drop example, although I didn’t really dig deep enough to see if it’s the same example shown on the ExtJS website. In either case, Jorge did a great job explaining how it all works!

Chapter 3 (Load, Validate, and Submit Forms) was more useful to me than I thought it would be. Forms are the basis of web-based applications, and any developer using ExtJS has (more than likely) had to create Ext.form.FormPanel() objects at some point. Awesome tips included: changing the location of validation errors and auto-validation of URLs/email addresses.

Chapter 4 (Fun with Combo Boxes and Date Fields) has a lot of great examples for customizing these two widgets. The best samples in this chapter involve XTemplates and data-paging on the ComboBox, and disabling days/dates in the date picker. I actually didn’t know you could disable days/dates on the date picker widget… I learned something!

Chapter 5 (Using Grid Panels to Display and Edit Tabular Data) didn’t really teach me anything new, but I will say that I was impressed by the number of examples Jorge uses to demonstrate the power of the ExtJS grids. This chapter covers everything from using remote data sets (in both XML and JSON) to inline editing, grouping and expandable rows. If you’re not an expert on ExtJS grids before you read this chapter, you’ll know everything you need to know when you’re finished!

Chapter 6 (More Applications of Grid and List Views) is another great compilation of examples which build on the ExtJS grid. ExtJS GridViews are (in my opinion) one of the best features of the entire framework because they allow the developer to customize the way the UI displays the data. Jorge also covers the RowEditor plugin (new in ExtJS 3.0) and dives into creating grid cell tooltips.

Chapter 8 (Making Progress with Menus and Toolbars) demonstrates a bunch of ways to make your application interactive. While most of the examples won’t blow your mind, I found that they do spark ideas to accomplish any number of things. I particularly liked the customization of the progress bar!

Finally, Chapter 10 (Patterns in ExtJS) contains solid direction for developers looking to build rich internet applications with ExtJS. In all honesty, this chapter could probably be expanded into a separate book… but it serves as a nice conclusion for the previous nine chapters. Jorge builds on many of the examples he mentioned in earlier chapters and gives some final advice for developers to move forward with their own applications.

The Best Chapter

If I had to pick a single reason to buy ExtJS 3.0 Cookbook, it would definitely be Chapter 9 (Well-Charted Territory).

Why?

For starters, the ExtJS website samples don’t do a great job explaining how to use many of the available charts. The online documentation also lacks direction. Jorge is the first person I’ve seen who thoroughly explains how to use each type of chart, and his examples are both unique and helpful. Kudos!

Final Thoughts

I really liked this book!

I’ve read a lot of programming textbooks, and none are nearly as helpful or interesting as ExtJS 3.0 Cookbook. It is a quick read for containing 356 pages, and Jorge Ramon does a fantastic job offering tips and tricks for ExtJS developers.

Regardless of your experience level, the ExtJS 3.0 Cookbook will absolutely teach you something new!