Nate Klaiber Book Reviews

Design Patterns in Ruby

Nate Klaiber — Thu, 02 Apr 2009 09:20:00 +0000

If you have been programming for any extended period of time, I am sure you have started to see different patterns emerging out of your tasks. You may find you are doing the same thing over and over again, solving problems that you had previously solved in another project. These patterns can vary from smaller chunks of re-usable code, to manage the sending and receiving of email, all the way to watching over a part of your application and triggering notifications to another part of your application. This book, Design Patterns in Ruby takes several of the principles found in the widely known book, Design Patterns by The Gang of Four, and applies them to Ruby. It's a mixture of the theory behind the design patterns, and then hands-on practice applying it to your Ruby applications. While this book is centered around patterns in Ruby, it is not about teaching you Ruby. There is a brief primer in the beginning, but it comes with the understanding that you already know a little bit about the Ruby language. Now it's time to check out some of the patterns presented in this book.

What are patterns?

The book starts off with a chapter devoted to giving background to design patterns and how they can help you build better applications. This chapter isn't a history lesson. The main points of this chapter teach you about awareness. They teach you how to look at your applications, and when and where patterns could best be applied. He gives what he calls Patterns for Patterns while developing:

Separate out the things that change from the things that stay the same.
Program to an interface, not an implementation.
Prefer composition over inheritance.
Delegate, delegate, delegate.
You ain't gonna need it.

These principles provide us the glasses with which to look through as we assess our code. You will want to keep these in the back of your mind as you read through the rest of the book.

What is Ruby?

As I stated in the beginning, this book isn't about teaching you Ruby. However, the author does take the second chapter to walk you through the basics. This chapter simply shows you a bit of the syntax, types, and constructs. This intro is very brief, but probably enough to provide a reference throughout the rest of the book if you haven't worked with Ruby before. With this primer into Ruby, the author wraps up the first part of the book and we are now ready to move on to the 14 patterns covered in this book.

The Patterns

Spotting patterns might not always be easy, even with the guidelines given in the first chapter. One of the strengths of this book is that each chapter poses a different problem and then tackles is using the suggested pattern. This allows you to see it in action, and allows you to get the wheels spinning on how the pattern is used and where else it could be used. After walking through each of the patterns, we are presented with a nice wrap-up of the pattern.

This book is not very long in length, so I won't go into great detail with each of the patterns, as they are covered very well in each chapter. You need the context to understand how all of the pieces fit together. So, without providing too much information, here is a list of the patterns covered in the book:

Template method
Strategy
Observer
Composite
Iterator
Command
Adapter
Proxy
Decorator
Singleton
Factory
Abstract Factory
Builder
Interpreter

If you are like me, then you will have read these chapters and be left with a desire to instantly start researching, practicing, and applying what you have learned. But we aren't done quite yet, there is still one more section to go. We now know what the patterns look like. We have seen the examples done solely in Ruby. Everything makes sense. But can we do more? Now we shift gears to look at patterns found in the Ruby language itself.

The Patterns + Ruby

The Ruby language itself has several patterns that make programming Ruby fun and elegant. The last part of this book shows us a few of those patterns, as they can be used extensively while building your application patterns. If you have ever browsed through the Ruby on Rails source code, then you will have seen all of the patterns listed above, as well as the patterns in Ruby. Here are a few of those:

Domain-Specific Languages
Meta-programming
Convention over configuration

Ruby is such an elegant language to work with, and it is due in many parts to these patterns found within the language. These aren't patterns solely used by Ruby, but the English-like nature of Ruby makes it fun to both read and write with these patterns.

Parting Thoughts

This book fits nicely with the Addison Wesley Professional Ruby Series, but doesn't require you to read all other books in the series to fully comprehend. While the progression of this book was done very well, starting you off with a discussion of patterns and Ruby, then diving right into the patterns, I did find myself reading this book several times. I didn't read it several times because I didn't understand it, but simply to read with a new outlook on how and where these patterns could be applied, or are currently applied out in the wild. I find this book not only to be very informative, but also an excellent reference as I look to solve different problems. If you are a programmer, you should definitely read Design Patterns. If you are a Ruby programmer, you should then read Design Patterns in Ruby.

Building Findable Websites: Web Standards, SEO, and Beyond

Nate Klaiber — Thu, 15 Jan 2009 01:14:00 +0000

While at it's core this book is about SEO, Aarron's first task of the book is to step back and look at the big picture of things and answers the question what is findability? My first experience with this term was through reading Ambient Findability by Peter Morville, and I found myself very fascinated by the subject. Aarron cites Morville on his definition of findability, and then graphically shows how this blends into the process of building a website. There are many pieces of the puzzle that fit together to portray the big picture, and it is up to us as web developers to make sure all of those pieces are in place for the end users. Some of these things include accessibility, usability, copywriting, information architecture, design, and more. That's what this entire book is about - putting the pieces of the puzzle together to create a useful, usable, search engine friendly, and ultimately, findable website.

After the first overview chapter, Aarron dives head first into the strategies and techniques he deploys. The first of these sets the foundation for all other pieces: the HTML Markup.

The Markup

This section starts off with a brief primer into what web standards is and how it is actively being applied by developers. There is no need to sell or preach web standards, as we soon see all of the benefits that are by-products of simply having semantic markup at the core. He walks through some of the essential tags that help you give context to your content. Having a clean organization and structure will allow both your end users and search engines to make sense of the content at the core. Some of these tags even include the meta tags you find in the head. He clarifies some often misunderstood conceptions of their value and use, shows how they have been abused, and then shows how they can be used for good. He makes the strong claim that accessible content is findable content. This directly relates to the different elements that can be found on a website that could potentially impede findability. Content inside of images, audio, and video are just a few of these things. He walks through the proper ways to overcome these as roadblocks, and make sure that the core content is accessible outside of those mediums. He rounds off this chapter by sharing a little bit about Microformats and how they can help add more semantic value to your pages. Through constructs such as hCard, hCalendar, and hReview, you can begin to add more meaning to your core content.

All of these things shape and set the foundation for making your content findable. It starts with good, clean, semantic markup at the core, and then we start building on that. Now that we have these pieces in place, it's time to shift gears and take a peek into the server-side.

The Server-Side

Equally as important as the markup you use to build your core, the server-side needs to receive attention to the little details to make the website work as a well oiled machine. This often times means understanding the nature of HTTP and some of the response codes associated with it. These codes are what tells your visitors where your content is. It's important for you to have one central point of entry for your visitors. Be sure you choose a canonical version and stick to it (www or non-www, it doesn't matter - just stick to one). Not only should you have one central point of access, but you should have descriptive URLs that are reflective of the content people will find on the page. The URL, used intelligently with your markup, can give you great keyword density and quality to your pages. This means stripping your URLs of their query strings or non-sensical naming conventions. This can be done through folder naming directly, or utilizing rewrite rules to make your pages accordingly.

I have moved several times in my lifetime, and one of the first things I have to do is have my mail forwarded to my new address. Without doing this, I would miss all of those oh-so-important bills. The same is true of your website. Your website is an evolution, and sometimes that can mean you completely move things around, whether on your own domain or to a completely new domain. Regardless of where the content moves, you need to let the search engines and servers requesting your website know where the content has been moved to. You do this by issuing an HTTP status code of 301 (Redirect Permanent). This means that they will now know where to find the new content, and will continue to look there in the future.

Sometimes you forget to forward your content. That's fine, but then you need to understand that your content is now in an abyss of the Internet. After looking for your content and not finding it, the server will then issue a 404 status code, letting the person requesting the site know that it can't find the content anywhere. This can range from a bland message stating the server information, to some really creative uses of letting you know the content has been moved around and lost in the shuffle. You can carefully craft this page to guide people in the right direction as they continue on in their wayfinding. This is your chance to redeem yourself and set your visitors on the right course. Using this wisely will help visitors follow their information scent and end up where they were looking to be.

Lastly you want to make sure that people can find your content, and they can find it quickly. Take some steps to optimize your content for quick response times and download speeds. Aarron introduces an array of different techniques that you can employ to make your site a little snappier for the end user. Some of these things include caching, compressing, and optimizing files.

Now the site has come to life. We started with a solid foundation on the front-end, then optimized the back-end to be prepared for all sorts of different requests. All of this keeps in line with our goal of making everything findable for our end users. It's time to add the real value to the site, the content.

The Content

It has often been said that content is king, and this still holds true on the web today. The Internet is massive. Noise is everywhere. The goal you have is to create solid content that communicates effectively and passionately about your subject matter. This chapter focuses on some steps you can take to make sure that your content is meaningful and helpful to your end users. It doesn't matter if your site is an e-commerce site trying to sell pens, or a personal blog talking about what you had for breakfast - it is important to make sure your content is quality at the core. Findability is a by-product of well organized, structured, and written content. When you start to think about the content from your end users perspective, and you are able to shape and mold your site for them, you will naturally create content that is useful.

