Nate Klaiber Book Reviews

The Elements of Content Strategy

Nate Klaiber — Wed, 16 Mar 2011 20:09:00 +0000

Websites come in many shapes and sizes and serve many different purposes. For many websites, supplying content for the visitor is the primary purpose. A restaurant providing contact information, hours, and a menu. A product-focused company providing information on their product, their pricing, and contact information. A service-focused company providing information on their services, pricing, examples, and contact information. These are just a few examples. Content is everywhere. However, having content doesn’t equate to delivering your message. Throughout this short book, Erin walks through the process of developing and maintaining a content strategy.

The principles

The first section walks us through the basic principles. A key point made is to omit needless content.

Some organizations love to publish lots of content. Perhaps because they believe that having an org chart, a mission statement, a vision declaration, and a corporate inspirational video on the About Us page will retroactively validate the hours and days of time spent producing that content. Perhaps because they believe Google will only bless their work if they churn out dozens of blog posts per week. In most cases, I think entropy deserves the blame: the web offers the space to publish everything, and it’s much easier to treat it like a hall closet with infinite stuffing-space than to impose constraints.

Simply having content does not mean you have a content strategy. Visual designers practice the art of taking elements away, while still delivering the message. The same holds true with content. It’s not about the number of words, but about the quality of the words you choose to deliver your message. Eliminating the noise, and strengthening the signal of communication.

The craft

The second section speaks more in-depth on the craft of content strategy. On the subject of curation, she presents a wonderful analogy:

Now imagine going into a museum and trying to walk up to a Matisse, only to run into a glass wall ten feet away from the painting. To get past the wall – which is now frosted so you can’t see the painting at all – you have to write down your full name and address, and then show ID to prove that you are who you say you are. Once you’ve submitted to all this, you discover that the “painting” is only a small print – you have to go into another room full of billboards to see the original. Finally, you reach the painting. The descriptive label is written in miniature gray text on a slightly lighter gray background, so forget trying to read that, but here at last is the art.

That’s when the circus clowns pop out of the woodwork and start honking little horns and waving signs advertising tooth-whitening products and diet pills. This is content online

Read that last paragraph again. I know it brought a grin to my face.

This goes back to the basic principles and eliminating the distractions. Programmers practice their craft through techniques of code reviews, test-driven development, and constant education. Designers practice their craft through peer-reviews, design iterations (and reduction), and constant education. The same is true for the craft of content strategy. I know it’s an area where I am striving to dive deeper and learn more. I appreciate her passion and knowledge.

Continuing on the subject of curation, she talks about the different ways that curators of content can continually manage, measure, and refine their content. Doing this crosses into other disciplines found on the web. Not only do we have the ability to continually analyze our website’s traffic, goals, and performance, but now this gets applied to managing your overall content strategy. As your content grows, it needs to continually be nurtured. A specific example for those involved in web analytics: Annotations. Whenever a feature is released, a large campaign is implemented, or your company is speaking at a large conference, you can annotate in your analytics when this happened. Now apply this to content curation. Over time you may have organizational changes, layout changes, or structural changes. You can annotate this so when you look back you know when the change was made, and why previous content may not adhere to the same standards. This is a small example, but highlights on ways you can analyze your content as a part of the curation process.

An important part of managing the overall content strategy is being an advocate of the end visitor.

Nearly every project contains within it two sets of needs that are held in tension: the needs of the client and the needs of the user. In successful projects, these two sets of needs tend to be complementary, but you will also encounter situations in which client and user needs appear in conflict. In this situation, content specialists are well places to acts as user advocates, as we often have an easier time finding and citing user research to back up our positions than do visual designers held hostage by a client’s personal fondness for mauve.

Summary

To some, a content strategy seems easy. It’s just words, right? To others, it’s a craft. Content is not just added to take up space, but is added with a purpose and goal in mind. In such a short book, Erin does a great job of giving the basics, going in depth, and then providing other tools and resources. If you manage content for a website – copywriting, design, minor updates – you need to read this book. You could read it twice if you wanted, as it’s a pleasure to read and short in length.

Handcrafted CSS: More Bulletproof Web Design

Nate Klaiber — Tue, 29 Dec 2009 07:40:00 +0000

The new release from Dan Cederholm is a great complement to his previous work in Bulletproof Web Design. For those who haven’t read Bulletproof Web Design, it’s premise was creating flexible websites and keeping a clear separation of your markup (HTML), styles (CSS), and behavior (JavaScript). It took examples of sites that weren’t bulletproof, and showed the process to make them bulletproof. All great things. The landscape of browsers, CSS, and HTML has changed slightly since Dan wrote Bulletproof Web Design, and this book is focused on bringing those aspects to the forefront. This book assumes you have knowledge of developing with web standards, and therefore bypasses the why of adhering to web standards.

The entire book focuses on building a fictional site, the Tugboat Coffee Company. Each chapter builds a new layer into this site, with clear instruction of how each aspect progressively enhances the user experience, while not explicitly leaving other browsers in the dust. Here is a quick breakdown:

Introduction

This chapter is a quick example of why we need to be flexible with our designs and development. Using a list of menu items, Dan walks through how to best organize your markup and CSS. To me, this chapter was about first putting on your thinking cap and planning for how your sections should be organized within a site. Think about how the end user will experience and interact with your site. Even with a simple menu list, he shows how things change when text is re-sized, or simply making your clickable link area larger in a given area. While this chapter had a specific example, and code to work through—I really saw it as something to begin challenging you to think about your architecture.

Round and round we go

Most of us are familiar with the previous way of creating rounded corners, and each of those ways had their drawbacks. Using 4 images, then you had superfluous markup. Use 2 images, then it didn’t scale well in both directions. This left us to educate ourselves and then choose the best decision based on our context. With CSS3 this process is made much easier. Using border-radius and it’s browser specific counterparts, we can begin to work with rounded corners now—and have it work in standards aware browsers. This chapter not only discussed the organization for this in your CSS, but also some of the finer points of using rounded corners in the first place. Background clipping with images inside of a container and applying this to form elements were two specific examples.

Now, don’t start throwing vegetables at me just yet. This is the beauty of this book. This is the premise of this book. The ability to use features in CSS3, while still providing an experience for all of your users. Those with advanced browsers will see everything in it’s shining beauty. Those without may be missing a few things here and there. It’s not all a loss—they can still access the content. In this example, your rounded corners simply may not be rounded. You have many options available to you if you wanted to do some extra work to make rounded corners in all browsers. It’s all about your context and your goals. Again, going back to the first chapter—put on your thinking cap and weigh the goals and costs.

RGB eh?

Specifying colors has always been easy. You have several ways with css, including color, hex codes, and RGB. Now, we also have the ability to specify a fourth parameter to control the alpha transparency. Yes, you could achieve some of these same effects with PNG’s, but that’s the point—now you don’t have to. This isn’t just in reference to a text color or background color. This can also be applied to your borders and pseudo elements for some nice effects all around.

This chapter again builds on the example site, and shows the process for implementing this into your site right now.

But it doesn’t look the same!

I have often heard this cry from many different web developers. Dan points to his wonderful site, Do Websites Need To Look The Same In Every Browser? While this may seem somewhat sarcastic (what an incredible domain name), he created this to prove his point. Even this site alone doesn’t look the same in every browser—and that’s OK. This chapter goes into a little more detail into the questions posed in the first chapter. We need to think about the end user experience, and let that be the driving factors into our design decisions. While these tools are great, and it’s great to start experimenting with them now—they might not be right for all scenarios and contexts. To me, this chapter was a challenge. It was a challenge to be more forward thinking with the front-end architecture decisions. Thinking about the different aspects that users, analytics, and browser market share bring to this decision making.

Some techniques discussed in this chapter were text-shadow, box-shadow, and adding some smaller animations via CSS. Again, we use these things to build into the example website.

Float on

You guessed it. This section focused on managing your floats. The interesting point I found here is that Dan talks about how he has altered the way he handles them. Previously, he would clear all floated elements in the CSS file. This would create a large list that would need to be managed in the CSS. Instead, he has moved to a more preferred method of applying a .group class to the elements themselves in the markup. I think I would agree, that it works well in the markup and compounding the necessary classes together. It is much more modular, which was the point he was trying to make with this section.

The Grid

This was a chapter presented by Ethan Marcotte, and an incredible addition to this book. Ethan talks about setting up a fluid grid, and shows an array of different tricks to help you achieve this. These tricks even included image sizing, which can throw a grid off if you don’t necessarily know the height dimension. He shows how to keep a larger image in context, and allowing it to scale with the design itself. He showed how to keep everything in line to a specific Grid that you choose, and how to make this flexible for the end user and their experience. It wasn’t just letting things move one way or another based on the browser stretching—it was about truly adapting. Some tricks took a little JavaScript love to make them work, but it was done in a very clean manner. This was the icing on the cake to the beautiful example site that gets constructed throughout the book.

The devil is in the details

Bringing things to a close, Dan dives into some of the often forgotten smaller details of a design. It’s these small details that can sometimes make or break a design. He briefly discusses fonts with @font-face linking, using jQuery for a handful of small effects and to tidy up things like .last classes in lists of items, and then an example of parallax scrolling. These little details may go un-detected to most people, but are there to help enhance the user experience. I think this chapter could have even been longer—especially with the discussion of jQuery—but I liked the examples he chose to use.

Summary

This book was a great follow up to Bulletproof Web Design. It wasn't merely a replacement or update of the book—but an extension. This book wasn't about all of the small details. It was about an introduction to some of the tools you can start using today. When I finished the book, I was inspired to simply learn more and play with the techniques discussed. If you want to see—in action—how you can begin to use new techniques while still maintaining an experience for all browsers, then this is a great book for you.

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.

Pro CSS and HTML Design Patterns

Nate Klaiber — Tue, 14 Aug 2007 09:39:00 +0000

Pro CSS and HTML Design Patterns by Michael Bowers is an incredible resource and toolbox for any level web developer. Whether you are just beginning with CSS or are of a professional status, this book has something to offer. With over 300 different design patterns, this book is the perfect resource to solve just about every problem you face. There are patterns for every aspect of your site, and their modular nature give you the potential to combine several of them to create some very unique websites. All of this comes with the added bonus that each of these design patterns have been thoroughly tested in all major browsers. There is great attention to the details throughout each of these patterns.

This book is not broken down like your typical web development book. The first 3 chapters of this book focus solely on the foundation. The first chapter discusses CSS. This includes addressing many of the common properties and values, different types of selectors, units of measure, and addressing the cascade. Chapter 2 moved on to talk about different HTML design patterns. This section outlines the basic building blocks of any HTML document such as html, doctype, head, body, and many possible elements in between. Chapter 3 moves on to the tricky subject of CSS selectors and inheritance. This becomes important throughout the rest of the book as proper inheritance will play a big role in developing our patterns and keeping our code lean and semantic. None of these three chapters are exhaustive in nature, but they give you a solid base to work with as you read throughout the rest of the book. So, while this book can be used as a resource, if you are just beginning CSS I would recommend not skipping the first three chapters.

Chapters 4 through 9 focus on the different layout options available to you. Chapter 4 starts things off by defining and discussing the Box Model. We look at several different types of the box model including inline box, inline-block box, absolute box, and floated box. Chapter 5 takes things a step further and discusses width, height, sized, shrinkwrapped, and stretched box model options. Chapter 6 addresses all of the editable properties of the Box Model and how they relate to one another. Things like margin, border, padding, background, visibility, and overflow are covered. Chapters 7 through 9 take you from the basic models to advanced layout options. Some of these are more intricate than others, but afford you some great layout techniques. We have built a base, and looked in depth at all of our available positioning models, now it is time to get down to some of the finer details of our layout and how we can style the often overlooked elements.

Chapters 10 through 19 are all focused on polishing each and every piece of your layout. We start by looking at different ways to style your text, how to give your content breathing room and your different alignment options, and gradually move to styling elements such as tables, columns, drop caps, and callouts and quotes. There are several other sections that also discuss block elements and entire layout options. We can now begin to put the pieces of the puzzle together and see how our finished product can become one cohesive whole unit.

The last chapter discusses design patterns for alerts within your layout. This chapter does include some JavaScript, but all of this is made known up-front as you implement any of the given options. We look at different alerts such as JavaScript, tooltips, popups, inline, and graphical. There are several others covered as well, but these are some of the more common ones that developers run into.