There are many different strategies taken when writing copy. Some write solely for search engines and advertising campaigns. Some write for themselves. Some find a good blend of writing style that lets them express themselves while also inviting the user into a digital conversation. Some of the different types of content you may come across include blogs, articles, case studies, reviews, code examples, and more. Some sites let their users populate their content, either through direct articles or engaging in comments. Still others simply syndicate their content from other sources. No matter how you get the content on your site, the goal is to make it useful and relevant to your end users. This also means crafting your content wisely. Building on the core from the first chapter, using the right markup, and adding in the right mixture of keywords can help make your site more findable. Having lean markup also gives you an advantage of having a higher keyword density without all of the noise of superfluous elements and words. Use that foundation you built in the beginning to craft and place your keywords wisely throughout your content.

I still believe content is king. Take the time to make sure you have great content, and you will start to see more visitors, and repeat visitors, coming to read what you have to say. One of the types of content that Aarron discussed, and is one of the most prevalent types of sites out there, is the blog. Next we are going to look at some of the strategies in action as he shows us what it takes to build a findable blog.

The Findable Blog

This chapter is devoted to the almighty blog and what you can do to make yours more findable. Blogs, by their very nature, are saturated. Anyone can have a blog. That is why this is one of the most important content types that you need to focus on making findable through the techniques presented up to this point in the book. Aarron breaks down what it takes to build a findable blog, and this includes many habits such as writing regularly on a focused topic, give yourself a unique identity, organize your content by topics, archives, and popularity, promote your content, and encourage the sharing of your content. He then moves on to show how to do this within a Wordpress blog. He talks about installing and setting up your Wordpress installation, and then updating it to make it more findable. This includes showing some useful plugins available for you to install and coordinate with your content structure.

While a blog is not the only content construct out there, it is one of the most popular. This section walks us through the steps to creating a usable, well organized and structured blog. Many of the same practices could easily be applied to a different content construct with the same results. Hopefully by now your wheels will be turning as you see the many different possibilities. Now it's time to move on to another aspect of a findable webste: the search.

The Search

Search is never an easy task. Sure, some could use a simple LIKE query and call it a day, but there is so much more to it than that. You have taken the time to add all of this quality content, and having a robust search is your chance to really bring items to the forefront or give weight to different pieces of content. To some this may sound easy, but the reality is there are many factors at the core of building a quality search index. Luckily there are many different tools available to use to aide us in the process. Aarron brings several different options to the forefront, and discusses briefly how each one could be used. He includes both free and paid options, as you will want to find one that suits your custom needs.

Building a search engine and index is something that is out of the scope of this book alone, but this chapter gives us insight into some of the tools and resources at our disposal to start taking advantage of search without having to know all of the intricate details. With all of this discussion on creating content that is findable, Aaron shifts gears slightly to talk about some of the common roadblocks to findability and how they can be avoided.

The Roadblocks

We briefly saw some roadblocks earlier in the book related to images, audio, and video, and then looked at how we could overcome the inherent problems. This chapter goes a little more in-depth on each of those items, as well as focusing on another roadblock: JavaScript. Now, before you begin to persecute me, I am not saying that JavaScript is evil, I am simply saying the mis-use of it is evil. Aarron agrees. He discusses the inherent problems with JavaScript and the ability for search engines to follow some of the different commands. It may seem minor at first, but when you realize some of the areas you completely shut out by using JavaScript you begin to think twice. An approach to solve this problem has been around for a while now, and it's called Progressive Enhancement. Using progressive enhancement, you progressively build on to your foundation from chapter 2. You craft the core. You build the design and apply the CSS on top of your markup. This gives you great visual flexibility. Finally, you can add a presentation behavior with JavaScript which can override some default actions and present the user with a slightly more slick interface. Those who can't execute JavaScript still get the content at the core - everybody wins.

When you are dealing with audio and video, things become a little tougher. This medium can't be directly translated to the Markup layer, and therefore will require a little extra work on your part to make this happen. The techniques he presents to us are to embed Flash and video elements properly, relaying a message to those who may not be able to see that content. When dealing with audio, it is good to take some time to prepare a transcript of what was being said. This allows the content to still be present at the core.

The good news is that none of these are impossible to overcome. They are not permanent roadblocks. When you build with the proper techniques that he lists in this chapter, you are simply making your content that much more valuable to all audiences. Remember: accessible content is findable content.

The Mailing List

As we have already discussed, the Internet is a noisy place. There are many sites vying for people's attention. We can't possibly think that we will instantly win over all visitors at all times. This is why we employ different strategies to open up the doors of communication with them. We have seen this briefly with RSS in previous chapters, and now we look to the mailing list. The tough part about this is that e-mail has often been abused (and continues to be abused), and users are likely to be very protective of their information. After all, they don't want an overflowing inbox of items they never asked for. This first step is to earn their trust, and then request permission to contact them in the future. Be specific about your reasons for contact them. Let them know you will take good care of their e-mail address and won't let it fall into the hands of malicious users. All of this needs to be communicated quickly and effectively.

Just as with search, it isn't always as simply as just getting their email. You want to have a good system in place to manage, protect, filter, and prepare your email campaigns. There are many tools available for us to use (see Campaign Monitor for some great resources into managing your email lists). Again, we walk through a few use case examples, with some of them using Ajax to submit the emails - making it a quick and painless process.

It's important to keep in communication with your visitors. You can use this to let them know when you have new content of their interest. You can let them know about your new products. You can even let them know if you have moved, and invite them to check out your new digital residence. Be sure to take care of this list. Too much abuse and you will quickly find people unsubscribing. Too little and you will find the messages fall in with the rest of an often times noisy inbox.

Putting it All Together

It's time for this book to come to a close, and that means looking back at what all we have learned and how we can instantly start implementing some of our newfound knowledge. It's time to create a roadmap and plan of action. I'll say it again, your website is an evolution. The beauty is that you can make iterative changes and then gauge their effectiveness. You can see what content people enjoy the most, and conversely, what they don't like at all. Managing all of these things can sometimes seem like a daunting task. However, again, Aarron introduces some of the readily available tools at our fingertips for helping us manage our findability. The key is to remember that instant success won't happen overnight. It takes time and attention. It takes the willingness to know when you made a wrong move, and creating a plan to move in the right direction. It takes an understanding of your end users. Also, it is important to mention that each website has different goals. Be sure to continually monitor your goals and gauge your effectiveness in light of those goals.

Parting Thoughts

There are many books out there on SEO. There are several out there on Findability. There are a handful of books on HTML, CSS, and DOM Scripting. Though concise in nature, and small in size, Aarron does a great job of bridging the gap between the different disciplines and pulling those together to build a truly findable website. While I would encourage you to read books on all subjects, if you want to get a quick primer and get your feet wet, then be sure to check out this book to get you started.

Website Optimization: Speed, Search Engine and Conversion Rate Secrets

Nate Klaiber — Mon, 15 Dec 2008 12:12:00 +0000

The first line of the preface to this book reads, "We've had a website for years now, but it hardly pays for itself." This book aims to solve the mysteries that many site owners feel about the performance of their website. Some owners don't know any better, some don't know where to start, and still others rely on false metrics to make their site seem as though it is doing better than it actually is. This book doesn't contain myths. This book doesn't contain "feel-good" stats about websites. This book contains in-depth information related to every aspect of your website, and how you can turn your website into something that works for you and, ultimately, achieves the goals you set in the beginning. This may be a financial goal and your website is responsible for driving sales. This may be a social networking goal, where you want to nurture a growing community. This may be an advertising goal, where you can optimize your site for advertising campaigns. The core of this book will help you, no matter what the goal of your website. Andy King has done an incredible job of thoroughly covering the areas of performance, optimizing these areas, and then properly analyzing the results.

This book is divided up into two parts: Search Engine Marketing Optimization and Web Performance Optimization.

Search Engine Marketing Optimization

Natural Search Engine Optimization

Anyone who has ever been in charge of optimizing a website for search engines can attest to the many challenges they may be presented with. These challenges are, often times, unique to any given project. Andy starts off the book by introducing natural, or organic SEO. He explains the benefits, shows some of the core SEO techniques, and wraps it up into a very thorough ten step process to achieve higher search engine rankings. He covers many aspects such as using a professional design, the pitfalls of Flash, and lists out some of the barriers to SEO. I personally liked that he took the time out to explain what a professional design looks like. He introduces the concept here, and then goes into more depth in a later chapter. I have always seen this as one of the most important aspects to your SEO campaign. Having a solid look, feel, structure, and organization will ultimately help both humans and bots find your important content. I also liked the fact that he had a nice section devoted to Microformats while explaining the benefits of Meta Data.

Natural SEO Case Study: PhillyDentistry.com

So how do we know what he says is true or even works? The next chapter dives into a case study. Enough talking about what works, let's see some real world examples. This specific example, PhillyDentistry.com, took a site that was not professionally designed, and turned it around into something much more meaningful. While the copywriting was re-organized, much of the re-structuring took place in the markup. By employing quality markup, he was able to achieve better results, as things were all put into context. He makes brief mention of using the Lynx test to make sure things make sense. Strip your styles away. Strip your behavior away. Does the content make sense at the core? By re-working the core structure and copy-writing, they were able to see much better organic SEO results than the first iteration. This is just the first step.

Pay-per-Click Optimization