Conclusion

This is not a book that needs to be read from cover to cover to fully understand. It is used and designed as a resource to help you solve your design problems. This book would serve as a great desk reference. As stated earlier, each of the design patterns presented in this book have been thoroughly tested in all major browsers. This doesn’t mean everything will work in all situations, but it does mean that each stand-alone pattern has undergone intense browser testing. It is up to you and your creativity to combine and extend them to suit your specific needs.

It is worth noting that this book's contents are also available at the official website. For those who find it hard to read about the patterns and try and visualize them from a page, the website has each and every pattern available for view on the website.

If you are looking for a complete site design solutions book, this is not it—but if you are seeking a book to help you solve many common problems—then this book will serve as a useful tool for you. You do not need to be a CSS professional to find great value in this book.

PPK On JavaScript

Nate Klaiber — Tue, 31 Jul 2007 09:55:00 +0000

PPK on JavaScript by Peter-Paul Koch might just be the most thorough JavaScript book I have read. Through the use of eight real-world example scripts, PPK walks us through JavaScript from the very beginning. Over the years JavaScript has had its ups and downs. This is mainly due to the flux of poorly optimized scripts that are scattered around the Internet. So how do you know what source to trust? What are some best practices for JavaScript? How can you utilize JavaScript to add enhancements to your site without breaking in the browser? How can you create scripts that will enhance the user experience and not hurt it? All of these topics and more are discussed in this book.

Throughout the ten chapters and 499 pages of this book, there is very little that isn't covered on the topic. Let's take a look at the organization and flow of the book:

Purpose
This chapter paints the big picture for us. There is no jumping into scripts or coding in the first few chapters. Here we get an overview of some important aspects of JavaScript. One of the most important aspects is the coverage of the history of JavaScript. Though some might find this to be boring, I believe it to be invaluable. Understanding the history of JavaScript gives you a better idea of how it has formed into the language it is today. This is one of the most valuable parts of the book. It sets a solid foundation for everything else that is covered.
Context
Along with understanding the history, it is good to see where JavaScript fits into the big picture of web development. Here we take an in-depth look at HTML, CSS, and JavaScript. There are many distinctions to be made here as each could potentially mix with the other. It is important to keep a clean separation of your structure (HTML), presentation (CSS), and your behavior (JavaScript). At some points the line may become blurry on mixing the two, which is why each aspect is discussed in detail. These include separation of presentation and structure, separation of behavior and structure, and separation of behavior and presentation.

Not every user or device has JavaScript enabled. Moving forward we look at the impact on accessibility and how it affects things such as no mouse, screen readers, and usability. These are all important pieces that must be addressed as we begin adding advanced functionality to our website.

Lastly we are introduced to the eight example scripts that we will encounter: Textarea MaxLength, Usable Forms, Form Validation, Dropdown Menu, Edit Style Sheet, Sandwich Picker, XMLHTTP Speed Meter, and Site Survey.
Browsers

This chapter provides a little more context and history into the different browser families. We look not only at browsers but other devices such as mobile phones and screen readers. We look at each of these and are then shown some of the incompatibilities that they suffer. We address the problems and look to build solutions to patch the holes. Next we look at solving problems by using two different techniques: object detection and browser detection. Object detection works by checking if the methods you are using are supported before you use them. Browser detection tries to detect the current User Agent and then build from there. Browser detection has many flaws associated with it. One specifically is browser spoofing where you can send a different User Agent string to the server, lying to the application about the available technology. There are correct uses, but this should mostly be avoided.

If you have been developing JavaScript for a while then you are probably used to using the alert method to help in the debugging process. Here were are introduced to debugging, figuring out some of the cryptic messages returned by the browser, and how we can deal with browser bugs.
Preparation

Planning is important for all projects. Here we are introduced to preparing our application for enhancements. This involves having the proper placements of hooks. Hooks are found by using an ID, class, custom attributes (not a widely accepted solution), and name/value pairs.

Once we have our hooks in place, we have to get access to them to make our modifications. Having access is only part of the process. We also have to learn how to generate content when necessary and understanding the relationships inside of the DOM. We get a brief primer on setting up our script tag and how we can utilize multiple scripts if necessary.

Our hooks are in place, and we know where we want to apply our effects. How and when should they fire? We stop to take a look at the initialization of scripts and the load event. This method has its pitfalls, which are discussed and alternate solutions are addressed. We take a look back to the example scripts for some more insight and real-world use cases.
Core

Everything we have done to this point hinges on our ability to actually program the functionality we are trying to achieve. This section walks through the basics of programming in JavaScript. We look at statements, comments, code blocks, operators, values, and case sensitivity. Next we look at the six different data types that are available to us, and how JavaScript handles conversion and concatenation. We look at ways to explicitly convert our data types when necessary. After looking at the data types we look at some of the common operators. These are inherent to every programming language, so there isn't much new in this area. We've looked at the constructs, now we move to discussing variables: proper naming, the var keyword, and variable scope. This is very important to grasp as we move forward and create our own functions to achieve our tasks. Next we look at working with numbers, strings, and booleans inside of our scripts. We have a good foundation, now we move to control structures such as if, switch, for, while, do/while, break and continue, and try/catch. The next few sections focus on defining and working with custom functions, creating and defining objects and their methods and properties, and finally dealing with arrays. The section on arrays is especially helpful as it discussed how you can loop over them and how you can add, delete, and locate specific sections inside of an array.
BOM

This section looks at the Browser Object Model and the window object. We take a look at the global window object and its impact on creating new pages and cross communication between windows. We then look at navigation within the window and the location and history. We learn how to manipulate the geometry of the window, and how to retrieve information about the current window dimensions.

The chapter rounds off with discussion of some miscellaneous functions such as alert, confirm, prompt and timeouts and intervals. We take a closer look at some of the available methods for the document object. Finally, we take a look at working with cookies and utilizing/managing them within our application.
Events

This is probably one of the most important sections of this book. This section gives a thorough look at all of the available events. The chapter first starts by looking at some compatibilities and how to resolve them case by case. We take an in-depth look at all of the available events at our disposal and how they work. We look at event registration and the best way to handle it. The rest of this chapter discusses event bubbling and capturing and the browser support related to each, the event object and its properties available to us, targeting your elements, and then implementing some of our new-found knowledge in the example scripts. Sometimes grasping events and event registration can be tough, but this chapter makes it easy through illustration and the example scripts.
DOM

We have come a long way to this point. We have set our foundation, looked at the core of JavaScript, examined the browser window and its properties, and learned how to set our events in motion. Now it is time to look at the Document Object Model. The DOM holds all of the information inside of our pages. It is comprised of all elements and attributes and their relationship to one another. They are commonly referred to as nodes that build the family tree. Understanding of this structure is what gives us the power to build elements and insert them or delete them. We have full control over our internal structure.

However, it is never that easy. Traversing the DOM can sometimes be painful, especially when you see some of the differences between browsers. We take a look at how to find our nodes, how we can retrieve information about those nodes, and how we can change our document tree through appending, inserting, removing, and replacing. We are also introduced to creating elements and creating text nodes, and then how we can achieve some of the above tasks.

This chapter rounds off with the always heated discussion of the use of innerHTML, finding attributes and setting their values, dealing with text nodes - even empty text nodes that sometimes cause confusion, understanding and traversing the nodeLists, and dealing with forms and the Level 0 DOM. All of these pieces help us put together the big puzzle as we are using JavaScript to manipulate our pages.
CSS Modification

Earlier we discussed the aspect of keeping your presentation separate from your behavior. This chapter discusses best practices for working between the two. We learn how to get style information from our elements, and then how we can add classes dynamically. We take a brief look at the possibility of changing the entire stylesheet via JavaScript. While this is a nice introduction, I think it would require a specific project.

The last parts of this chapter look at some examples of keeping the clean separation, but applying some visual enhancements. We work through some examples of toggling display of elements, animating elements, and changing the dimensions and position of elements.
Data Retrieval

This chapter is all about AJAX. We look at the XMLHttpRequest object and how to make it work cross browser through some conditional checks. Once we have sent the request, we need to know how to handle the response. We look at the different statuses and response codes that we will be dealing with and how to set callback functions to handle the response. We look at the available return formats such as XML, HTML, JSON, and CSV. The final part to this chapter looks at the impact that AJAX has on accessibility.

This review alone does not do this book justice. This book thoroughly discussed each and every aspect to JavaScript, from its history to looking to its future. The example scripts helped to grasp the different concepts, but the real meat of the book was in the specific coverage of each aspect. There are many books about specific aspects of JavaScript, but this book combines them all into one resource. If you are just getting your feet wet in JavaScript, then this book is the perfect book to help take you to the next level.

Textpattern Solutions: PHP-Based Content Management Made Easy

Nate Klaiber — Mon, 23 Jul 2007 14:27:00 +0000

Textpattern Solutions: PHP-Based Content Management Made Easy by Kevin Potts, Robert Sable, and Nathan Smith (with Mary Fredborg and Cody Lindley, foreword by Jon Hicks) is a cohesive primer to getting started, working in, and managing the Textpattern CMS. If you are a PHP beginner and are looking for a CMS solution, then this is a great start. If you are an advanced PHP developer, then this is an excellent choice for a CMS. No matter what the skill level, Textpattern allows you to take full control of your website, whether it is a simple blog or an e-commerce application. Getting started with a CMS is never easy. You have to learn the CMS interface and it’s nuances including such things as templating and plugins. This book will walk you through all the steps necessary to effectively manage your site with the Textpattern CMS.

This book is broken down into 6 parts and 17 chapters. Let’s take a look at each part.

Part 1 sets the foundation in getting started with Textpattern. This section will give you the basics and walk you through installing a local server using the popular XAMPP setup. They run through the process on both Microsoft Windows and Macintosh OSX platforms. After XAMPP is installed, you are walked through connecting the pieces to get Textpattern up and running. This includes downloading and installing the CMS and connecting it to your MySQL database.
Part 2 continues with setting the foundation and introduces you to the Textpattern interface. Each chapter walks you through the administration panels and breaks down all of your options. These chapters are extremely thorough and leave no gaps in the administration panel and your available options. From site administration, basic content creation, and altering the look and feel—this chapter covers all of the bases necessary to work within the CMS.
Now that a strong foundation has been set, it is time to dive in deeper and customize our installation of Textpattern to our needs. No two websites are the same, and each website has different needs and goals. Textpattern has a flexible setup that allows you to define the content areas, what they include, and where they should be included. A simple templating system that gives you the necessary defaults, but also allows you to extend beyond those defaults when necessary. These chapters also introduce you to the Textpattern Model which adds a content layer to the already known structural, presentational, and behavioural layers.

Here is where we dive in and start getting our hands dirty. We start by creating the content needed for the site. This includes such things as categories, articles, and then comments. We step back and look at the big picture, then break each of these things into their own forms. This give us the freedom to re-use chunks of code throughout the rest of our site. We start putting the pieces of the puzzle together and connecting the content to our site structure. It is important to mention that each step of the process is covered extensively and the template tags are broken down to let you know all of your options.
Moving to part four we get to take an in-depth look at the Textpattern plugin architecture. Sometimes we need to achieve custom tasks but don’t want to manipulate the core code. Plugins allow you to extend the Textpattern CMS and build in your own tags and functionality. We are first introduced to custom fields and how we can utilize them in our site. This extends the flexibility even further, as you are allowed to define the context through the use of these custom fields. For instance, if I were doing a website that focused on books I could create custom fields for author, price, publisher, and anything else related to the book. With just a few clicks you can utilize an array of plugins already available to the community or you can build your own. This section walks you through the process of doing both tasks. We get to see an in-depth tutorial on creating your own plugins from Rob Sable who is very experienced at creating plugins. Now that we have seen how to add custom fields, how to implement already existing plugins, and how to write our own plugins, it is time to put this all into practice.
At this point you have covered virtually every aspect of Textpattern. Now it is time to take a look at some case studies. The first example is one of a multi-author website, Godbit.com. This is a website run by Nathan Smith, and has contributions of many others. Nathan walks you through the structure of the Godbit website, and how it allows multiple authors to add content and achieve only the tasks necessary to their role.

Next we are presented with two different case studies: PopularWeddingFavors.com and Boise City Eats. The first is an e-commerce site and the second is a place to review local restaurants. It is important to note that each of these sites has a unique context and structure. These chapters show the true power of Textpattern: getting out of the way and giving you the control. You are not confined to specific types, nor do you have to shoehorn your content into something that it isn’t. You are in full control of developing your application no matter what the need.
The last part of this book makes this a valuable desk reference: appendixes that walk you through a complete tag reference and plugin developer resource. This includes full coverage of all available tags and options, and some of the core code and functions that will allow you to effectively build your plugins. Both of these are invaluable as you work within the Textpattern CMS and should be an arms length away as you are developing.

Conclusion

If you are looking for a PHP-based CMS and don’t know where to get started, then Textpattern is worth a serious look and this book will guide you in the process. I have played with several other CMS’s that seemingly lock you into their context and options. Textpattern is more of a blend of a framework and CMS, allowing you to have full control as your website scales—no matter what the need.

The Principles of Beautiful Web Design

Nate Klaiber — Mon, 09 Jul 2007 20:18:00 +0000

The Principles of Beautiful Web Design by Jason Beaird is a concise book about basic design principles. To some, design is something that is tough to grasp and is a mystery to understand. To others it simply comes naturally. If you find yourself struggling with design and need some direction, then this book is for you. Throughout each of the chapters Jason breaks down the specifics of layout and composition, color, texture, typography, and imagery.

Jason states his intended audience as someone who might be:

…squeamish about choosing colors, feel uninspired by a blank browser window, or get lost trying to choose the right font.

It is important to note that this book is not a book about code, but is about principles, inspiration, and education. With that brief disclaimer out of the way, here is a breakdown of the content found in the book.

The journey starts with chapter 1 and layout and composition. Before any keys are pressed on a keyboard, there is much work and research to be done. Jason talks about his design process and starting things off right with your clients. He gives a brief definition of what makes up good design. I am sure this could be many different things to different people, but he stresses the key points in relation to user interaction on the web. How easy is it for people to find what they are looking for? Does the design help them achieve their goals, or is the design visual eye-candy that inhibits them completing a specific task? Is the navigation and information easy to understand? Can the user navigate without feeling lost? The design process takes time.

Next he looks to the anatomy of a web page. Many pages have a consistency to them. There is a navigation, sub navigation. A masthead with branding information. There might be a search field to help locate different pages. There are an array of columns used for placement. There is a footer that usually has more details or contact information. These are just a few, and they don’t all have to look the same.

The next few pieces discuss grid theory, balance, unity, and emphasis. Each of these play an important role on how your information is presented. Aligning your items to a grid. Aligning your type to a vertical rhythm. Having balance between your sections. Having unity in your sub-pages as the navigation gets deeper. Placing emphasis on any given section. Each of these are discussed in detail and are accompanied by examples found on the web.

This chapter rounds off by Jason showing some bread and butter layouts, finding inspiration on and off the web, giving introduction to some new and fresh trends (you know, the Web 2.0 stuff), and then begins the application that we will watch unfold throughout the rest of the book, a website for Florida Country Tile.
With a firm foundation of layout and composition beneath us, it is time to address the aspect of color. We have all seen beautiful color combinations, and most likely our fair share of not-so-friendly-to-the-eyes color combinations. How do you go about selecting a color scheme for your website? Jason starts this chapter off by discussing the psychology of color. Color theory simply addresses how people react and relate to different colors. There are many variables involved, and some of them are even geographical in nature. What types of colors should you choose for your target audience? Looking to develop a site for a restaurant? Find out how different colors convey different emotions in your users. Color theory gives great insight into how people perceive colors found on your website.

The next few sections discuss things such as the temperature of your colors, the value of your colors, and then into a little bit of color theory. Each of these pieces are given adequate attention with even more examples shown. Things start to get fun as he moves into color theory. Here is where we see some methods used to creating elegant color schemes. No longer do you have to randomly select colors, now you can give your entire website some of that balance that we discussed above. Selecting a color scheme can be very difficult, but as Jason shows there are many options to selecting a color scheme that will fit the needs of your site. As he shows the process for creating a color palette, he moves on to the process of selecting a color palette for the application section. The Florida Country Tile website is starting to get filled out with an elegant color scheme.
The application is starting to come to life. We have a layout, we have a color scheme, and now it is time to see how we can make some subtle improvements through the use of texture. This chapter defines such things as points, line, shape, volume and depth, and pattern. Each of these come with illustrations to further elaborate on the topics. After looking through each of these things, Jason moves to the practical side and building your own textures for your website. This includes subtle background textures, textures for use as borders, and textures are backgrounds for different elements on a page. He gives the application a subtle enhancement by adding a textured background. Things are starting to evolve even more, and the site is starting to take form and life. Background images, drop-shadows, and section separators are just a few ways textures can be used to enhance a layout.
One of the often overlooked aspect of a website is that of typography. This is mainly due in part to the small selection of fonts available to web designers. Jason covers some ways to get around this shortcoming by use of sIFR and other image replacement techniques. Image replacement has been discussed in depth in many different avenues, and Jason doesn’t spend much time discussing these. This is an out of classroom assighment for you as the reader.

Now it’s time to dive in a little deeper. The next few sections are a brief history lesson. He discusses things like letterform, text spacing, letter spacing, text alignment, adjusting line height for an optimal reading experience, and some of distinctions of typefaces. Here you will see a breakdown of serif versus sans-serif, and some of the different variations of each.

With the history behind us, we move forward to what it takes to choose the right font for your project. This is always dependent on the client and the branding that needs to take place. Choosing a typeface is sometimes a difficult process, especially with the large amounts of fonts and variants available to you as a designer. Jason moves on to apply some of these principles to the application that we have been working on. He chooses the fonts he will use throughout the website, both in images and in the body of the pages. He proceeds to add some text on top of the imagery, as well as give some breathing room and separation to the content on the homepage.
Our journey to design bliss is coming to a close. The last chapter discusses adding imagery to give your site a bit of visual flair. Again, Jason begins with a few sections covering some history, what to look for, and where to look for it. This includes the legal implications of the different kinds of images that you may come across. Once we safely secure the images we want to use for the website, and are sure we have full permission to do so, we then move to cropping, adjustments with photoshop, and the different formats and resolutions available to use. Here we see a brief discussion of applying CSS to achieve some re-usable border treatments to our images. Finally, all of this knowledge is used to extend upon the application and give it its final touches.

Overall, this book is an excellent resource for those seeking design instruction and inspiration. The book is filled with screenshots of different sites and sources for inspiration as the author encourages us to look around for inspiration in our own designs. Seeking inspiration doesn't always mean emulation. Find a way to make things your own for you and your client. As a reminder, this book might seem elementary for those who have a background and education in design. This book is for those looking to take small steps to improve their websites.

I did have one qualm with this book. This book is primarily constructed of principles, history, and philosophy of design. This means discussion of code and application specific techniques are kept to a minimal. However, given the target audience, it seems as though Jason makes many assumptions about the understanding of Photoshop and the techniques described therein. I know that it would take extra time to explain this process, and he even gives a disclaimer that it is hard for him to explain his entire process. Maybe it would have been nice to have an appendix with some more details to the Photoshop techniques he discusses throughout the book.

Simply JavaScript

Nate Klaiber — Thu, 05 Jul 2007 22:33:00 +0000

Simply Javascript by Kevin Yank and Cameron Adams lives up to the subtitle of Everything you need to learn Javascript from scratch. Javascript is a tricky subject to tackle. The Internet is full of Javascript snippets and code samples everywhere you look. Often times these code samples are less than satisfactory when you are addressing accessibility within your website. Many of the code samples contain outdated and proprietary code samples, making it a task to work out kinks and debug. The good news with this book is that they stick to a standard. All code used in this book uses object literal notation. Sticking to a coding style and format helps make this book an incredible read. Throughout this book you will learn the underpinnings of Javascript and how you can achieve different tasks.

Learning Javascript from scratch can be a daunting task. After all, there are several libraries and free scripts that you can essentially download and plugin to your website. But what happens when things go wrong? What happens when you need to modify the script to fit your needs? Having a solid foundation and understanding of Javascript will help you as you begin to develop for your own needs. This book gently walks you through the steps you need to take to achieve that solid foundation.

Chapter 1 starts off with a brief primer of unobtrusive Javascript and it’s role in the three layers of the web. HTML is your content. CSS is your presentation. Javascript is your behavior. These three aspects need to be separate from one another and also co-exist at the same time. Gone are the days of inline event handlers and functions. Using the power of the DOM you can rest assured your HTML will be pure and your applications will work flawlessly without Javascript enabled.
Chapter 2 spends some time setting up the foundation for beginners. This chapter walks you through statements, comments, variables and different variable types, conditions and loops, functions, and objects. Whew, that was a mouthful. This is where the standard of coding is introduced that will be used throughout the rest of the book. Things such as code indenting and formatting are touched on as well. This allows you to write clean code that is readable by you and other developers who may be working with your code. As stated earlier, all code uses object literal notation, and therefore this is explained in this chapter. A few examples are given and we are off to building some handy tools.
Chapter 3 gives you the necessary road map. This chapter is devoted to traversing the Document Object Model. A few helper classes are shown here that will allow us to retrieve elements by class name, add class names to an element, remove class names from an element, and check for the existence of class names within in an element. These will be used extensively throughout the book and are placed in their Core object. In addition to being able to traverse by class names, there is also the list of standard elements such as getElementById and getElementsByTagName. With these powerful tools at our finger tips we can now begin altering our pages as deemed necessary. The example given here is one of striping table rows. For those who don’t do this on the server side, this simple task allows you to stripe your rows via the DOM.
Sure it’s cool to add stripes to a table, but how can we do more? Chapter 4 is all about Events and the power they add to interacting with the DOM. The brief history lesson in this chapter helps us understand the different interpretations of different browsers and how we can use object detection to abstract these tasks into the Core object. Event Listeners and Event Handlers are both discussed in great detail. We move on to two working examples: Rich tooltips and Accordion. Rich tooltips are used to extract information from our title attribute and then apply them to a more stylish hover tooltip effect. Accordion allows us to save space on our pages by gradually showing the content as it is requested by either a click or keyboard event.
Chapter 5 gets us moving even more. This chapter is devoted to Animation and is probably one of the more complex chapters of the book. We are introduced to two methods, setTimeout and setInterval. Working mainly with setTimeout we are able to achieve our animation effects. This chapter looks at the principles of animation and an example of path-based motion with a soccer ball. We then use our new-found knowledge to extend our tooltip to show after a specified time, and our accordion is given a nice slide effect. We simply extend the code from our previous chapter to make these things happen. This is a good example of the benefits of working with objects and decoupling inside of your Javascript.
Chapter 6 gives use a few more tools to work with Forms. Forms are never easy to manipulate. Whether it be the style or the behavior. The beginning of the chapter starts with smaller scripts and examples of manipulating forms. This is done by specifying dependent fields and only showing them when necessary, and creating cascading menus from a select and it’s optgroup. We then move on to some more advanced features for validation and creating a custom slider. These have been presented before in other areas, so nothing is really new in this area. However, this is all a part of understanding the bigger picture and the possibilities. It is about getting the creative juices flowing.
Chapter 7 discusses the inevitable testing for errors and debugging your application. We walk through the different types of erros: syntax, runtime, and logic. With each of these code samples are given with errors. We then use the tools of the browsers to make sense of their often cryptic error messages. In order to debug Javascript there is an invaluable tool in Firebug, a plugin for the popular Firefox web browser.
More interaction is still left as chapter 8 moves us to AJAX. Some very strong disclaimers are made as to when and where to use the right tool for the right job. Caution is also given in regards to assistive devices such as screen readers. With the warnings out of the way, we move to a some practical examples. The first is a small weather widget and the second is an extension to form validation.
The book finishes off by looking too the future of Javascript. Discussions of Rich Internet Applications and their place inside of the web help to stimulate your mind as you think about the possibilities. Not only about building applications on the web, but also using Javascript for such things as Dashboard Widgets and even browser development. In the hands of responsible developers, the future looks exciting for Javascript.
The Appendix is a very important part to this book, and I like its placement. The appendix goes through the Core methods used throughout the entire book. But why wait until the end of the book? Had this chapter shown up earlier it would have caused more confusion than necessary, and more explanation that necessary. As a reader you have the option to read this appendix first, but I felt it was well placed and covered thoroughly at the end of the book. By this point in the book you will have gained enough knowledge to dive in, whereas the beginning might have left you asking all the wrong questions.