What we have seen in the previous chapters were methods and techniques of natural, or organic, SEO. These techniques revolved around the things that could be instantly done without putting money towards any campaigns. Organic SEO was about setting a good solid foundation for your website. Now that we have that solid foundation, we can look to setting up a pay-per-click campaign. PPC advertising revolves around setting appropriate goals, and targeting the right keywords for the right audience. I found this chapter to be one of the most important chapters in the entire book. I read through it twice. He breaks down setting up PPC campaigns, and then monitoring their health. He has things broken down to their mathematical equations to let you truly gauge your campaign. He mentions many helpful resources and tools for selecting your campaigns, A/B testing your campaigns, and then making sense of the results. He also mentions some of the struggles you will ultimately face while trying to manage a campaign, and some things you can do to alleviate the pain.

PPC SEO Case Study: BodyGlove.com

Again, instead of just talking about what you could or should do, Andy presents us with another Case Study to put his words into action. Here was the kicker for me: This case study wasn't all about the success of the campaign. He presented the campaign, setup the pricing, and then dove into integration. However, this was for items that were in a very competitive market. While improvements were seen, they didn't always come easy. The end of this case study was not a magical story of success, but a story of planting a seed and nurturing your campaigns - even in a competitive market.

Conversion Rate Optimization

At first glance one might confuse this with PPC Optimization. Andy defines CRO as

[...] the art and science of persuading your site visitors to take actions that benefit you, by making a purchase, offering a donation, or committing to some positive future action.

This chapter presents us with the social aspect of being on the web. We started with a core foundation, and moved to setting up campaigns based on our keywords and target market, now we look to converting the visitors into users of our site. This involves an array of tactics that revolve around the Psychology of Persuasion. This psychology is broken down into many useful strategies and topics. Next up he provides us with an exhaustive list of factors to maximize your conversion rates. Each of the 10 factors he mentions are discussed in great detail. He wraps the chapter up with important advice to Test Everything. All of the lists, and understanding how users make decisions, are useless unless you can test against them and make sure you are still achieving your goals. He shows how to test each aspect by using your analytics, but ultimately each scenario will be different based on the needs.

You have just finished the first half of the book, and you studiously implement the suggested plans and techniques. You find out they were successful and brought loads of traffic to your website, only to have your website crumble under the load. Now it's time to shift gears to a more technical aspect to find out how we can optimize our Markup, our CSS, our JavaScript and Ajax, and our Server.

Web Performance Optimization

The two-fold nature of this book may turn certain people on or off, but all of this comes under the umbrella of optimizing your site. I encourage you to read (and possibly re-read) through the different areas, even if they may seem too deep. While the first part of the book was about keeping your visitors happy, this half makes sure your server is happy.

Web Page Optimization

This chapter seems to be a quick overview of what is to come in the next few chapters. He gives a brief introduction into some of the common performance problems that servers can face, and then gives us a list of things we can do to optimize our site for the request and response life-cycle. This list is exhaustive, but many of the items are discussed in more detail in the coming chapters. This is just to get your feet wet and understand some of the common pitfalls. These include items such as optimizing your markup and removing the load of tables, optimizing your images for display on the screen, optimizing your CSS and using things such as CSS sprites to keep your styles lean and re-usable, and optimizing your JavaScript.

CSS Optimization

Some of these items may be commonplace for different developers, but include a good discussion nonetheless. He breaks down the anatomy of a CSS file and the rules inside of them. He advocates the use of a Reset Stylesheet, and then dives into another list of ten things you can do to optimize your CSS. This list includes things such as:

Replace Inline Style with Type Selectors
Use Descendant Selectors
Group selectors with Common Declarations
Use Inheritance to Eliminate Duplicate Declarations

Obviously, these are just a few items abstracted from the full list. This chapter is about not just taking CSS from a WYSIWYG output, but truly crafting your CSS to fit your needs. It's about making the CSS readable, re-usable, and taking advantage of the Cascade that we have. Simply accepting the output of an editor isn't enough. I have said it before, and I'll say it again: There isn't an editor out there smart enough to understand your cascade and needs. The advantages of crafting your own CSS means that it's more extensible, maintainable, and semantic. You can group items as your needs require, and by using the cascade and CSS2.x and CSS3 selectors you can begin to achieve an array of different effects that would otherwise be achieved through dirtying up the markup (content layer).

Ajax Optimization

Ajax became all of the buzz for a while. Everyone wanted it, but very few fully understood all of the impacts that it had on many outside factors. This chapter starts off listing some of the common problems with Ajax, and then lists out some proper applications of Ajax. Remember, the goal here isn't to just use Ajax for the sake of using Ajax, but to use it tastefully where it will ultimately enhance the user experience without negatively impacting your SEO visibility. This chapter also breaks down a list of many items you can do to optimize your JavaScript while building your Ajax applications. As with CSS, much of this refers to writing the JavaScript yourself (or assessing and relying on one of the many great frameworks out there) and keeping optimization at the forefront. Don't just accept the output from an editor, you can take the extra steps to make sure your JavaScript is performance friendly for the visitor. For small tasks, this also means you may not need to include a library. Read through this chapter to get a better understanding of what Ajax is, how it can be used tastefully, and how you can make sure it doesn't hinder performance. This chapter is by no means exhaustive on the topic, but it is an excellent primer.

Advanced Web Performance Optimization

Now that we have found ways to optimize our assets (HTML, CSS, and JavaScript), lets look at how we can optimize the server to manage the requests. This chapter includes techniques such as server-side optimization, reducing DNS lookups and also utilizing DNS domain aliasing to balance the requests, caching your frequently used objects and using HTTP compression. I especially enjoyed the topic of caching, and the many ways you can manage caching on both the server and client side, and planning for a proper caching strategy based on your needs. This chapter focuses on squeezing the most performance you can out of each and every aspect of your website. Using CDN to manage assets, using mod_rewrite to map your URL's, and taking another step of optimization to your files in the process. Using monitoring tools will also help you monitor your HTTP requests and make sure they are being served in a timely manner.

Website Optimization Metrics

This last chapter brings everything full circle. Now that you have taken the time to optimize your website, how can you measure that any of this has helped? Through the use of many helpful tools and analytics programs you will be able to constantly evaluate the performance of your website. We have briefly seen the mention of analytics software in some of the earlier chapters, but this chapter takes it to another level. This chapter is all about breaking down the analytics programs and understanding the different reports and terminology, and how they are affected by the entire gamut of changes you have made in the previous chapters. I found this chapter to be rather dense, but very useful. Entire books have been written on this subject, so this is really just another primer - but an excellent primer for you to instantly start gauging the performance of your website. Using your analytics software will allow you to evaluate the performance of your pages, run A/B testing, manage PPC campaigns, and monitor your keywords. All of this is done under roof, and can be used to cross compare against an array of other sets of metrics to get any reports you may be seeking.

So, now what? (Summary)

Creating a successful website simply won't happen overnight. There are many aspects that need to be addressed, and this book covers those in great detail. If you are working on a high-traffic website, or simply want to find a way to optimize your website for goals, then you need to pick up a copy of this book. It is very well written and organized. You don't necessarily have to read it all in order, you could pick and choose based on the topics you are interested in. The writing style also kept things interesting along the way, making great use of lists and callout blocks with more information or resources.

Companion Site

The Website Optimization Secrets companion site has sample chapters, chapter summaries, full-color figures, code, worksheets, videos, and more.

Web Design and Marketing Solutions for Business Websites

Nate Klaiber — Fri, 05 Dec 2008 21:36:00 +0000

Kevin Potts has done an incredible job of presenting the logical steps to make your site usable, accessible, and marketable. The web industry is a noisy one. Everyone has a website, and with the help of some text editors, anyone can theoretically create a website. There is, however, a big difference between simply creating a website and creating a usable website. I found the key to reading this book is to let yourself step outside of your projects. Take a look from the outside in and truly think about how to create value. Too many times we get attached to our projects and can become very narrow minded. The journey to creating a successful website isn't always an easy one. There are many decisions that need to be made before designs are created or markup is crafted. This book starts us at the beginning of that journey, and walks us through some necessary steps to creating a successful website that meets our business goals as well as connects and interacts with those around us.

The decision making process

The beauty of the web is that things can constantly shift and change. We are not working within a static environment. We have the ability to change on the fly and monitor and respond to our needs. The first 4 chapters set the foundation for creating a marketable site. Addressing your goals, visions, and needs, and setting up the proper building blocks to give you the solid foundation you need. These things include redesigning your site and your objectives, planning your platform and content management, gathering up your content, addressing accessibility issues to give your site maximum visibility, and setting up your site architecture and navigation. Within these items you find a way to tell your story. Chances are there are many other's out there with similar stories, so you need to take the time to plan properly.

Craft your words wisely. Understand the technology and the constraints. Ultimately, you need to understand your target audience and how they use the web. Without users, your beautifully designed site will be nothing more than decoration. Take the time to plan your architecture and navigation to match your user's mental models. You need to first realize that, in most cases, you are not your target audience. Step back and empathize with your users and their browsing habits. These chapters give you all of the little details you need to build a solid foundation. You now understand your goals, you have designed to the needs of your users, and you are aware of the proper tools to use (and to avoid) to let your story be heard.

It's all about the content

Now that we have the foundation, the next 6 chapters will walk use through some of the more common pieces of content found within an array of different websites. Pieces of content such as the homepage, an about us section, products and services - whichever it is that you happen to offer, harnessing the words that others have said about you, engaging your users through blogging features, and ultimately supporting your story and communicating with your audience. These pieces of content need to be structured wisely. No one piece should exist without the others. When done well, you will find ways to inter-weave your content between each of the different sections. Your homepage is a prime example of a page that has valuable real-estate and can be used to direct your visitors when you want them to go. The goal here is to not create your content in small islands, but to craft your content in a way that encourages scanability, readability, and interaction from your users.

Now we have build a solid foundation, and added our content on top of that foundation. Things are starting to fill out nicely and you are becoming proud of the the work you have accomplished. Let's not get too far ahead of ourselves, though. While things may look great, you still need to find a way to make your story known to others. That is, after all, the goal of this book, to market your website. Let's now look at some ways to get in the game.

Shout it to the hills

You have a solid foundation. You have a well crafted architecture and quality content. Now the time has come to release your site into the wild. The next 5 chapters walk through some steps you can take to become more visible. The first of these steps involve planning your server to respond to an array of different request from your users such as proper redirects, searching both outside and within your website, gracefully handling errors and respectfully guiding the users, and understanding the different contexts users may be accessing your content (online, print, devices, etc). Next up you want to cover your bases with the legalese. This can be useful in many cases to protect your business, your content, and your users. Having this in place comforts both you, the owner of the website, and the user visiting your website.

The next section compresses what could have taken an entire book. This is the process of SEO: optimizing your architecture, your content, and your requests to give you maximum visibility. This chapter gives you some very useful tips for understanding how search engines find your content, and how you can let them freely crawl your newly built website or a re-worked existing website. Careful considerations need to be taken in both instances. This leads into the last 2 chapters that discuss outbound marketing and online marketing. All of these come under the umbrella of telling your story inside of a very crowded Internet. These chapters give way to very powerful techniques to getting into the community and interacting within it. It is the art of building relationships with those around you - both websites and users.

Now what?

Building a successful website takes time. You need to allow time nurture your website and watch it grow. As we recognized in the beginning, the beauty of the web is that we can constantly shift and change to fit our needs and goals. While this book covers a broad array of topics, it covers them in a very concise and readable manner. Whether you are a site owner with little understanding of how the web works, or you are a seasoned web developer trying to find the next steps, this book will be able to point you in the right direction. Kevin shows the very value of connecting with those around you, by providing a very useful appendix of useful resources such as books, websites, and articles that expand on each of the topics found within the book. If you do any marketing on the web, then this book will prove to be an extremely valuable resource both now and in the future.

The Rails Way

Nate Klaiber — Tue, 11 Dec 2007 09:27:00 +0000

The Rails Way by Obie Fernandez is an extremely thorough book about Ruby on Rails. Addison-Wesley has another book that has always been by my side as a reference while programming Ruby: The Ruby Way. I love this book for its depth and attention to detail. Many times I wished there was a book that had the same depth and attention to detail, only focused on the Rails framework. That book is now here and hasn't left my desk for the past month. Obie Fernandez does an excellent job of walking you through the life-cycle of a Rails request, taking you into the guts to figure out how things work, and ultimately how you can extend it to fit your needs. The journey starts with looking at the available configuration options and takes us all the way through testing, deploying, and monitoring our application. With the recent release of Rails 2.0.1 - this book still stays relevant as Obie covers many of the new features and fixes in Rails 2, including ActiveResource. Lets take a look at some of the aspects covered.

The book starts off with your environments and configuration options. This encompasses everything you find within the /config folder. We dive into environment.rb and look line-by-line at each option, its purpose, and our available options. It is important to note that in Rails 2 they have extracted user configuration options into their own files stored in /initializers. This means that the environment file stays squeaky clean while still giving you options to extend.

We then take a look at the default environments in the /environments folder. Each are discussed in detail, and more information is given on creating your own environments for different needs.

The chapter rounds off discussing Rails log files, which are valuable no matter what you are doing. We inspect the default logging options and how to analyze some common bottlenecks.
Now it is time to move on and start working with controllers. This chapter starts off with an excellent quote and piece of advice: keep your business logic in the models. Fat models, skinny controllers. The controller is there to map requests between your data source and the views. We start off looking at the basics of dispatching and then move to the controller tasks. Controllers have a very important task of handling the requests and serving up the proper templates. We look at several different ways of rendering: the default actions template, another actions template, inline, text, and nothing, to name a few. We also look at rendering other data types all together. We also have another option, and that is to redirect. We get a nice list of HTTP status codes and how to properly redirect from our controllers, using the proper status code.

Next we dive into managing the filter chain. Filters are used for many things in a controller, from authentication to security settings. Managing the filters and inheritance can help you to keep your code DRY. The chapter comes to a close with a discussion of streaming files, which is never an easy task due to browser quirks.
With an understanding of our controllers under our belt, we move to routing. Routing is the process of both recognition and generation. This means routing in Rails gives you great flexibility over your URL structure and managing your URLs within your application. We look at the basics of routing, how it is recognized, processed, and the order in which it executes. If you have only scratched the surface of routing in rails, you need to read this chapter. Rails has default routes and ways for us to access the params in our controller. Looking at your views, however, you can see the areas that could lead to repetitive code. Always re-stating your controller, action, and any extra parts. This could be wrapped in a helper, or you could use the power of routing in rails and create named routes. Named routes allow us to take advantage of generation. Instead of writing link_to 'Blog Entry', :controller => 'blogs', :action => 'show', :id => @entry we can simply write link_to 'Blog Entry', blog_entry_path(@blog). This comes from creating a route like map.blog_entry '/entry/:id', :controller => 'blogs', :action => 'show'. This is a very simple example, and this chapter walks through all other options such as requirements, with_options, and setting our custom params.

The ability to manage your routes at a deeper level gives you much more flexibility within your application and helps to keep your view code clean of clutter. This chapter covers each and every detail of routing and how we can use it to our benefit.
There is an even easier way to manage your routes using a RESTful approach and Rails resources. This chapter is chock full of useful examples to help you make sense of REST and how it relates to your application. In a nutshell, Rails implements REST through routing and the proper use of appropriate HTTP verbs. Your CRUD actions are linked to each (GET and Read, Create and POST, Update and PUTS, and Destroy and DELETE). In order to benefit from RESTful resources, we need to stick to a few standards. First off, we need to create the routing resources with map.resources :books. You can have either singular or plural map.resource :session. Then we need to utilize the available methods in our controllers that correspond to our HTTP requests. These include: index, show, edit, new, create, update, and destroy. We also have the ability to serve up different content based on the HTTP request using the respond_to block. One resource could have many different representations: HTML, XML, and JSON to name a few. This means that we could have a request for /books.html and serve up the HTML, or /books.xml and serve up the resource as XML.

You have full freedom and flexibility to extend your routes with an array of other options. You could have nested routes. You could control the name_prefix and path_prefix. With each of these, Rails gives us a handful of named routes to use within our application. Using the books example we are given: books_path, book_path, edit_book_path, new_book_path. The _path part creates URLs like /book/1, whereas we are also given _url, hash, and formatted that give us the full URL, formatted URL, and hash of the URL.. This chapter discusses each and every aspect of RESTful routing and Resources within our Rails application.
Find yourself still confused with the innards of routing? The next chapter reflects on routing and dives into the console to show you how routes work. Seeing this gives you a clearer picture of how you can take advantage of the routing in Rails. We are also introduced to a plugin which is now standard in Rails 2 that lets you type rake routes in the console and get a full list of all of your routes, what they expect, and how they are mapped. This is an indispensable tool as you start dealing with nested routes with extra resources.
Now we have a firm grasp of the request cycle and how to manage the requests. Now it is time to move to the beast that is ActiveRecord. ActiveRecord has so much depth that it gets 4 chapters devoted to the different aspects. We begin with the basics and using migrations to manage our database schema. Again, we explore each and every option for our columns, types, and mappings.

Our tables have been created, time to look at our Models. We briefly look at setting our associations (more to come in the next chapter) and how Rails recognizes our associations and maps them to the corresponding database table. We look at how to do our basic CRUD and the many available options to extend your attributes and finder methods in your models. We get to see all of our options with our find and dynamic attribute based finder methods. These include :select, :conditions, :order, :group_by, :joins, and :limit to name a few.

The nice part is that you are never locked into a specific way. ActiveRecord is very powerful and has security options such as bound parameters and protection from SQL injection out of the box. However, you never have to feel limited as you can also use find_by_sql and write your own SQL if you have the need. This chapter shows us how to use all available methods, our configuration options, and managing our connections.
One of the nice parts of Rails is the inclusion of proxy methods known as associations. These methods allow you to specify that a blog has_many :posts. In return we get access to our data through @blog.posts. This is a very simplistic example, and this chapter walks us through has_one, has_many, has_many :through, has_and_belongs_to_many, and belongs_to and discusses all of our available options to each. We look at how each is composed, how we can validate against our associations, and how we can control things through the chain of callbacks. This includes building, validating, and creating association objects. Lastly we look at using Association Extensions on our collections.
Keeping your data clean is an important part of any application. Now we move on to ActiveRecord validations to see exactly how we can keep our data clean. Just as with other chapters, we walk through all available methods and options for validation of our data. Rails has many validation methods built-in, but this chapter goes beyond those methods and shows us how to do custom validations on our attributes, when to do validation in the available callback methods, and how to deal with our returned errors.
While I wouldn't consider everything in the previous chapters to be basic, it is time we moved on to some advanced ActiveRecord. This chapter is focused on taking full advantage of the array of callback methods, creating and using observers, single-table inheritance, and polymorphic models. Each of these are discussed in great detail with usage examples of each. Callback methods allow us to manipulate and work with our data at different points in the request cycle. Things like before_save, after_save, before_create, after_create, before_destroy, and after_destroy. We have different options for defining methods and registering them, or using one-line blocks. We also have the ability to define classes and calling them to help us keep our code DRY between models. In this process, it may be necessary to halt execution of the callback chain, as is the case with validation and errors.