If you have been developing Javascript for any amount of time, then you are most likely aware of the array of libraries available to us. These include Prototype, Scriptaculous, jQuery, Dojo, MooTools, and YUI to name a few. Each chapter of this book ends with a discussion of the libraries and how they can be used to help achieve the different tasks. Some libraries can achieve some tasks, while others still take a little work. The authors give a fair coverage to the libraries but do not dwell on them as the end-all-be-all of Javascript. If anything, the author’s stress that you understand your Javascript at the core and know why you are doing what you are doing. This book sticks to unobtrusive principles and doesn’t take shortcuts. The authors strive to make sure the code is of high quality and compatible cross-browser, but they never take the easy way out. Things such as innerHTML are put away in favor of building the DOM on the fly. This adds to the overall excellent quality of this book. The excellent code coupled with beautiful illustrations make this book easy to take small chunks at a time.

Web Development Solutions: AJAX, APIs, and Hosted Services Made Easy

Nate Klaiber — Thu, 14 Jun 2007 22:43:00 +0000

Web Development Solutions: Ajax, APIs, Libraries, and Hosted Services Made Easy by Christian Heilmann and Mark Norman Francis left me with mixed feelings. The title lead me to believe there would be some more in-depth information related to the topics, but in reality the end of the title should have been Using Wordpress. The majority of this book focuses on Wordpress and how each of the topics relate to the blogging platform.

The reason I had mixed emotions is because on one hand, the authors made it seem as though web development is so easy your Grandma could do it, while on the other hand sliding in some disclaimers about needing more knowledge on different topics. I think that this book would give someone just enough material to be dangerous, but not enough to really understand web development as a whole. This book is geared to the beginner in web development, so I was hoping for some more solid material.

With that out of the way, lets take a closer look at the book and its contents:

The first chapter simply discusses the reason for starting up a website in the first place. There are many different reasons for many different people as to why they start a site. Some start for financial reasons (make money and advertising), while others start to share photos with family and friends. This chapter discussed several of these reasons for starting a website.

Chapter two was where the book really started to take off. This chapter discusses the Dilemma of “Rolling your Own” Solutions. We also get a brief crash course in several aspects related to web development.

The author gets you started by installing a local server on your machine with PHP and MySQL. After this is completed, the authors walk through an installation of Wordpress as we begin our journey. Basically every chapter after this will use Wordpress in one way or another.

This is where things get somewhat fuzzy. The chapters related to Ajax, APIs, and Libraries all revolve around Wordpress. The topics are not discussed in depth, but merely show you how to install an array of different plugins available to the Wordpress platform. Flickr, Youtube, Odeo, and Google Maps—all of which are presented as plugins for Wordpress.

The last few chapters involved some good discussions on promoting your content, navigation and layout, and finally—how to get help when you hit a roadblock. The last chapter really made this book worth the read, as it discussed the different ways to get help, the places to go, and how to ask for help in the different communities. There are some very helpful and important tips in this chapter as you seek help from your peers and colleagues.

Overall, the book was not a bad read—it just left me with mixed emotions due to the title of the book. The authors are very knowledgeable and that shows in each of the chapters. Though I felt the book made things look so easy, the authors were sure to point out that the solutions there were not in-depth, but enough to get you started. If you are just beginning your trek into web development, then this book would be a good read to get you up and running in no time flat. However—for long term involvement in the web, or a more in-depth discussion of the topics listed in the title, you may want to grab a few more books.

Web Standards Creativity: Innovations in Web Design with XHTML, CSS, and DOM Scripting

Nate Klaiber — Mon, 30 Apr 2007 14:37:00 +0000

Web Standards Creativity: Innovations in Web Design with XHTML, CSS, and DOM Scripting by Cameron Adams, Mark Boulton, Andy Clarke, Simon Collison, Jeff Croft, Derek Featherstone, Ian Lloyd, Ethan Marcotte, Dan Rubin, and Rob Weychert —whew—was an excellent resource for any web developer. Each of the authors had their own chapter based on different aspects to create accessible, usable, and standards based websites. Andy Budd wrote the introduction and let readers know that this book was an extension to his previously published CSS Mastery—and I would agree. This book was broken into 3 main sections and 10 total chapters.

The first section was dedicated to Layout Magic. The chapters covered such topics as background images, page structure and contents such as menus, content highlights, and the masthead. We got a glimpse of how you can best manage, or tame, a wild CMS using CSS, Javascript, and Flash (sIFR). We move on to discussions related to switching your layouts based on your body selectors. This chapter exposes tips and tricks to create a website with several layout options—by switching a class on the body—all of the underlying markup is the same. Next we take our skills and apply them to a layout that jumps out of the grid or boxy layout. For those of you who have read Transcending CSS this chapter will be familiar as Andy Clarke walks us through a layout while using element selectors, descendant selectors, and adjacent sibling selectors. If you love pink, you will love this layout! The last chapter in this section discusses some creative uses of PNG’s. I would say this was one of my favorite chapters of the entire book. Jeff Croft does a great job discussing the different image formats, their uses, and why PNG is now a viable option for your websites. He shows some great examples with the alpha transparency and it’s uses for things like image captions, icons, and even watermarking and masking. This section gives you a solid foundation to begin creating some very exciting layouts.

The second section bridges the gap between print design and web design. Mark Boulton starts this section off by giving a brief history to the grid in print design and how this can be applied to the web. He shows us how to use background images and a little bit of math, allowing you to create websites that align to a horizontal grid. For those who have seen subtraction.com, or even Mark’s personal site, markboulton.co.uk, you can see this example in action. The next chapter talks about Typography. I think that this chapter could have been expanded into it’s own book—there is much to be discussed here. This chapter gives you the tools you need to creatively use elegant typography in your layouts’without sacrificing accessibility. These two chapters give a great primer on getting inspiration from other areas of design—including print.

The final section is related to the DOM and some tricks to enhance your website. The first chapter talks about printing. Using a mixture of print stylesheets and the DOM we are able to print specific sections of a page, while hiding the unnecessary elements of the page. The user is given total control—so this solution only helps to save a user from wasting mass amounts of paper (they can select to print the entire page if they would like). The next chapter discusses extending your layouts based on the size of the browser port (resolution-dependent, though not directly dependent on the screen resolution). The tricks here allow you to create a layout that looks great in a smaller viewport, and re-arranges the layout for those who use more screen real estate. This is not stretching with the viewport (fluid), but actually re-arranging your columns and navigation based on the viewport. Some very valuable tips in this chapter. The last chapter finishes us off with an accessible sliding navigation. This example can be found all around the web, but most of them don’t always address the accessibility needs and issues that may arise. Derek Featherstone does a great job of putting accessibility at the forefront of creating the sliding navigation, while still giving you a stunning end product.

This book was a great read, and is packed full of great tips, tricks, and usable scripts to enhance the overall usability of your website. All of this is done without hindering the accessibility for the widest audience. This book is highly recommended for those who are looking for the best practices to achieve different effects. To be honest, some of the chapters were very elementary—while others were more advanced—but everything was explained very well by the authors and the code examples.

Microformats: Empowering Your Markup for Web 2.0

Nate Klaiber — Wed, 18 Apr 2007 19:25:00 +0000

Microformats: Empowering Your Markup for Web 2.0 by John Allsopp is an incredible resource for learning Microformats. I didn’t know what to expect with this book, as part of me wondered how someone could take over 300+ pages to talk about Microformats. Truth be told — this book was very in-depth from cover to cover. Microformats are still in their infancy, being just a few years old. However, as we see throughout this book — there are many big players who are staking ground in the value and use of Microformats. I recently read HTML Mastery which scratched the surface of the power of Microformats. I would consider this book The Official Guide To Microformats with all of the information available. Here is a brief glimpse of what is found in this resource:

The book is broken down into 5 parts, but I will look over each chapter individually.

Chapter 1 answers the question “What are Microformats?” This is a thorough introduction to Microformats, the semantic web, the benefits of using Microformats — as well as it’s origins, definition, and principles. The principles include:
1. Solve a specific problem.
2. Start as simply as possible.
3. Are designed for humans first, machines second.
4. Reuse building blocks from widely adopted standards.
5. Are modular and embeddable.
6. Enable and encourage decentralized development, content, and services.
These are vital to the heart of Microformats. Though the web is aspiring to be semantic — we still have many problems to solve to help out our machine friends in the process of making sense of our language.
Chapter 2 gives us some quick snapshot views into how Microformats are currently being used. Discussions of browsers, their support, and their future. It is exciting to see the possibilities of Microformats being built into the browsers — since they are decentralized they will allow us to find things much easier (and make sense of those things). There are currently many tools available to aid a developer in creating the necessary markup and structure for formats. It is important to note that Microformats are not a new language, but are simply built onto already existing XHTML. The author presents the chicken and egg struggle and where Microformats are already being used in the wild. A few of those include, Yahoo, Cork’d and Apple. Not only are there early adopters on board, but there are services to help people make sense of the content. A few of these services include Technorati and Pingerati. These services all you to generate vCards from your properly formatted hCards. It also allows you to submit your site for Microformats searching. These are some powerful tools that will only continue to expand and grow.
Chapter 3 discusses the necessary foundation to create Microformats — Semantic HTML. The author discusses the days of the web where HTML was wrongly turned into a presentational language. HTML is a structure. It is semantic. It gives meaning to your documents. Your presentation layer belongs in your CSS (most developers will know this, unless they are living under a rock). He discusses some of the not-so-popular HTML elements, as well as elaborating on their proper use and placement in a page. This chapter ends with the fact that HTML has its limits. There simply aren’t enough tags for us to complete many of our common tasks (with semantics in mind). This is where Microformats come in.
Chapter 4 is where we start to get our feet wet. We are introduced to Link-Based Microformats. I won’t elaborate on each, but a few of these include rel-license, rel-tag, and rel-nofollow. These are embedded in — you guessed it — links.
Chapter 5 takes your relationship a step further. Here we discuss XFN. If you have used any blogging software then you have most likely come into contact with this. This is defining your relationships based on the rel attribute. There are many relationships that can be defined, and several more that are planned to be added. This chapter shows some of the services already utilizing XFN, as well as how you can use the rel attribute and CSS attribute selectors to style your content. Lean, semantic, markup.
Chapter 6 looks to geo and adr Microformats. Geo is related to defining your location via latitude and longitude. We are also introduced to a new design pattern: abbr. The adr format is used to markup addresses. These two Microformats used together have added rich value to applications such as Google Maps, Yahoo Maps, and Flickr. Again, we are given some examples of styling these elements using their attributes as hooks.
Chapter 7 takes use a little deeper with hCard. hCard reuses the already established format of vCard used in many applications today. Both individual persons and organizations were discussed. Again, we are introduced to services currently using hCard, as well as several different ways to style our hCard using the given hooks.
Chapter 8 helps us to get our dates in order with hCalendar. Again, hCalendar extends from vcalendar (used in many applications like Outlook and Address Book) Both basic and complex events were discussed here. I like how we have the ability to add a calendar to a page and add multiple events to a specific calendar. This shows just how flexible Microformats are. We also get to see a complex example of a timeline marked up in a table. Here we see how Microformats utilizes the semantic markup to achieve specific tasks. Using axis, scope, and headers allow us to create an accessible table — while also reaping the benefits of vevent. We get a glimpse of the tools available to help you construct hCalendars, as well as services currently using the hCalendar format.
Chapter 9 brings us to a few items in draft format, hReview and hResume. Though they are drafts, they are very solid and can be implemented in their current state. These items allow for great flexibility as we can use compound Microformats (just as we can use compounded XHTML elements). hReview has it’s core, but certain elements allow for extensions of hCard, rel-tag and rel-license. Again, very powerful ways to build your Microformats into your pages. As with the other chapters, hooks were shown and some basic styling instructions were given.
Chapter 10 discusses hAtom. This doesn’t seem to be as widely used as the other Microformats we have seen — but there is still great value for syndication and publishing (alongside RSS).
Chapters 11 and 12 show Microformats in the wild with 2 case studies: Cork’d and Yahoo!. These chapters featured interviews with Dan Cederholm as well as Nate Koechley. Cork’d is a relatively new application with Microformats attached from the beginning. Designer Dan Cederholm discusses how and why they chose to use Microformats (and when) in their application. Moving up the scale to a larger organization, Yahoo! is utilizing Microformats in many of their major applications including Upcoming.org and Flickr. These case studios show how many organizations are starting to take hold of Microformats, and how simple the process really is to reap the benefits of your semantic structure.
Chapter 13 and the Appendixes discuss how to get involved with Microformats. The goal is to have a decentralized service, so Microformats are not as closed as other formal standards are. They are open to more developments as long as they stand in line with the principles behind the foundation. The appendixes give a full listing of all Microformats, Design Patterns, and the People and Services using Microformats in their applications. The appendixes are extremely valuable to have as a resource as you begin your journey with Microformats.

I have had a passion for Microformats for the past 6 months or so. I started researching and really diving in to understand the goals. I was immediately able to see the benefits — but there was still the chicken and the egg question that was in the back of my mind. I don’t feel this question is even necessary anymore, as I move ahead utilizing Microformats (and building applications to utilize them) in my development of websites. They don’t take long to put in place as they go hand in hand with a solid HTML structure. So I guess the only question is: why wouldn’t you use them?

This book was a great read, and will continue to be used as a great resource.

The Art and Science of CSS

Nate Klaiber — Tue, 10 Apr 2007 21:22:00 +0000

The Art and Science of CSS was a quick read (208 pages) and packed full of valuable code examples. Unlike other CSS books that teach you the specifics of CSS with vague examples (not vague in a bad way), this book teaches you specific examples and gives you extra resources. This book is somewhat of a cookbook of commonly used CSS methods. Each author brings their unique writing style to the table, and each chapter focuses on a specific aspect of design and its CSS and styling methods.

Chapter 1 starts with Headings. The author of this chapter gives a brief introduction to hierarchy and branding, and how you can achieve more control with your look and typography. As typography is discussed, he moves on to talk about image replacement and the many techniques available to us today. There is no perfect solution when it comes to image replacement, but the author does a great job of showing current methods, their advantages, and their disadvantages (including an in-depth section on sIFR).
Chapter 2 is all about Images. The author starts by showing you how to create a basic — but aesthetically pleasing — image gallery. The task at hand is to create the enlarged version, the thumbnail page, and the galleries page while keeping the markup lean and semantic. Each of these are put together very nicely with flair not usually seen in off the shelf image galleries. The author also discusses how to create images (in context) with captions, including a nice use of transparent PNG’s. The author’s creative use of captions give you options ‘outside of the box’ (both semantically and philosophically) of normal captions that are seen all around the web.
Chapter 3 shows us that backgrounds don’t have to be boring. This is a very simple chapter that discusses backgrounds of the past (repeating pictures, large pictures, etc), and then looks forward to the present in getting creative with your backgrounds. He uses a case study as an example, and it shows specifics of positioning and layering.
Chapter 4 jumps into Navigation. Different types of navigations are discussed (vertical, horizontal, tabbed, variable width, etc) and shown with specific examples. The author shows how to take from each of those to create advanced navigation systems using images and your semantic markup. I think that from this chapter a user could create an advanced navigation simply because the foundation is set pretty solid before he gets to the advanced section. This chapter goes hand-in-hand with chapter 1 when talking about image replacement.
Chapter 5 discusses the dreaded (sometimes feared) Forms. Forms come in all shapes and sizes — and it is up to us to build them accordingly with the user in mind. The styling in this chapter spruces up what is a rather mundane form — while giving you great flexibility and hooks to extend yourself. The author discusses the several different layout types (top aligned label, left aligned label, right aligned label) and shows how to enhance each. If you work with forms often, this chapter will help you whip up a clean interface for the task.
Chapter 6 is everybody’s favorite chapter — Rounded Corners. The author gives you an arsenal of tools (and knowledge) to attack the task of adding rounded corners. He discusses the different methods (horizontal stretching, vertical stretching, and full flexibility) and shows you how to achieve each — keeping in mind the task of keeping the markup minimal and meaningful. We also get a brief glimpse into what CSS3 will have to offer us with multiple backgrounds per element.
Chapter 7 closes out the book with Tables. Tables still have a strong place in web development — and the author shows you how to use tables properly (with semantic markup) and then how to give them a little visual jump-start and interaction. The markup presented here helps you give clear meaning to your tables — as well as building with accessibility in mind (which is always important with tables, specifically). We round off the chapter looking at some interaction enhancements via Javascript that we can use with our tables (sorting, striping, and hovering).

Overall I found this book to be an excellent read. It was short and to the point, and gives the reader a great starting point (as well as inspiration). The book itself is well designed. My only qualms with the book is that the code examples are listed in full in many places, which gives less room for content related to the chapters. As I said in the beginning, this was a fairly quick read — but well worth it. I would say that this is for an intermediate CSS developer, as specific CSS is not discussed in great detail but given to you as a way to achieve a specific design task. If you are familiar with CSS and need a quick way to achieve the tasks listed above, then this book is perfect for you.

Bulletproof AJAX

Nate Klaiber — Tue, 06 Mar 2007 20:11:00 +0000

Bulletproof AJAX by Jeremy Keith was an excellent beginners book to AJAX. For those who have read Bulletproof Web Design by Dan Cederholm, this book literally took the same approach. The book starts with the very basics and walks you to the end where you create a fictional bookstore that utilizes AJAX. Each chapter addresses what it means to make an AJAX application bulletproof. The author is brutally honest while informing you the barriers that AJAX faces, and how to get around them. Sometimes the best solution is: don’t use AJAX. Obviously, this isn’t the case for everything — or there wouldn’t be a book to read. I appreciated the approach of making sure that your AJAX applications utilize progressive enhancement and are unobtrusive. These are two key elements when dealing with JavaScript as a whole. The entire journey of this brief (but informative) 200 page book looked a little like this:

Chapter 1 answers the question “What is AJAX?” and gives a brief introduction and history lesson as to it’s origins. This is very basic, but begins to get your feet wet understanding that AJAX is not a new technology — but one that has recently hit the spotlight.
Chapter 2 gives a thorough overview of the Document Object Model. He explains what the DOM is, how it relates to your structured HTML and Javascript, and the methods associated with traversing the DOM. This is very important as he moves forward to create unobtrusive AJAX.
Chapter 3 dives into the XMLHttpRequest object, it’s origins, and how to create a bulletproof instance of the object. This handles the differences between IE and other browsers and how they implement the request. He creates a wrapper for use (and use through the rest of the book) that allows us to send requests, receive responses, and then position it accordingly in the DOM.
Chapter 4 covers the Data Formats that are returned by our request. These include XML, JSON, and HTML. He covers each data format, and creates another wrapper for retrieving the different data formats.
Chapter 5 introduces HIJAX. This is where he irons out some of his previous scripts. Initially inline scripts were used as examples, but with HIJAX we see how we can create bulletproof implementations of AJAX. Topics covered here include progressive enhancement, unobtrusive Javascript, and rich clients.
Chapter 6 forces us to hit a wall (briefly). This chapter discussed the challenges that AJAX faces (and has faced in the past). Some of the challenges revolve around web services and connecting to remote API’s, making your application backwards compatible, how to work around browser inconsistencies and consistencies (The back button and bookmarking), and how to wireframe an application that will change in each section.
Chapter 7 discusses accessibility in relation to AJAX. One of the most frustrating parts for any application moving forward is dealing properly with screen readers. Screen readers are incredible tools, but since they sit on top of an existing browser it can make some things rather difficult (especially checking for the existence of Javascript).
Chapter 8 starts to wrap things up. Taking everything we have learned to this point, he discusses planning, applying, and bulletproofing your application.
Chapter 9, the final chapter, looks to the future of AJAX. Not only did it discuss the future — it covered many of the current frameworks available. He does a great job of discussing the good and bad of using frameworks — and where frameworks are best suited.

Overall, this book was a great read. This book is geared for the beginner, and I believe it will help a user have a complete grasp of AJAX. AJAX is a tricky subject, and Jeremy does a great job of tackling each subject in great detail. This book would go well with a Javascript book to help you bulletproof your applications. This is a must read for those who are interested in understanding AJAX and its place in the world of web standards.

Pro JavaScript Techniques

Nate Klaiber — Wed, 21 Feb 2007 22:36:00 +0000

Pro Javascript Techniques by John Resig was a very in-depth look at Javascript and its capabilities. I loved this book for the simple fact that the first chapter started by introducing you to objects in Javascript. No time was wasted on the basics, you were diving in deep right from the beginning. Also, even though John is the creator and lead developer of the jQuery Javascript library, this book was not about pushing his framework. He did a great job of introducing many of the different frameworks and listing their strengths and purposes.

The entire book had you building a library of usable scripts that allow for great portability while using Javascript in your applications (or even your personal website). Each chapter discussed the scripts, their functionality, their support, and giving great details to how they worked. Most chapters also gave you examples of the scripts in a working environment. A quick breakdown looks like this:

The first part of the book discussed Object Oriented Javascript. This included information related to creating your own objects and extending the core javascript objects. He then moved on to discussing testing of your code and how to package it for distribution. This is especially helpful for those working in an environment with multiple developers and programmers. Thankfully, he discussed unobtrusive DOM scripting, which still may be new to some developers. The first part closed with discussions related to AJAX and browser support, both of which we would see more of later. All of part one was a brief introduction to what we would read through the rest of the book.
Part two discussed Object Orient Javascript in more detail. This included things such as basics of objects, object creation, references, overloading, scope, and closures. I found this chapter to provide a solid foundation for the rest of the chapters to come, as well as very descriptive related to objects. The next few chapters discussed creating reusable code and shined some light on several of the libraries available. Also, we got a glimpse into the wonderful world of debugging Javascript and were introduced to some great tools to help you as you build.
Part three dives into unobtrusive Javascript and intricate details related to the DOM and how to manipulate the DOM. Once we learn how to properly manipulate and traverse the DOM, we move on to attaching events to elements. All of this was discussed in light of progressive enhancement and making sure content is always available. The last three chapters of this section discussed Javascript and CSS, how to improve forms (which is also a topic for another discussion), and a practical example of building an image gallery.
Part four pushes ahead to AJAX. The first chapters discussed the history of AJAX and some of its common uses. With a foundation of understanding what AJAX is, the next chapters were spent with practical examples of enhancing your blog (quick access to all posts dynamically on scroll), building an auto-complete search field, and creating an AJAX Wiki. I found that the blog and auto-complete were a little more valuable than the Wiki.
The final part looks to the future of Javascript. This section was very educational as we move forward. This is very important to be aware of what will be available in the near (hopefully) future.

The appendixes were extremely valuable, and I will use it as a quick reference as I begin developing more Javascript. A full listing of the DOM reference, Events reference, and the Browsers.

Overall, this book was an incredible read and is highly recommended for those who want to take their Javascript skills to the next level.

Rails Solutions: Ruby on Rails Made Easy

Nate Klaiber — Sun, 18 Feb 2007 17:06:00 +0000

Rails Solutions by Justin Williams was an excellent primer to the popular framework, Ruby on Rails. I recently had a chance to learn some basics of the RoR framework from a friend of mine, Stephen Rainey. He got me up and running and pointed me to some great resources and books. This book is a recent release from Friends of Ed and it is highly recommended if you are just getting your feet wet with Rails. The book walks you through each step to get up and running and developing the ‘Railslist’ application. The author takes the time to walk through the installation process for both OS X and Windows. The flow of the book was very easy to read and each chapter built more from the previous chapters. The goal of the book was to create a working rails application, while showing you the possible routes and benefits. The overall flow looked a bit like this:

The first chapters were very elementary. This is a good thing for those looking to learn the right way to get started. The author walks you through Ruby, the language behind Rails, and shows you some of the constructs and nuances of the language. This is a good primer for those coming from another language (such as PHP) that looks very different. After the introduction to the language, he moved forward into the setup.
Installing Rails was painless. The author walks through the necessary steps to setup a development environment on the Mac and Windows platform. For those who are interested in some additional resources on setting up your environment, check out the updated Building Ruby, Rails, Subversion, Mongrel, and MySQL on Mac OS X by Dan Benjamin. Personally, I have found using Mac Ports a very easy way to manage your development environment and it is worth a good look.
We are now ready to build our application! Through the next few chapters, the author walks you through creating a ‘railslist’ application. With each chapter you learn new aspects of rails. You learn how to setup your project, how to use scaffolding, how to generate your models, views, and controllers, and how to get your database connected and working. He goes in depth on each aspect. Setting up relationships and validations in your model (ActiveRecord), setting up your Controllers and using custom routing, and then how to get your views in place and use partials and .rjs files. Towards the end, we even get to add a dash of AJAX to the application for some simple tasks.
The last chapters and appendixes discuss deployment of your application to a production server and all the pieces that need to be in place to go live to the public and handle the traffic. Though this book covered the steps, I have heard that there is more to be said on deploying your application — so you may want to look at some more resources.

This book is for a beginner to Rails. If you are an advanced programmer or have been in Rails for a while now — then this book is not for you (and the author states this in the first paragraph of the book). I felt that there were some pieces that could have been discussed related to progressive enhancement and accessibility (AJAX and CSS), especially when building the AJAX into the application. However, that is no reason to not give this book a chance.

HTML Mastery

Nate Klaiber — Wed, 17 Jan 2007 22:35:00 +0000

HTML Mastery by Paul Haine was definitely not your average HTML for Dummies type book. Paul did a great job of covering HTML thoroughly and ended on a note that inspired you to think beyond the basics. Some might be turned off by another HTML book, but this book is far from that — this book is packed full of information related to all aspects of HTML, including (but not limited to), XHTML, CSS, full discussion of possible tags, and how to appropriately markup things like tables and forms. Even an advanced developer would benefit from reading this book in it’s entirety (about 215 pages).

There is much to be said about the content that is packed into those 215 pages, so I will give a brief rundown:

The beginning of the book starts out with your basic terminology and background of HTML and XHTML. The author even covers the debated topic of which to use, and how to properly use each type. He discusses XHTML and some of the myths associated with it that seem to make it a better technology than HTML. I am glad this was presented in the first few chapters as I think many people have a wrong perception of XHTML. The chapter ended by discussing the anatomy of an XHTML document, including a breakdown of the doctype declaration and its parts.
Now that he got the basics (and some history) out of the way, he dives into the tags available to us — and ‘using the right tag for the right job.’ This chapter is an excellent breakdown of the available tags, their support, and their function and meaning in the context of semantic markup.
The next two chapters discussed marking up tables and forms. Many would think this is an easy task, but for anyone who has built an accessible table — you know how hard it is to make sure you have all of your bases covered. This has also been covered in some other recent books as well, but it is a good thing to hammer home to those who are accustomed to their WYSIWYG and building tables and forms in that environment.
Chapter 5 was definitely my favorite chapter of the entire book. This chapter was devoted to semantics and microformats. I have been using microformats in several recent projects, and am a little obsessed with giving more meaning to my content. The author broke down all aspects of microformats and discussed their structure and the markup used to create them. Everything from hCard, hCalendar, hReview, XFN, rel-, VoteLinks, and XOXO. Reading through each of these chapters challenges you to use these in an array of different ways. He then goes on to discuss the Dublin Core Metadata Initiative and structured blogging (This is a topic for another day all together). Overall, this chapter challenges you to really look deep into your markup and give it structure and meaning — for both your users and the machines reading it.
The book closes out the chapters discussing more detail related to semantics and how to avoid things like span-mania and classitis. This is a final reminder from the author to really give meaning to your content — to create clean, flexible, meaningful, and scalable code without the clutter. The last chapter takes us a step ahead to get a view of what we can expect with the future and XHTML2.0 and Web Applications 1.0.

Overall, this book was a quick read — but well worth every page (even the appendixes). If you are a developer that prides yourself on clean markup, this book is still a valuable addition to your library. If you are a developer trying to ween yourself away from a WYSIWYG editor, then this book is a must have. The author does a great job of covering HTML in an exhaustive manner, way beyond what you will find in a basic HTML book.

Pro CSS Techniques

Nate Klaiber — Tue, 09 Jan 2007 22:16:00 +0000

Pro CSS Techniques by Jeff Croft, Dan Rubin, and Ian Lloyd is a very thorough book on practical CSS. Having just read Simon Collison’s Beginning CSS Web Development I found this to be a great continuation of the learning process. This book picks up where Simon’s book ended, and even briefly covers some of the same topics. This book is full of great information and each author had a fun personality (and sense of humor) with their chapters.

The book jumps right in and walks you through specificity and the cascade and how this will help you keep your markup neat and tidy (without any superfluous markup). This topic can cause confusion for many beginning CSS and even those who are advanced. Having a strong understanding of the cascade and specificity will greatly help you write cleaner code and solve any debugging issues that may arise. This chapter was full of examples, charts, and interactive walkthroughs to help you understand the process.

The next few chapters were spent discussing the browsers, managing your CSS files, and many of the hacks used to fix problems. These were similar to some of what was seen in Beginning CSS Web Development — but they require special emphasis. I didn’t feel that any of the authors ever advocated using hacks to solve problems. They challenged you as a developer to dig deeper and find workarounds that didn’t require hacks. However, when it is necessary — they explain the process of using conditional comments versus mixing any hacks into their own sheet or section of your other files.

Chapter 7 was by far my favorite chapter of the entire book. I have read many other CSS books that show you advanced layouts and techniques, even full of the code and images, but don’t fully prepare you for the frustration that may arise. This chapter walked you through creating different layouts. Absolute positioning, floats, liquid layouts, fixed with layouts, and elastic layouts were all discussed. The best part about the chapter is that the author walks you through your failures. In seeing these failures and being aware of them, it will ultimately help you avoid them in the future (or at least be prepared when something goes awry). Failure is a part of learning CSS, and the author comforts (and humors) the reader as he shows the failures, explains why and what failed, and how to fix and continue with the layout. In the end you are working towards a very simple, yet flexible, layout.

Another topic that is not often discussed is that of typography. This chapter was an exhaustive covering of typography and the web. It included information about upcoming typefaces available in vista, as well as some current typefaces that you might not know about. It also covered things like leading (line height), kerning (letter spacing), and how to make sure your liquid layouts (or high contrast layouts) don’t ruin the legibility.

The last few chapters walk you through styling everyday elements like tables, forms, and lists. The last two chapters were focused on stylesheets for other media (print, screen, projection, etc). I found this chapter very interesting as we are moving toward supporting mobile devices. I think initially it would be easy to think you can serve up the ‘handheld’ stylesheet and all is well — however we are finding that this is not true (Which is why I can’t wait for Cameron Moll’s book on Mobile Web Design). With so many different devices and services out there, what will be the best way to target them? I used to think the handheld stylesheet would solve many problems — but I am re-thinking that as a solution.

Finally, the book wraps up with an exhaustive list of CSS References including: allowed values, element type, and initial/inherited values. Also covered is the CSS specificity chart and the browser grading chart. The appendix of this book makes a nice desk reference to help solve an issue.

Overall I really enjoyed this book. If you are still dipping your feet into CSS, then this book will help you understand the inner workings of CSS and help you avoid many frustrating hours of debugging. Yes, there were some advanced topics that weren't discussed that could have been (hasLayout), but overall the book covered everything exhaustively. Do yourself a favor and pick up a copy of this book.

Transcending CSS: The Fine Art of Web Design

Nate Klaiber — Sun, 31 Dec 2006 12:57:00 +0000

Transcending CSS by Andy Clarke literally ‘transcends’ other CSS books that I have read. Now, to bring that into context — the other books I have read were incredible books, this one just takes CSS from a different perspective than the others (so you should still read the other books too). The writing style of this book was different from other CSS books which were very instructional. Along with a different writing style came a different design. This book is designed beautifully from front cover to back. The full color photos, original artwork, sidebars, quotes, and even the way he slips in photos from other developers into newspaper articles makes this book visually pleasing.

Mr. Clarke goes down a different path and calls for true progressive enhancement. Ideally this book would not be one for beginners (and he makes this claim), but I do believe it has some great inspiration throughout. He makes a good point when he questions how progressive enhancement could be progressive if we haven’t really moved anywhere in the past few years? As web developers we have many hurdles to jump when creating sites that function well across all platforms and browsers. There are certain browsers that are worse than others. However, do we simply let them hold us back or do we move forward with the browsers that are proactive and support standards. This is not to say forget the older browsers, but it does call for a higher standard of quality available to use in standards compliant browsers.

The book is divided into 4 sections:

Discovery. This chapter instantly jumps into the ‘transcendent CSS’ approach and discusses some of the different selectors and options. Most sections are brief, but get right to the point. This chapter is devoted to seeing markup in everything that you do. He advocated a ‘content-out’ approach to your designs, where you start with a solid foundation and structure with your content and build from there. This chapter was fun as there were little ‘quizzes’ of how you would markup different sections in a given photograph. It stretches you to really see the markup and structure first and foremost.
Process. Just like the first chapter, each section was touched on briefly — but was right to the point. This chapter discusses the many processes available to building your website. Starting with content and moving to things like wireframes, The Grey Box Method, and Interactive Prototyping. He discusses best practices as you work through these processes. This chapter came to a close with a little practice session (just to get your feet wet).
Inspiration. This was probably my favorite chapter of the entire book. I found that this chapter was very rich with artwork, photographs, and screenshots — oh, and some text, too. He challenges you to look beyond the web for your inspirations and designs. He brings examples to the table, as well as in-depth discussion of using a Grid in your designs. This chapter really encompassed The Fine Art of Web Design.
Transcendence. This was a perfect way to bring this book to a close. This chapter looks to CSS3 and all of its possibilities. CSS3 may seem like a long stretch away, but it is very important to be aware of what will be available and to begin thinking creatively — prepared for what is to come. This chapter was rich with examples and screenshots of the possibilities.

As I stated earlier, this may not be a book for beginners — but it sure is full of inspiration. There are some books that you read and think ‘Wow, this book is going to transform the way we think about CSS’ — and this book is just that. CSS Zen Garden had the same feel to it, but this is more updated. Not that you don’t need other CSS books — but this book is a must read as we move forward into 2007 and years to come.

Web Standards Solutions: The Markup and Style Handbook

Nate Klaiber — Mon, 27 Nov 2006 18:35:00 +0000

Web Standards Solutions: The Markup and Style Handbook is a 2004 release by Dan Cederholm. I was inclined to read this book after reading his more recent publication, Bulletproof Web Design. I really enjoy his writing style and the content presented. Though this book was published a few years ago, the principles still apply to many of the modern techniques used to solve problems.

What I liked most about this book was how Dan keeps his opinions to himself and brings facts and solutions to the table. The book was not watered down with ‘selling’ web standards. Each chapter concluded with several routes to achieving different tasks. Dan walks through each of the methods and explains how each works (and its upsides and downsides). Many of the chapters also concluded with ‘bonus’ or ‘extra credit’ pieces that stretched the reader a step further.

The structure of this book reminded me of Simon Collison’s recent book, Beginning CSS Web Development. Both books are excellent in their own respects, and I would recommend having both as a quick reference.

Part One walked through the markup. He took short chapters and devoted them to things such as lists, headings, tables, quotations, and forms. Each chapter discussed old methods for handling tasks, the markup and meaning associated with the tasks, and how to best organize your markup. These chapters give a very thorough understanding of the everyday tags used in web development.
Part Two got down and dirty with CSS and applying it to your markup. Not only did it discuss CSS, but it also discussed organizing your CSS, applying Print styles to your pages, and how to manage things such as text and image replacement (always a tough subject). He gives a very thorough walkthrough of applying CSS — and then looks to the future and stirs up the creative juices.

There are several times where I have referred back to Bulletproof Web Design to help me get creative with different tasks. Dan’s writing style is great in that he gets out of the way and opens up the door for you to get creative and get your hands dirty. It’s not weighted down with personal opinion or selling — but is loaded with practical techniques and methods. If you are new to CSS and would like to learn best practices, I suggest buying this book along with Simon’s book, Beginning CSS Web Development — these two books will give you a solid foundation moving forward. For the advanced CSS developer, this book is still nice to have as a reference.

Getting Real

Nate Klaiber — Wed, 08 Nov 2006 23:06:00 +0000