Observers are just that. They are code that observe your models and call different code and different points in the callback chain. This works well for things such as sending emails and logging. For instance, you could setup an observer that looks for the creation of a user and then sends the user an e-mail with ActionMailer. You keep this code out of your controllers, and out of your models, but still gain the access to the model object. The work needed to register the observers on your models lies with your environment.rb where you specify which observers to use.

STI allows us to extract our business logic in several aspects. The example given is a User model that also has a Guest and and Admin User. You can have Admin extend your base User class on and extend your models as necessary for each model. This section is all about setting up your models to handle this inheritance properly. Considerations are given for STI, including overriding defaults and dealing with associations.

This chapter finishes up with discussion and configuration of Polymorphic models such as commentable and taggable, a review of class scope and context, and how to alter ActiveRecord models at runtime.
Now we move to our views and ActionView. This chapter starts off with an introduction to ERb and some formatting examples. Next we take a look at the Rails structure, organization, and naming for the views. Using variables is the most important part of the view, so we are introduced to how to use instance variables, as well as other variables made available to us by Rails. Just as with other aspects of our code, we want to keep our Views DRY. We look at best practices for managing your views, partials, and collections that make it easy for code re-use.

The last part of this chapter discusses caching. Caching takes some thought and planning, no matter what the size of the application. We look at page caching, action caching, and fragment caching. Along with the discussions related to each - we then see how to expire our stale content using Sweepers. Sweepers are much like observers that can clean out our stale content on create, update, and destroy actions. Caching is a complex subject, as there are many little pieces that must be taken into consideration. This chapter discusses some of the gotchas, and several methods to help you manage your caching process.
Sometimes we have code in our views that needs to be extracted or have some logic applied. In order to keep logic out of the views, we use Helpers. This chapter walks through each and every available helper and all of their configuration options with full examples of their usage. After dissecting all of our available helper methods, we are introduced to several ways of developing our own helpers and making them available in our views.
What would Rails 2.0 be without Web 2.0. Our next chapter dives into Ajax on Rails. The chapter starts off with some debugging tools to help us in the process, and an introduction to Prototype and Scriptaculous, the default JavaScript libraries. I must say that this chapter was the least inspiring, not to the fault of Obie or of JavaScript, but because of the way Rails embeds JavaScript inline with your HTML. We spend so much time talking about keeping our code DRY, and then we litter our markup with inline JavaScript that could easily be abstracted to an external file accessed via the DOM. My qualms aside, this chapter is much like the chapter related to Helpers. The beginning was spent explaining the available Prototype methods, then on to how they are used in the context of our application and the available Rails helpers for generating JavaScript. Several examples are given: Drag and Drop, Sortable, Autocompleter, and In Place Editors. We even have the ability to use RJS templates that allow us to write JavaScript with Ruby code. While this chapter is very exhaustive, I still believe there are better ways to manage your JavaScript.
Keeping state is an important part of any application. We now dive into session management. We look at how session management is implemented and the different storage mechanisms available to us. Other topics discussed were security and the usage of cookies. Session management will come in handy as we move on to discuss login and authentication.
The login and authentication chapter is devoted to the Acts as Authenticated plugin written by Rick Olson. Due to the different needs of applications, authentication and authorization are best left to the developer to implement. Acts as authenticated is a drop in solution to manage your authentication. The plugin creates several helper methods for us, and this chapter walks through each piece of the plugin to help us understand what is going on under the hood.
The ability of rails to handle different resources brings us to the chapter focused on XML and ActiveResource. This chapter starts off breaking down the to_xml method and all of the available options to extend and build it to your needs. This comes in handy when using the respond_to block to serve up different representations of your content. The second part of the chapter focuses on ActiveResource, the Rails 2 replacement for ActionWebService. ActiveResource shares many of the methods with ActiveRecord, so by this point things are looking very familiar. Just as with ActiveRecord, we examine all of our options with examples of each.
Another part of an application is the process of creating and sending emails as well as receiving them. This chapter is devoted to ActionMailer. We start off looking at our configuration options. After that, we explore each of the available methods. This chapter discusses sending plain text emails, HTML emails, multipart emails, and handling attachments. Once we create our ActionMailer methods, we are given instructions on how to actually send the emails. The last part of this chapter discusses receiving emails and reading incoming email messages using the Tmail API.
With so many pieces of our application in place, we now look at the methods of Testing. Rails embeds testing at the core and encourages it every step of the way. It isn't just there in case you need it, it is fully functional and there to help you write tests for each and every part of your application. This chapter walks through setting up your own tests, fixtures, and checking for errors. We see our configuration options and how rails organizes the tests within the application. We see how the tests are connected to the application and how we can use the many available methods to create our tests. With our tests in place we can run them and examine the returned results. Having this in place assures that as we develop our application our code still responds as we expect. We can develop and then run our rake tasks and make sure everything still works as expected.
Obie states:

RSpec is a Ruby domain-specific language for specifying the desired behavior of a Ruby application

This chapter discusses RSpec on Rails as a replacement for the default rails testing mechanisms. This chapter is exhaustive and dissects all available options for writing, maintaining, and running your tests. There are also details for installing it as a plugin to Rails and use this versus the default Test::Unit. This is one chapter I need to re-visit as it covers each aspect in great detail, and I don't have any experience with it (I know, shame on me).
We looked earlier at the acts_as_authenticated plugin, now it is time to look more into utilizing Plugins. The beautiful thing about Rails is that it has a solid core but gives developers the freedom to extend and build to their needs. Plugins are just that. They are subsets of code that you can install and use within your application. Rails has an excellent plugin system built in and makes it really easy to install and build your own. By using script/plugin you have many options available to you for managing your plugins. This chapter shows us how to discover, install, configure, and build our own plugins. It also shows us how to manage plugins with SVN and Piston.
We are finally nearing the end of our Rails application and it is time to discuss Production Configurations. We start off by looking at our production stack. The Web Tier, Application Tier, Database Tier, Monitoring, and Version Control are all discussed. The rest of the chapter provides configuration examples and init scripts for mongrel_cluster, nginx, and monit. The chapter rounds off with considerations for redundancy and fail-over, caching, performance and scalability, maintenance, and security.
Capistrano is a tool to help you streamline your deployment process. This chapter provides us with some Capistrano recipes as well as breaks down configuring and modifying Capistrano to fit your deployment needs.
22 chapters later and we end with a topic related to Background Processing. An opening quote states: Waiting for railsapplication.com... Background processing allows us to extract resource intensive tasks into the background while allowing our Rails application to continue to respond in a normal fashion. This is useful for application pieces that need to handle large uploads or some sort of API authentication in the background, such as Credit Cards. This chapter presents us with our available options with some example usage scripts.

Whew, it has been a long journey. The details are important when you are building an application, no matter what the user base. Rails is a very powerful framework and provides us with many built-in features that handle some of the mundane tasks. It also gives us the flexibility to extend tasks to fit the needs of our application. The Rails Way teaches us just that: the rails way of planning, organizing, extending, and maintaining our applications while keeping our code as lean as possible. While we have the Rails API available to use (Which this book also provides the entire ActiveSupport API as an appendix), this book helps to clarify some of the muddy details. Obie highlights the clarification process with his excellent code examples and explanations.

It is hard to give a 22 chapter, 830 page book, full justice in a simple review. While working with Rails I always have a tab open with the API. Still, some of the examples could use some more examples or clarification. Obie gives that clarification in this book. He does an excellent job of staying on course, while also giving you a vast amount of resources for more research. Aside from the Pragmatic Programmers books I have had a hard time finding good, quality, Rails books. There are a few that walk you through simple application examples (much like the create a blog in 15 minutes example), but none that dive in as deep as this book. No matter what your skill level with Ruby on Rails, this book is a must have guide, reference, and resource. This is the definitive guide to Ruby on Rails.

Mobile Web Design

Nate Klaiber — Tue, 04 Dec 2007 09:24:00 +0000

Mobile Web Design by Cameron Moll is a very small, but concise and thorough, book on designing for the mobile web. This book does not teach methods for designing for mobile devices, but the options available to use as web developers. Cameron does a great job of being exhaustive on the subject in a quick 102 page read.

This book starts out with some statistics and history related to mobile web usage. This gives us a snapshot foundation to work with, and Cameron relays the importance of mobile web design in the current market, as well as moving forward. To ignore designing for mobile devices now would mean leaving out a very large demographic. Unfortunately, much like the browser wars of the past, it isn't an even playing field across all devices. Cameron's testing of the different mobile devices helps us get a clearer picture, but things are still tricky. At least when you are designing for a browser, you have the ability to test in those browsers across several machines. Attaining mobile devices for testing isn't always an option for the average designer. His insight and research is very helpful as you begin the journey of mobile design.