Getting Real is a recent release by the guys over at 37signals. I actually stumbled upon this book and read it online from their website. It is a very quick read that conjured up some different thoughts and approaches. I have used different 37signals applications in the past, so I had a history to understand their writing and developing style. This book reflected their business values and goals, so it may cause conflict for some readers who don’t necessarily agree with everything they bring to the table.

I must say, I am not completely sold on all of their methodologies, but I am also in a different market than they are (development wise). A few things I enjoyed from this book:

The problem of scaling. Many people make this out to be a big problem before it is really a big problem. They focus heavily on making sure their server can withstand the biggest Digg, without knowing if they will ever need to worry about that scaling. Some sites are moderate sites and will stay that way. They may be able to get by without load balancing and other tricks to keep their server running. Not that you shouldn’t look at this, but that you shouldn’t focus on it too early in the development cycle.
Taking user feedback. They seemed to contradict themselves a little here. In one breath they said “take what the users give you, and throw it aside and forget about it.“ Basically, you be the judge about what is good for the end user. Later on they say “We already knew what needed to be done next because our customers constantly reminded us by making the same requests over and over again. There was no need for a list or lots of analysis because it was all happening in real time.” The distinction is never made as to what requests are actually used (except through repetition from users). How do you know of a repeated item if you are throwing their initial requests away? I understand the concept — I just felt it wasn’t articulated as well as it could have been.
Don’t specialize. This idea takes different routes from different developers. I am in agreement with them. Too many people try to separate every little piece which adds to unnecessary confusion. They are aware that specialization has its place, but it takes away from your developers really taking hold of the application. Instead of seeing the whole picture, they are seeing only specific parts of the puzzle.
Getting in the Zone. This is simple, and for anyone who has programmed they understand this completely. It is that uninterrupted time where you can complete tasks.
Passionate People. I think it would be hard for an application to succeed if the people behind building it didn’t really believe in it. For 37signals, much of their development and applications came from their own needs. Having passionate people on board will ultimately enhance the production as well.

These are just a few items, but they are best read in context with the rest of the book. The main struggle I had was working in a corporate environment, some of their things are easier said than done. When you are building a web app for yourself all of their items make sense. However, when placed in a corporate environment the picture seems to shift a little bit. Not that this is a bad thing, or that the team at 37signals is wrong — I just think there is a big gap between the two (although I wish there wasn’t).

Overall, I enjoyed the read and was encouraged and refreshed by much of what they had to say.

Ambient Findability: What We Find Changes Who We Become

Nate Klaiber — Tue, 31 Oct 2006 14:44:00 +0000

Ambient Findability by Peter Morville took me back to my days of college. I initially purchased this book due to it’s high reference from other respected designers and developers. My first inclination was that the book would be about SEO or something along those lines. Though the book was small, it packed a big punch of information! I was pleasantly surprised at what this book had to offer.

This book went much deeper than I expected. As a disclaimer, I had many of my coworkers laugh when I told them the title of the book I was reading. However, I had a quick response as to what the book contained as the author quickly defines both ambient and findability. The author starts by giving background to how we come to find things. Not just as humans, he takes it to an even smaller scale discussing how ants find their way during their long journeys. Though this may seem odd, it helps to really put things into perspective. How do we find things? Do we all find things the same way? In relation to the web — what words or phrases do we use to find things? Do we use broad terms or more specific (long tail) terms?

This book is very tough to review, as I felt it was packed with so much information. The only way for me to really elaborate would be to put it into context, and by that time you could have read the book. The information packed in this book has really opened me up to an array of new questions related to searching. Outside of the context of the web, how do people find things? Inside of the web, how do people find things? I constantly monitor our analytics at Barbour Publishing, Inc. and watch how people find us, and where they go from there. Did they get the answer they were seeking? Was their search relevant? What terms did they use? What order were the terms? What punctuation is used? What did some of the other similar searches look like? What did their other searches look like? What did the spellings look like? So many aspects to look into — and then refine to make sure people can find the information they are seeking. Sometimes simple ‘like’ queries aren’t enough. Sometimes the index needs to be refined to incorporate stopwords, mis-spellings, aliases, and other pertinent information. Understanding the core principles, findings, and research will help you build a strong foundation and core.

I have found this to be extremely valuable and applicable to web development and answering the deeper questions. As stated earlier, this book is rather small in size but packs a big punch content wise. The author avoids ‘fluff’ or trying to tell stories, and simply dives into the core (which is sometimes even scary) — which is often times backed by a significant amount of research and supplemental resources.

Though this book is not directly related to web development — the lessons learned here can be applied to that medium. If you are a web developer, SEO expert, or simply want to know how people find things (and their decision process) — then this a book for you.

The book is very well written, very easy to read, and follows a logical progression.

Web Accessibility: Web Standards and Regulatory Compliance

Nate Klaiber — Mon, 16 Oct 2006 18:46:00 +0000

Update July 8th, 2007: Be sure to read the online chapter, Understanding Web Accessibility. Also, be sure to read Just Ask: Integrating Accessibility Throughout Design by Shawn Henry.

Web Accessibility: Web Standards and Regulatory Compliance was one of the more hefty books I have read in the past few months, weighing in at approximately 648 pages. The book spanned many different topics including accessible Javascript, CSS, accessible PDF, and accessible Flash.. This book was not a CSS Mastery, DOM Scripting, or The Flash Bible — but it covered each topic in relation to accessibility. Each chapter did a great job of covering all of the basics as well as giving extra resources if you wanted to find out more.

The book was split up into three parts:

Part 1: The Impact of Web Accessibility was initially a tough section to get through. This is a very important section, and sets the foundation for the rest of the book, but I was initially overwhelmed by all of the terms presented (some of which I was unfamiliar with related to standards). This section was full of great information, as well as links to discover even more information.
Part 2: Implementing Accessible Websites covers a broad range of topics (listed above). This was the lengthiest part of the book, but well worth the read. Much of what was discussed in these chapters has been discussed in other books I have read lately. Each chapter goes in-depth on creating accessible websites and using the technology at hand. The chapter related to assistive devices confirmed what Nathan Smith said: “I mean, I always thought browser differences were bad, but compared to the many screen reader quirks, wow.” Overall, it discusses best practices for web development.
Part 3: Accessibility Law and Policy wraps up the entire book. This section covers the legal information in an array of different countries as they relate to websites. Again, I was worried that this section might be dry — but I found it easy to read and learned much.

Most of this book could be summed up by Cynthia Waddell at the end of Chapter 16 where she states:

“The economic, political, and ethical benefits far outweigh the cost of this effort. The cost of being inaccessible — missing the boat on the coming age of thin clients, failing to serve our most needful citizens and employees, and legal liability — can be incalculable.

This millennium offers unprecedented opportunities for efficient, effective governance. The Internet should be accessible to all. It is the right thing to do.”

This book is a must have for any serious web developer. Don’t be intimidated by the size, it is well worth the read.

Beginning CSS Web Development: From Novice to Professional

Nate Klaiber — Sun, 17 Sep 2006 19:56:00 +0000

Beginning CSS Web Development by Simon Collison is the perfect beginners guide to CSS. As the subtitle says, ‘the book is about taking you from novice to professional’ by the time you are finished. This book is laid out very well, and moves at a perfect pace. Now, for those who are advanced CSS developers — this book is still a great book to have as reference to different aspects or topics. I agree with Simon, in that I wish I would have had a book like this when I started using CSS a few years ago. It would have saved many headaches and late nights of figuring things out the hard way. Here are some of my thoughts after reading the book:

The book’s pace was perfect.Simon did a great job of breaking this book into two major sections. The first section is comprised of understanding CSS. It starts with a very brief discussion of CSS and some core concepts. He doesn’t dwell on this, though, and dives right into the meat of the book. Some of the different aspects discussed were styling text, backgrounds, colors, images, lists, links, and tabular data. Each having its own chapter to discuss the basics.

The second section gets into more advanced CSS. It discusses positioning, floating, layouts, templating, usability, accessibility, and some tips and tricks. Each of these given a good amount of time with some great examples. The end chapter brings it all together with a case study, a very interesting case study to say the least (you’ll just have to read the book to check it out).
Styling of headers left me thinking about a few things. I agree with his approach, in using an actual image in the markup (since it is content). The flip side would be using image replacement — but then losing any textual representation or alt attribute if images are disabled and CSS is still active (unless you implement Richard Rutter’s method with some JavaScript). With his style of setting up templates and reusable CSS — it would be tough to update h2 images over an entire site when updating a template, design scheme, or even typeface (depending on the size of the site). This discussion has been had many different times, and I am not sure I am completely settled on one specific solution for image replacement. So, he gives the best solution for a beginner — I was just left wondering if there was a better option.
Styling of forms is something that is super tricky, even for the advanced CSS developer. He does a great job of covering three different approaches (table, using a combination of p and br and finally using a definition list). The tricky part is: What is the best solution? He gave the answer I would have given, in that it depends on the job and the needs. Lately I have been very prone to using a definition list to style some of my basic forms (contact, newsletter, etc). I believe this does a great job and gives great flexibility. Some would say that it is not a proper use of the definition list, but I would beg to differ. I think there are many uses for the definition list. Simon walks through each, giving you a base form template, and then using the cascade to style via the other methods.
Frustrations in CSS often lie in the confusions of browsers, hacks, and filters. Dealing with the different quirks in the different browsers makes things complicated (at times). I believe the best thing to do is to understand how each browser renders different elements with it’s default stylesheet. Simon discusses some of these differences, and then shows how to override with the cascade to get the desired results (IE: zero out margins and padding). I have always felt that using hacks was simply not the best option. Simon agrees with this, but at the same time shows how to manage hacks and filters — with descriptions of each and their workings (how they manipulate the browser bugs, etc). This discussion, coupled with his beginning chapter of managing your style sheets will ultimately help you to keep your CSS clean, organized, and protected against future browser fixes. Simon makes this process easier by explaining best practices and showing solutions.

This book is full of much more information, and I even learned a few things myself (I was not aware of the content: property and how to use it with a:after). If I were just starting out CSS — I truly believe this book would have been the perfect starter. Not only did Simon cover the basics of CSS styling, managing your CSS, and using CSS for advanced layouts — he also encouraged me to drink more tea. My evenings consisted of banana bread, some peach tea, and Beginning CSS Web Development. I think the tea helps you understand the chapters better, therefore making it a necessity.

For those beginning CSS and looking for the perfect book, this is it. Having read CSS Mastery by Andy Budd and Bulletproof Web Design by Dan Cederholm, I can say that all three of these books work very well together. If I could recommend a sequence, it would be to read this book first, followed by Bulletproof Web Design, and finally CSS Mastery. All three books are great, and all three serving a different purpose and audience.

DHTML Utopia: Modern Web Design Using JavaScript and DOM

Nate Klaiber — Mon, 04 Sep 2006 19:28:00 +0000

DHTML Utopia by Stuart Langridge was a very thorough book on using Javascript and the DOM. This book seemed to pick up from the previous book I read, DOM Scripting by Jeremy Keith. Not that one was better than the other, in fact, I think they complemented each other very well.

Stuart didn’t spend much introduction time for beginners, but dove right into manipulating the DOM in many different creative ways. He states clearly that Javascript should be used to enhance a page, and should degrade gracefully without (unobtrusive). With each chapter he made sure that his tutorials took this approach, and he stuck with it. Though there were several tutorials, I didn’t find all of them useful. For instance, his example of using Javascript and the DOM to create graphic rollovers could have been easier done using CSS. From a usability perspective, I have not found a case where rollover menus are really useful — but his menus were very impressive and I learned many things as he walked through the build. The principles behind each chapter helped me to understand different aspects of using Javascript.

Many browser still react differently to different calls. Stuart makes this very clear and gives you solid scripts to detect for different browsers and their support for different methods or calls. He didn’t dwell on the differences, but made it very clear how each browser reacted differently and how to overcome and support each browser. He brought many more advanced techniques to the table. As one who is still trying to find the best place to put this into practice, I appreciated his in-depth approach. At some times I felt overwhelmed, but the pace of the book easily kept me intrigued enough to stick around.

I wouldn’t recommend this to someone just beginning Javascript. It may actually cause you a headache without prior experience. This book is recommended for someone who has experience with programming and understanding the constructs of Javascript. Personally, I loved this book from the beginning to end. Unlike other books I have read lately, it wasn’t so much that each chapter built on the next — but that each chapter forced you to dive deeper and think through the process. From simple image rollovers, animations, and multi-level menus — all the way to the several different ways of using Javascript to make remote calls - this book was a solid read and gives you a great foundation.

DOM Scripting: Web Design with JavaScript and the Document Object Model

Nate Klaiber — Tue, 29 Aug 2006 08:32:00 +0000

DOM Scripting by Jeremy Keith gives you a very smooth introduction to JavaScript and the DOM. The books is more directed at those who are just beginning JavaScript or have used it in the past but would like more knowledge.

The book itself flows well from chapter to chapter. The beginning chapters give you a foundation to work with during the rest of the book. Jeremy teaches basic constructs of JavaScript programming and how and where they can be used. If you are already a programmer (not necessarily JavaScript), this chapter will be a quick one. It is very informational, yet straight to the point. Once he gets the basics and best practice techniques out of the way — he dives into the DOM and gives several useful examples. This is where it gets good.

Before moving further, I should mention that his best practices are applied all throughout this book — and that includes creating useful and unobtrusive JavaScript. So, with each chapter he shows the process and then brings it around full circle to an unobtrusive model. For instance, with the image gallery example, he shows that without JavaScript, this process would be useless, and we don’t need extra markup on the pages that won’t be used. He shows you, step by step (with great code highlighting and screenshots), how to build the image gallery on the fly. This way, if a user has JavaScript they can get the better experience. For those without, it degrades gracefully and doesn’t add unnecessary code to the markup. This is just one example — but is used on all of his building blocks throughout the book.

There were many times in the book I would question what was being done (from an unobtrusive standards perspective). Each of those questions was immediately answered in the paragraphs or chapters to come. Jeremy does a great job to present the big picture, along with explaining why things were done certain ways. I read this book in two days, simply because it was hard to put down. The last chapters (aside from the reference), were the icing on the cake. This is where he puts all of the pieces together for a fictional website, JayScript and the Domsters. This chapter takes all of the pieces taught throughout the book and puts them in a practical environment. Go ahead, play with the fictional site. It has nice little touches, that, even when JavaScript is disabled has a nice user experience.

Overall, I would highly recommend this book if you are looking to get your hands dirty with JavaScript and DOM Scripting. The book was an easy read, packed with useful information. Just as with CSS Mastery, each chapter would build on the last — all the way until the end where it was all put together as a whole. Also, I am currently reading DHTML Utopia, and this book was a great primer to JavaScript techniques. Thanks, Jeremy, for a great, concise, book on a topic that can sometimes scare people away.

Prioritizing Web Usability

Nate Klaiber — Sat, 26 Aug 2006 15:04:00 +0000

Prioritizing Web Usability by Jakob Nielsen and Hoa Loranger can best be described as a more ‘strict’ approach to web usability. If you have been in web development for any extended period of time it is likely that you have heard the name Jakob Nielsen. He offers great insight to web usability and has for many years. Some may view him as strict, some as normal, and still some as way off his rocker. No matter how you view him, he deserves much respect for his time spent in usability studies and the (somewhat timeless) statistics and information he brings to the table. I just finished reading this book, coupled with “Don’t Make Me Think” by Steve Krug, and appreciated what all of the authors’ could present through statistics, screenshots, and customer insight.

The first part of this book focused on revisiting early web usability findings. This dealt with discussing the aspects of web usability that have progressed since his first book. He went through each of them and re-evaluated their score. His scoring method was based on 1-3 skulls, with 3 representing major problems and 1 as not as problematic. He goes through each of them and asserts why (or why not) they received their specific rating. Many of these deal with the basics of web development such as underlining links, using animation or other intensive use of graphical elements, and the structure of pages. I found this section to be a great resource, but the best of the book was still yet to come.

The middle chapters (I would break this book into thirds), discussed assessing your website and potential usability problems. The chapters focused on such things as: Search, Navigation and Information Architecture, Typography, and Writing for the Web. Each of these chapters plunged deep into the root of how users interact with each element.

With search, it included such things as where the search box is placed, how it is worded, and how easily results are returned. He examined several sites and their search results — giving feedback to their listing and usefulness. The concept of Search Engine Optimization was also discussed here, giving you insight on how to optimize your internal website to interact with the larger search engines.
Navigation and Information Architecture was interesting, but I don’t believe much as changed in the past few years. Users are accustomed to many different elements when browsing a website (a standard, if you will). Many times when this is broken it causes the user to have to stop, spend time thinking about the site, and then interacting (if they stay in it that long).
Typography was discussed in detail, and I found this to be an informative chapter — even if you are not a designer. It lets you know what fonts are common for web browsers, the difference between serif and sans-serif and its effects on users and their reading pattern, and using case and spacing (and color) to present your content. These are often the little things that are overlooked when developing a website, and he gives several examples of typefaces in page structures.
Writing for the web is somewhat of an art. Many companies rely on marketing ‘fluff’ to get content in place. This strategy is more harmful than helpful as people are in search of your content — and if they get fluff or can’t find what they are looking for, they can instantly go to another website. Through this book, and others, I have found that the key to successful copy on the web is: Keep it Short.

The last part of the book discussed e-commerce, product page structure, using technology that works, and finding design that works. Again, I don’t feel that there was anything earth shattering or new mentioned — but reinforced with up to date websites and common mistakes.

When discussing technology that works, he made mention to accessibility. He states:

“An accessible site is one that removes obstacles that get in people’s way; removing the obstacle overcomes the disability.”
In design that works he emphasizes the practice of simplicity. He makes the analogy of interior decorating. He states that:

“An amateur decorator might pack a living room with a jumble of furniture styles, patterns, and textures in a misguided attempt to dazzle. In contrast, skilled designers carefully select items that support their clients’ needs, ruthlessly eliminating those elements that do not serve a real purpose.”

Basically, assessing each element of your design and asking if it simplifies the user experience or adds value. If it doesn’t, then remove it!
The steps to finding a design that works involves evaluating new technology.

“There will always be new technology, but setting your sights too high backfires. Early adopters are a minority.”

This book is an invaluable resource for anyone doing web development and is highly recommended if you want to really understand your users and their habits. It is a fairly quick read and is packed with up-to-date screenshots and statistics.

Don't Make Me Think: A Common Sense Approach to Web Usability

Nate Klaiber — Wed, 23 Aug 2006 13:07:00 +0000

Don’t Make Me Think by Steve Krug is a great resource for a deeper understanding of web usability. The title of his book says it all, and his writing style reflects it perfectly. A short read — but jam packed with great information.

What I like most about this book is the author’s approach. Many times those discussing usability will step on toes left and right, and do it intentionally. Steve’s approach is much more simple, and gives great insight into how websites are used. There is no pointing fingers or condemning you if you commit a usability ‘sin’. He simply shows some of the common mistakes — backs up his claim with statistics — and then shows possible solutions. So, while I felt guilty in some chapters, I didn’t feel like I was getting beat over the head. He does a great job of handling usability with care.

One of the most valuable parts of this book was it’s section related to usability testing. Steve removes the myth that you need thousands of dollars to complete usability testing. He even gives you a transcript of a sample usability test session. He discusses different methods and approaches to getting the most out of your usability testing. His insight here made the book worth every penny (plus some!).

If you are looking for a book that is a quick read and filled with great information related to web trends and usability, then this book is for you.

CSS Mastery: Advanced Web Standards Solutions

Nate Klaiber — Wed, 23 Aug 2006 12:05:00 +0000

CSS Mastery is one of the best advanced CSS books I have read in a while. Andy Budd does an incredible job of articulating the different aspects of CSS. From basic positioning to advanced layout and ‘tricks’.

The book’s style is a very easy read, packed full of great code snippets and screenshots. Andy goes through each aspect and gives you several options to achieve different tasks. So, while some may prefer method A, he also covers methods B, and C. This gives a designer a great arsenal of tools to get the job done. While showing the different methods, he also goes into detail about the positive or negative effects of using one method over another (such as image replacement).

While the book is an easy read, it seems targeted to the more advanced CSS developer. Each chapter seems to build on the previous, giving you a strong foundation to work with. By the end of the book, you are ready and itching to dive in and create something elaborate. In fact, the last 2 chapters are case studies by Cameron Moll and Simon Collison — and they only fuel the fire to get started right away. Their case studies present fictional businesses and websites, demonstrating many of the techniques covered throughout the book. This gives you a hands-on visual to play with and tweak, and help you get a better understanding of different nuances of CSS.

If you work with CSS everyday then this book is a must have. I find myself using it for reference as I learn new techniques and practices. It’s always an arm reach away when I am working with CSS.

Bulletproof Web Design

Nate Klaiber — Tue, 25 Jul 2006 13:59:00 +0000

Bulletproof Web Design does an incredible job of teaching, step-by-step, how to make your website ‘Bulletproof’. The author introduced the book by defining what it means to have a bulletproof website. He used the example of a police officer wearing a bulletproof vest. No, it is not 100% protection against a bullet — but it decreases the chances and is extra protection. When applied to a website, this means that your website can handle the ‘bullets’ being thrown at it. These are things like text resizing, use of assistive devices, no CSS, no images, and a few other examples.

The thing I liked most about this book is that it wasn’t preaching web standards — It was simply walking you through each chapter — with each chapter building on the last — and showing you techniques that work. The book itself does an incredible job of keeping your attention through the use of images, highlighting, and full code listing. For those who can’t quite grasp CSS (especially positioning and the like), this book is extremely helpful through its thorough explanations and visuals. Screenshots are provided each step of the way to let you see your progress.

Each chapter introduces you to new ways of handling things like text display, link display, navigation, list elements, layouts, floating, positioning, and a few others. Each chapter first take an example of a website (or aspect of a website) that is not bulletproof, then re-constructs that example with semantic XHTML and CSS to show you the results. The last chapter of the book brings it all together and shows you how it could be used in a production environment, with each piece of the puzzle being put together. The author doesn’t dwell on the array of hacks and filters — but simply lists the ones that he uses and how they get the job done (and why they are needed).

Using proper XHTML and CSS is sometimes misunderstood. This is where many will start with a bad case of classitis and divitis and start going crazy adding extra markup. The author does a great job of creating very lean, structured, semantic XHTML. This is the XHTML that is friendly to browsers and other devices alike, as well as rich in meaning. Using proper elements to get the job done is vitally important to the meaning of the website itself. He focuses on this aspect, and with each chapter discusses the importance of the structure and not adding unnecessary presentational markup to your pages. It is this separation of presentation and content that ultimately makes using proper CSS a wise choice.

Quite frankly, this is one of the best CSS books I have read — and I would recommend it to both the beginner and advanced CSS developer. This review doesn’t even do the book justice — mainly because you need to buy it and read it to really enjoy the context as a whole. There are many things I could explain in more detail, and there are many different things that I learned through reading this book (some of which were things that were needed immediately). This is a no-fluff CSS book that brings everything together nicely, and a must have for any web developers bookshelf!

Essential PHP Security

Nate Klaiber — Mon, 10 Apr 2006 10:32:00 +0000

Essential PHP Security by Chris Shiflett was a very concise read on PHP Security. I had read several articles from http://www.phpsec.org and really enjoyed the content. The articles were written in an easy to understand format with practical solutions.

I picked up (for $22 at amazon.com) Essential PHP Security by Chris Shiflett. I received it last friday at 5:00PM, went to a wedding rehearsal, came back and read the book in its entirety by 10:00PM (It is around 100+ pages — a very simple read). In all of the chapters Chris does a great job of presenting to you the problem and security risk at hand, how it is used (with examples), and how you can protect your applications from the same pitfalls. Many of them I have heard before, but it is always nice to have them compiled in one book as a great resource. His use of analogies and real world examples make this book a must read for a PHP beginner or professional. If I had a star rating on my blog, I would give this book a 5/5 for covering exactly what it said it would and doing so in a very clear manner.

Nate Klaiber Book Reviews

The Elements of Content Strategy

The principles

The craft

Summary

Handcrafted CSS: More Bulletproof Web Design

Introduction

Round and round we go

RGB eh?

But it doesn’t look the same!

Float on

The Grid

The devil is in the details

Summary

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?