The need for mobile web design is very clear, and could be vital to you depending on your business model. So how does one get started with mobile web design? What are the options? The advent of Web Standards taught us that it would be as easy as adding media="handheld". Cameron presents us with the following options, each with a list of their advantages and disadvantages:

Do Nothing
Reduce Images and Styling
Use Handheld Style Sheets
Create Mobile-Optimized Content

I won't attempt to re-hash each of these as Cameron does an excellent job breaking each of the options down. After discussing the options the question is asked: Which method is the best? If I were to answer this question, I would side with the option that we need to create mobile-optimized content. The research has shown that the handheld media type will be of relatively little use across the wide range of devices and mobile browsers. Ultimately, the mobile device has different contextual needs than a desktop environment. You have to deal with screen limitations, technology limitations, and speed limitations, to name a few.

Now that we have our options clearly marked, where do we begin with development? It is time to look at the XHTML/CSS development. Cameron gives us some concrete examples of markup and our options when using CSS. He walks through a basic document, from the doctype to the markup itself. While we adhere to standards in mobile development, it does not stray course from the standards we have for the desktop environment. There is no need to create new standards, only the need to build for the context. After he walks us through the HTML and CSS, he talks about device detection and sniffing User-Agents to serve up content accordingly. He admits that this approach is not 100% reliable, but gives us some examples using PHP of how this could be achieved if we wanted to venture this route.

We now have our beautifully crafted markup for our mobile devices, but how can we be certain it will appear as we hoped? We now move to the chapter discussing testing and validation. Though testing with the devices themselves is the best option, it isn't always feasible. Cameron gives us links to some great software or extensions to browsers that allow us to simulate small screen devices and User-Agent switching to test any device detection we might be using. Also, as with designing in the desktop environment, it is good to validate your code and be assured everything is in line.

As we have already seen, mobile devices present us with a different context. Next we look beyond the simple XHTML pages and tap into some other technologies that we can use. These include, but are not limited to, SMS, Java ME, SVG, FlashLite, GPS, Widgets, RSS and APIs, and AJAX. Each of these can play an important role in the contextual tools we can use. GPS for location awareness where we could perform searches based on their current location. SMS services allowing people to interact with their accounts in an easier fashion than potentially convoluted web forms. Using SVG to have your graphics scale appropriately for the device. Using widgets, such as with Blue Flavor's Leaflets. Each of these tools gives us more flexibility and power to create context sensitive interfaces. This chapter only scratches the surface on the possibilities.

Now all of your pieces are in place, it is time to promote your content and let people know you exist. This chapter discusses several options to promote and make people aware of your mobile content. Do you want to create a .mobi site, giving users a familiar address to use? Do you want to advertise online in the right arenas? There are several options you have, the first of which would be promoting from your own site. Exploring your options will help you choose the best plan of execution for exposure.

This book rounds off with a plea from the author for a more desirable mobile web experience. He states:

The production of desirable mobile user experiences will require the combined efforts of device manufacturers, browser developers, content providers, and ultimately you

Don't let the size of this book fool you into thinking it has little to share. This book is packed with valuable information from page 1. Each section is very exhaustive, with content, photos, illustrations, and links to other resources for extended research. For those who might need more persuading, you can download a free sample to check it out for yourself. Also, if you know of someone who would benefit from this book (including yourself), order before December 15th for a special holiday discount (it could even be used as a stocking stuffer).

Accelerated DOM Scripting with AJAX, APIs, and Libraries

Nate Klaiber — Tue, 23 Oct 2007 08:21:00 +0000

Accelerated DOM Scripting, Ajax, APIs, and Libraries by Jonathan Snook, Aaron Gustafson, Stuart Langridge, and Dan Webb is not just another book on DOM scripting. There are many excellent DOM scripting and JavaScript books available to us as developers. Some are thorough explanations of JavaScript with a little bit about the DOM, while others are full blown books on the subject of DOM scripting. This book takes a slightly different direction discussing DOM scripting in light of Ajax, the array of APIs available, and the many libraries available that help us rapidly develop our applications. Upon hearing of the arrival of this book, I was worried that it might be something that would be considered obsolete the week after it was published due to the rapid rate of change in libraries and APIs. After reading this book, that worry was put to rest as each of the authors did an excellent job of digging into the guts of the libraries, exposing how things are done, how you could do it yourself, and how a library could be of assistance to you.

Chapter 1 starts us off with an explanation of the state of JavaScript. JavaScript has been abused heavily in the past, and due to this abuse and its inconsistencies - many developers chose to shy away. However, this is no longer the case. Along with explaining the state of JavaScript, we get to look at ways to manage our JavaScript code as well as debug our code. This gives us the tools we need as we begin development throughout the rest of the chapters.

Chapter 2 dives into HTML, CSS, and JavaScript. Often referred to as the trinity of front-end development, it is valuable for you to understand the purpose of each, and how they interact with one another. The basics of each are discussed, and then we move to the DOM and find out how we can use semantic markup and meaningful CSS to create the necessary hooks for our JavaScript to interact. Topics such as traversing, reading, and writing to the DOM, handling attributes, detecting browser support, and handling events are all discussed. This chapter builds from previous chapter, and prepares us as we move on to the following chapters.

Chapter 3 tackles the sometimes tough subject of object oriented programming. Depending on your background and experience in programming, the idea of OOP may seem foreign to you. However, the author does an incredible job of highlighting the benefits, formatting, and examples throughout the entire chapter. Some of the benefits discussed are: Namespaces, closures, and encapsulation. To me, this chapter was one of the most valuable in the entire book as it helps you to understand the programming at the core of the libraries that are discussed. Knowing what is going on under the hood is extremely important as you develop and troubleshoot your code.

Chapter 4 moves us to the discussion of the available libraries. As I stated earlier, I was concerned that this book would quickly become stale due to the change and development of libraries. I couldn't have been more wrong. This chapter doesn't just show you the libraries and move on. This chapter teaches you how the libraries work, how you can develop within the libraries, and explains the benefits of using libraries. It teaches you what takes place under the hood for so many different aspects. Along with teaching these things, the author gives you some tips as you are searching and selecting a JavaScript library to work with, something invaluable as there are many options to choose from.

Chapter 5 moves into the world of Ajax and Data Exchange. This chapter discusses all of the nuances of Ajax. These are the important things that need to be addressed before you start implementing Ajax in your applications. Understanding the data formats that are returned. Understanding the HTTP codes. Understanding the different ActiveX Objects. Understanding how to prepare for and handle failure. All of these things are very important as you use Ajax. After you learn what is going on under the hood and how to put the pieces together, the author shows you how libraries can help you in the process.

Chapter 6 discusses Animation, what most people think of when they hear Ajax. As with the previous chapter, you start off by building a simple animation object, then look to see what the libraries have to offer.

Chapter 7 takes us into form validation with JavaScript. All validation should first take place on the server side, then use the client-side to enhance the user experience. The tricky part comes when you find yourself maintaining two validation codebases, one in a server-side language and one in JavaScript. This chapter brings both of these worlds together and allows you to specify your validation rules in one place, sharing your server-side code with the client-side. This makes the validation process much easier and expandable. If you ever want to add or remove validation rules, you can do it in one spot and both the server-side and client-side will follow suit. As with the previous chapters, we first build our example from scratch so we understand the core, then we see how libraries can help us in the process.

Chapter 8 is a case study in building a FAQ system. This chapter walks through the process of creating a usable, accessible, and progressively enhanced FAQ system. This case study builds the semantic HTML, the necessary CSS hooks, and uses the necessary JavaScript to achieve our tasks. The process is extremely thorough as each and every piece is tackled and dissected in the building process. This case study is an excellent tutorial in using all of the building blocks we have discussed up to this point.

Chapter 9 is another case study that walks us through the process of building a dynamic help system. This current example utilizes the Ruby on Rails framework to build the application. The first part of this case study spends important time in planning and preparation. This is important in any application that uses progressive enhancement. As the author points out, this chapter starts with a solid base of semantic HTML, and then builds the CSS and JavaScript on top where necessary. The planning is in place, the foundation is established, and the hooks are in place. As with the previous case study, this chapter does an excellent job of diving in and showing you all of the little details necessary to put an application together.

Conclusion

This book went beyond my initial expectations. It is geared more towards someone who already has a good understanding of HTML, CSS, and JavaScript. If you are looking for a book to teach you JavaScript, then this is not it. This book will help you take your understanding of JavaScript to the next level, and help you grasp what is going on at the core of your library of choice. This is especially important when you have to troubleshoot a piece of JavaScript, or you have to extend something to fit your needs. This book doesn't simply leave you with an explanation of libraries, but teaches you where libraries are helpful, and how you can fully understand what the libraries have to offer. JavaScript is not evil. JavaScript libraries are not evil. This book will show you how to make proper use of the tools available to you.

Beginning HTML with CSS and XHTML: A Modern Guide and Reference

Nate Klaiber — Wed, 10 Oct 2007 21:47:00 +0000

Beginning HTML with CSS and XHTML: Modern Guide and Reference by David Schultz and Craig Cook is an excellent beginners introduction to HTML and CSS. Through each of the eleven chapters the authors walk through the basics and foundation of HTML. For those who are just treading in the waters of HTML and CSS, this book will help you understand the tools available to you as you craft your markup. You will learn about the tags available, their available attributes and purposes, and how to finely tune these into a semantic layout that ultimately gives your content more meaning.

Chapter 1 is our quick history lesson and introduction to HTML. They give background and insight into the goals and purposes of HTML, and how these were shifted during the browser wars and the battle for browser dominance and market share. They introduce the different versions of HTML available, and what they mean for your markup and the rendering inside of the browser. As CSS is discussed, there is also a discussion on keeping a clean separation of content and presentation. Chapter 1 lets us see the big picture and evolution of HTML.

Chapter 2 builds the foundation for the rest of the chapters. This chapter discusses the basics of XHTML and CSS. The building blocks discussed here will be addressed in each and every subsequent chapter of the book. Things such as tags, elements, attributes, and formatting. We are also given a snapshot view of what comprises an XHTML document, the doctype, the HTML element, and the document tree. All of this plays into understanding the fundamentals of CSS, cascade, and inheritance. We now have our history lesson and basic constructs in place, it's time to take a look at the rest of the pieces to the puzzle.

Chapters 3 and 4 cover a large territory. From constructing a useable head section, to walking step by step through many of the available HTML elements available to you as you put your content together. With discussion of each element, you are given detailed instructions of how and when it should be used, with an exhaustive list of its available attributes. CSS is briefly discussed, but will be re-introduced in a later chapter after we have our content constructed.

Chapter 5 is all about images. This chapter gives a brief primer on how digital images work, and what are the formats you can use within your content. Images can serve different purposes: icons, decoration, background, or context. Each of these are discussed with information on how to place them accordingly with CSS or the img tag.

Chapter 6 is all about linking. You are introduced to the a tag, its available attributes, and how you can create different types of links. Textual links, anchor links, and linking an image are all discussed.

Chapter 7 is all about tables. Despite what you may hear from others, tables have a very good semantic use in regards to tabular data (who would have thought?). However, tables are also misunderstood in relation to the tags and attributes. It is important to build tables with accessibility in mind, and this chapter goes over some of the elements that haven't received as much exposure. These include, but are not limited to: caption, colgroup, and tbody. This chapter will give you the information necessary to build a powerful and semantically rich table.

Chapter 8 discusses all of the little details to building a usable and accessible form. Just as with tables, there are some elements that are often forgotten about when building forms. This chapter does a great job of covering all of the necessary components for a form, and how to structure them. Form elements are rendered with the underlying operating system, so the end of this chapter discusses CSS and some of the ways you can spruce up the look of your forms. This is to be used with caution, as forms are rendered differently in each browser.

Chapters 9 and 10 discuss the other 2 pieces of the trinity of the front end: CSS and JavaScript. These chapters are meant to be brief primers, and will most likely whet your appetite to learn more about each aspect. They are also placed here to give you a good foundation as the final chapter will roll everything up into a case study.

Chapter 11 is the end of the journey. What good would the book be if you couldn't put what you have learned into practice? This chapter creates the fictional Spaghetti & Cruft website (you have to read the book to find out the meaning of the name). This chapter starts with the design process, moves to the building process, and then polishes it off by adding enhancements with CSS and JavaScript. The humorous name aside, this chapter is one of the most valuable chapters of the entire book. This final chapter brings the book to a close, and with it leaves you a solid foundation as you continue your journey of building other sites.

Conclusion

Many would argue that they don't need to learn HTML, that is what a WYSIWYG is for. This book shows you the value of understanding the history, basics, and semantics of HTML. It is important to note that nothing found in this book is earth-shattering, however, if you are a beginner and new to HTML, this book will give you the proper start you need to begin developing right away. If you are moving away from the reliance of a WYSIWYG, you may be surprised at many of the elements available to you that are covered in this book.

Professional Search Engine Optimization with PHP

Nate Klaiber — Mon, 17 Sep 2007 20:31:00 +0000

Professional Search Engine Optimization with PHP by Jaimie Sirovich and Christian Darie is a very thorough resource and tutorial on how to optimize your website for search engines, using PHP as your programming language of choice. If you are a Search Engine Marketer, there probably isn't much new information in here for you. However, if you are an experienced PHP programmer wondering how your work on the back-end affects the front-end aspect of things, and how you can be more conscious as a developer, then this is a book for you. If you are just beginning your journey with PHP, this book is a must-read.

Search engine optimization is an ever changing field, but understanding some of the core principles will help you build a solid foundation that will allow you to grow or scale with the industry. That is exactly what this book sets out to achieve: Give you a solid foundation as you optimize your website for search engines.

Without repeating the same information you can find from the back of the book or the introduction, I am going to briefly touch on some of the topics that were discussed in the book.

This book covers a broad range of topics, and does so in great detail and with excellent code examples. The book starts off with the basics of both PHP and search engine optimization. They give a quick SEO primer, including some extra resources for homework. The PHP examples start with creating basic functions, then progress into creating useful objects that are reusable and portable as you develop your sites. The PHP code is very well structured and organized, something I was pleasantly surprised to see.

Creating a site that is friendly to search engines means understanding how a search engines finds your content, makes sense of your content, and indexes your content. The first exercise begins by creating search engine friendly URL's using Apache and mod_rewrite. This allows you to create more lean and meaningful URL's.

From there they move to understanding some of the basic HTTP status codes and how they affect the robot's indexing of your website. Here you will learn how to properly redirect your pages if necessary, and how to properly flag a page as an error. All of this focuses on having one point of entry for your pages, giving you a clean index to deal with.

Duplicate content is something that is often times overlooked or ignored. This chapter discusses the details necessary to avoid duplicate content, and how to use robots.txt to block the robots from pages that could potentially look to be duplicates, such as archives.

The next few chapters discuss things such as SE-Friendly HTML and Javascript, Web feeds and social bookmarking, Black Hat SEO, and Sitemaps. All of these things play an important role in making your content accessible to search engine robots (spiders), as well as humans. It discusses such things as sharing your content, streamlining the sharing process through social networking sites, using your web site's feed to its full potential, and creating a full blown sitemap specifically for search engines. Black Hat SEO is thrown into the mix of these chapters as well as a guide of what is considered Black Hat, why it is considered Black Hat, and how you can avoid many of the common pitfalls. It is important to play by the rules, or else you could find yourself out of the game. All of these play into creating quality content that is accessible to all in an array of different formats.

Before we view some of the case studies, we look at link bait, cloaking, geo-targeting, and IP delivery, and dealing with SEO and foreign languages. These chapters seemed to cover the most controversial topics related to SEO, and the authors take a solid stance on their process and cite solid reasoning for their specific stance. Much is discussed here, more than could be elaborated in a review.

The last few chapters discussed dealing with technical issues, an e-commerce case study, working with existing websites and fixing them for SEO, and how to create a SE-Frienly blog with Wordpress. All of these chapters put SEO into action and show by tutorials and examples of how to create a SE-Friendly website. They touch on the important topic of working with a legacy system and how to migrate or make changes to enhance SEO. Wordpress, being a common platform for blogging, is briefly examined and extra resources are given to help you expand your Wordpress blog. These chapters wrap things up nicely. The foundation is set in the previous chapters, and the building blocks we create in the previous chapters are used in real-world examples.

Conclusion

Any qualms with this book are few and far between, and are mostly minor details when looking at the big picture. Jaimie and Cristian have done an excellent job of bridging the gap of search engine optimization and PHP. Good search engine optimization is comprised of many different fields and practices: copywriting, writing excellent headlines, understanding the medium of the web and HTML, and the programming that often times glues all of these things together. As a PHP programmer, this will help you make that glue stronger and more cohesive. Though this book is aimed at PHP developers, the principles explained in this book could be carried over to any other programming language of choice.

NOTE: It is important to note that, since the printing of this book, the major search engines now support the sitemap.xml format. Not all support the full extent, but it is becoming more standardized. This just goes to show how rapidly things change.

RailsSpace: Building a Social Networking Website with Ruby on Rails

Nate Klaiber — Sun, 09 Sep 2007 12:57:00 +0000

RailsSpace: Building a Social Networking Website with Ruby on Rails by Michael Hartl and Aurelius Prochazka is part of the Addison-Wesley Professional Ruby Series and does an excellent job of teaching Ruby on Rails through a hands-on, real world application. If you are like me then you probably cringed at the thought of yet another social networking site. However, after reading through the first part to this book my apprehensions were put at ease. The authors explained in the opening chapter that “There’s a tension in any educational book between the two extremes of pure tutorial and pure reference. We land firmly on the tutorial side of this spectrum—“ The audience for the book is anyone beginning with Ruby on Rails. This book assumes no prior knowledge of Rails or Ruby, and sticks to that through the entire book. Each chapter walks you through the process of creating RailsSpace, while also teaching you best practices and some of the nuances of Ruby and the Rails framework.

This book is broken into two main parts, Foundations and Building a Social Network, with each part comprising several chapters each.

Foundations

Getting Started

With the introduction out of the way, it is time to jump into building the application. This chapter assists you in getting Ruby on Rails and its dependencies on your platform of choice, and then gives instruction for setting up your development environment. Once all of the pieces are in place they move to setting up your rails application, and how to get started with your first pages. They use rails generator to create the controllers and give you an idea of the default routing of a Rails application. The rest of the chapter spends some time building views and using embedded ruby to work with your templates. For the beginner to Ruby or Rails, this part is valuable for the rest of the application. They teach the basics of Ruby and introduce you to instance variables, hashes, and symbols. It isn’t practical for them to cover everything, so they also give you direction on finding answers to questions that might arise. The first place to look is always the API. We have the basics down, we have created our application, generated some controllers, and put our navigation into place.
Modeling users

What good is a social networking site without any users? Here we are introduced to setting up our models in our application. This chapter touches on defining your schema through the use of migrations. You build the migration, run the migration, and then work within the model to create your validations. They spend some time with the validations and show you how to use the default helper methods or extend the validations to be more powerful and suit your needs. Now we have a place to store our users, lets move on to the process of letting them become part of the community.
Registering users

This chapter focuses on the process needed to allow a user to register to RailsSpace. We are introduced to some more Rails magic as we build the User controller and the views. We start first with the view of the registration form and learn how to use Rails helpers to generate our form fields and error messages. Next we look at the action that handles the response to the user. This involves the validation, flash error messages, and flash notifications. With the registration in place, we take a pause to look at something very important in any software development: testing.
Getting started with testing

Before we move any further we need to make sure things are responding as they should be. Testing things yourself may seem practical when the application is small, but as it expands testing proves to be extremely useful. We create tests for the database connection, our site controller, the registration process, and testing of the User model. Testing allows us to check all important aspects of our application. We can simulate the processes of a user and assure that we receive the proper response and that everything stays fine tuned. This chapter sets the foundation for the rest of the application as we expand and create new tests. We have tested everything is working as planned, now let’s handle the process of logging in.
Logging in and out

Authenticating a user may seem simple at first glance, but there are often times steps that are overlooked in the process. This chapter attempts to cover all bases of making the login process painless. We learn how to setup the database for sessions and how to utilize them in our application. The sessions allow us to keep state of a user and their privileges. This also means that we need to protect our pages and some of our actions. They take the time to cover friendly URL forwarding, letting a user be directed back to any page after they login. Again, we run tests as we build more pieces onto the application. The end of the chapter is spent looking at the current code and refactoring to keep neat and tidy with the DRY principle. Just as with testing, this is also a very important part to the application and something the authors spend time doing with each and every piece of the application. We are also introduced to some more helpful Ruby nuances such as boolean methods and the bang! methods. A user has the ability to login, but we can take it one step further.
Advanced login

Users now have the ability to login. It is time to extend the login by allowing the application to remember the user. This chapter is spent on building the remember me functionality. This involves extending several aspects including the User model, the user session, and the authentication cookie stored in the browser. Since we are updating different aspects we take the time to extend our tests, assure our previous tests still work, and refactor some more of the code that we are building.
Updating user information

With login out of the way it is time to look at allowing users to interact with the website. The first part to this interaction is allowing them to update their details and information. This chapter discusses the process of allowing a user to change their email or update their password. The username is left untouched, as we will be creating a permalink with their username.

Our foundation is set. We have come a long way in just a few chapters, now it is time to extend our solid foundation.

Building a Social Network

Personal profiles

In the last chapter we allowed the user to update their email and password. Now we extend that to let the user create their own profile or spec. This allows a user to share all of their most intimate details one a single page. We look at building the user profile to be modular and utilize the same views for the public face and administrative face. We are introduced to some more rails helpers and some advanced routing techniques named routes. The user profile is in place, now it is time to create the pieces that allow all of your friends, teachers, aunts, and enemies to find you.
Community

The next few chapters will be spent building the central hub that will allow you to interact with the community as a whole. The first part addresses setting up the Community controller and setting up sample data to test our features with. Our first piece to the community controller is allowing you to browse users by an alphabetical index. This shows us some more options of the find method in ActiveRecord and how we can implement pagination and a summary in our results. Browsing by an alphabetical index is helpful, but lets move on to allow search and browsing by A/S/L.
Searching and browsing

Here we are introduced to plugins and using Ferret to help us with our search. As with the alphabetical listing we set it up to allow pagination within the results. We then setup a custom form to allow the user to search by age and sex. This utilizes the same views to return the results and allow pagination. Now we look at the location part. This is a little more advanced as it uses a GeoData database and a proximity search that allows you to find other users within a certain mileage of your current zip code. This concludes giving us all of the tools we need to find any information we need related to our users.
Avatars

What good is a name without a face? This chapter discusses several new aspects. The first is using a model that doesn’t connect to a table in the database. The second is handling image uploads and resizing. We create the interface and allow for the user to upload, save, or delete their picture.
Email

This chapter introduces us to Active Mailer, an aspect of Rails that allows us to send emails. We will setup a model that extends Active Mailer, configure our server to send email, and create the necessary links to allow users to contact their friends. We create a double-blind email system that allows the users to contact each other without exposing their actual email address. Naturally, we add the methods that allow you to correspond with the user. Once it is all in place, we take a look at some new testing methods that allow us to simulate the sending of emails without filling our inboxes.
Friendships

Friendships live at the core of creating a social networking system. After all, the more friends you have the more popular you must be in real life! Again, we are introduced to some new modeling techniques in this chapter. In order for a user to be a friend with another user, we must create the relationship accordingly. This involves having a Friendship model that has the current user ID, and the friend ID. Using has_many :through we are able to recursively look through this table to keep track of the friendships and their statuses. As with everything else, we take the time at the end to test and refactor.
RESTful blogs

This chapter throws an advanced topic our way, that of creating RESTful URLs for our application. There is much to be explained here, so I will avoid repetition. REST allows you to create neat URLs while also keeping your CRUD actions neat and tidy. This is important as we allow the users of our system to create blogs. Each user can have their own blog. Each blog can have many posts. Each post can have many comments (depending on how many friends you have). Using REST and map.resources to create our URLs we can utilize several Rails helper methods as well as give us a structure like http://www.example.com/user/name/blog/blog-title/blog-comments/. Though that may seem long and convoluted, it also allows us to utilize the power of the respond_to block to allow for RSS in each section without a lot of hassle.

This is just a small glimpse at what this chapter covers in regards to REST. This proved to be one of the most useful chapters for me. Utilizing this power in rails also warrants some new testing functionality to check for. We test to make sure everything is working, then move to implementing some Ajax into our application.
Blog comments with Ajax

We wouldn’t be very web 2.0 without Ajax. This chapter shows how to implement Ajax into our commenting system. We use both Ajax requests to submit the comments, and animation to toggle the display of the comment form. Rails comes with Prototype and Scriptaculous built in, so those libraries are used for the interaction. This is the only chapter that rubbed me the wrong way. I know that productivity is important, but I also don’t like the way that Rails implements JavaScript inline all over the place. I am in the camp of unobtrusive JavaScript, so this seems like going backwards to me. Sure, it is simple to implement with Rails helpers, but the output is simply horrendous. The chapter still has important aspects, I just feel they could be built in an unobtrusive manner, especially when you are using JavaScript to toggle the display of your comment form.
What next?

This chapter focuses on deployment of our application and the options available to us. It also addresses the issues of scaling, both with hardware and software, and administrating your Rails application.

I may seem cynical about social networks, but this truly book pays attention to the small details. Building a social network is a great tutorial that covers many aspects of Rails and building your own application - no matter what it is. It has several callout boxes that give more explanation where it is needed. It discusses the importance of testing. It shows the importance of refactoring. All of this comes together to make a great reading experience and knowledge gained. If you are a Rails professional, there might not be a whole lot new for you, but if you are just beginning Rails this is an excellent full-blown tutorial. Even if you don’t want to create a social networking site, the foundation and principles set in this book will give you the knowledge needed to start building your own application.

Nate Klaiber Book Reviews

Design Patterns in Ruby

What are patterns?

What is Ruby?

The Patterns

The Patterns + Ruby

Parting Thoughts

Building Findable Websites: Web Standards, SEO, and Beyond

The Markup

The Server-Side

The Content

The Findable Blog

The Search

The Roadblocks

The Mailing List

Putting it All Together

Parting Thoughts

Website Optimization: Speed, Search Engine and Conversion Rate Secrets

Search Engine Marketing Optimization

Natural Search Engine Optimization

Natural SEO Case Study: PhillyDentistry.com

Pay-per-Click Optimization

PPC SEO Case Study: BodyGlove.com

Conversion Rate Optimization

Web Performance Optimization

Web Page Optimization

CSS Optimization

Ajax Optimization

Advanced Web Performance Optimization

Website Optimization Metrics

So, now what? (Summary)

Companion Site

Web Design and Marketing Solutions for Business Websites

The decision making process

It's all about the content

Shout it to the hills

Now what?

The Rails Way

Mobile Web Design

Accelerated DOM Scripting with AJAX, APIs, and Libraries

Contents

Conclusion

Beginning HTML with CSS and XHTML: A Modern Guide and Reference

Contents

Conclusion

Professional Search Engine Optimization with PHP

Contents

Conclusion

RailsSpace: Building a Social Networking Website with Ruby on Rails

Foundations

Getting Started

Modeling users

Registering users

Getting started with testing

Logging in and out

Advanced login

Updating user information

Building a Social Network

Personal profiles

Community

Searching and browsing

Avatars

Email

Friendships

RESTful blogs

Blog comments with Ajax

What next?