The Bad Browser: What to Do When Browsers Fail to Play Nice With Your CSS

A Web browser is the essential Internet access tool of the early 21st century, indispensable to business, education, and personal communication. Browsers create a common platform upon which Web-based applications can be built. So what's the problem? In short: Web browsers have been inconsistent in their support for CSS. In this sample chapter, you'll learn the consequence of a browser failure, how current browsers implement CSS, what a layout engine is and how it affects your Web pages, and more.

How screen readers work with browsers to speak web pages to blind users

CSS rules are always interpreted by web browsers, just as the HTML pages those rules style are interpreted. The HTML and CSS standards give specifics on how browsers should display those rules—but they're not always followed. To design pages with CSS, you not only need to know the standards, as presented in the CSS specification, but also understand how browsers' quirks and flaws will affect your web design results.

The Browser Problem

A web browser is the essential Internet access tool of the early twenty-first century. Browsers are now indispensable to business, education, and personal communication. They create a common platform upon which web-based applications can be built, with an HTML framework driving e-commerce, business-to-business transactions, web-based learning, and online communities. Hundreds of thousands of pages of new information are added to the Web each day. Cascading Style Sheets play a crucial role in this communications medium by not only providing a pleasant visual layer on the surface of these web applications, but also by potentially reshaping the entire user experience.

So what's the problem? In short: web browsers have been inconsistent in their support for CSS.

There are many reasons for this. Some early browsers, such as Netscape 3, were created before the CSS specification was published. Some browsers jumped the gun. Microsoft is notorious for rushing ahead and using draft specifications of standards in their browsers, and then the specifications get changed. And sadly, some browsers are just plain bad. They may seem to function normally, but when it comes to consistent and standardized support for CSS, they fall very short.

The good news is that the problem is being solved. Slowly but surely, each new major browser release is better than the last, and you can get pretty decent CSS implementations from Firefox, Opera, Safari, and other browsers.

How Browsers Deal with CSS

When a browser encounters anything—from CSS rules to HTML, JavaScript to Flash multimedia—it has several choices as to what it can do. If the browser has been programmed to understand the thing it has encountered, it attempts to display it according to the specification. If it has no idea what it has come across, it can ignore it. Both these options can be considered "doing the right thing." Or the browser can do the wrong thing. It can get confused; it can display in some nonstandard way; it can even crash, although that's rare. Doing any of these wrong things, of course, is the least desirable and is at the root of our problem.

Cascading Style Sheets were designed from the start to degrade gracefully. This means that if your CSS rules aren't recognized for some reason, your page is still usable and the content accessible. Because presentation is separated from content, the content should be able to stand on its own, albeit not as beautifully, after the presentation is removed. At least, that's the theory.

In practice it's not nearly as easy as that. To be an effective CSS author, you need to know not only what works in any given browser—or in most or all of them—but also what happens when it doesn't work. Is it as simple as your style not being applied correctly and a bit of decoration being lost, or is it as serious as your entire layout being disrupted and content being lost?

Compliance and Lack Thereof

You need to understand what happens in each case of browser failure to know how to approach each browser. When a browser fails to correctly understand and apply a CSS rule, the browser may just ignore the rule and your design will be fine. Or, because of a browser quirk or bug, it may ignore the rule and your page could become unreadable. As a designer, you need to weigh each style rule carefully and know what effects will result if browsers don't understand and apply it.

In some cases, you may want to use CSS properties that aren't well supported; you may figure that you don't mind some users missing out on a special styling if it improves the site for those users with more advanced browsers. In other cases, you may decide you can't take that chance, and you'll have to make a choice whether to support the broken browsers with workarounds or ignore that audience.

For example, consider a CSS rule that makes the first letter of each section stand out large in a stylized font. This may just be simple decoration, and if the font is normal sized in some browsers, so be it; it may not affect at all the way your page functions.

In other situations, you may be forced to either abandon certain types of style rules that are perfectly valid and useful simply because some major browsers don't support them. An alternative to this approach is to make special modifications, called browser hacks, which allow your style sheets to work despite browser problems. The most common of these is called a filter; a filter prevents certain browsers from reading specific CSS rules that might cause them problems. You'll learn more about browser hacks and filters in Hour 24, "Troubleshooting and Browser Hacks."

To understand how browsers deal with CSS, I've divided them into four categories: ancient browsers, which pre-date the CSS specification and thus ignore it completely; broken browsers, which try to provide CSS functionality but fail horribly in some manner; quirky browsers, which have generally decent CSS support but a number of "gotchas" where they don't quite measure up; and compliant browsers, which do a good job of presenting CSS as it's meant to be. Each category of browsers treats style sheets differently, and it's important to understand what those differences are and how you can design for those browsers.

Ancient Browsers

Ancient browsers are those that existed before Cascading Style Sheets were even a glimmer in the W3C's collective eye. Netscape 3 is the classic example of an older browser, and it does exactly what it's supposed to do: It ignores CSS entirely. If you use Netscape 3 to visit a web page styled with CSS, the browser doesn't notice a single rule. The style sheet doesn't even load.

This is actually ideal behavior for older browsers; with CSS designed for backwards compatibility, most CSS-based websites should still work, although they may be somewhat boring in appearance. Because Netscape 3 is ignoring all Cascading Style Sheets rules, you know exactly what it will do with them; there's no guesswork necessary on the part of the author. You don't have to do anything special to support these types of browsers, except for testing your designs to see whether they still function without CSS.

Some ancient browsers are:

Lynx

Mosaic (no longer in widespread use)

Netscape 3 (no longer in widespread use)

Broken Browsers

The worst kind of browser is one that is simply broken when it comes to CSS, despite whatever claims the provider makes to standards compliance. A broken browser is one that, when given perfectly legitimate Cascading Style Sheets rules, doesn't present a web surfer with anything useful, but instead displays a mishmash of styles where information gets lost. The difference between an older browser and a broken browser is that older browsers don't try to display CSS, and broken browsers try and fail horribly.

Internet Explorer 3 was the first browser to implement any CSS, but it did an overall bad job at it, based in part on the fact that they coded to a specification that was still being written at the time. When the final version of CSS Level One came out, it was quite different from Internet Explorer 3's attempt to implement CSS support.

Fortunately, Internet Explorer 3 has almost passed into memory, replaced by newer versions of Internet Explorer that are closer to the CSS specification, meaning that the buggy CSS implementation in Internet Explorer 3 really isn't a factor in current CSS usage.

To account for the broken browsers out there, it's necessary to understand how they're broken and what happens when you give each browser some CSS rules that it doesn't understand. In some cases, the broken browser just ignores your CSS, as is the case with a limited or older browser; in others, it may do something horribly wrong.

There are two approaches to dealing with broken browsers. First, you can code around the problems by using a filter or other browser hack to prevent the browser from mangling your page. And second, for some browsers that are just so old that few people use them any more, you could just no longer support those browsers on your website.

The list of broken browsers includes:

Internet Explorer 3 (no longer in widespread use)

Netscape 4 (no longer in widespread use)

Various minor releases of browsers that had serious bugs, and thus are no longer available

Quirky Browsers

Between the downright broken browsers and the compliant ones is a category of web browsers that have the best intentions, but just don't get it quite right. These browsers are generally compliant but have serious problems that come out when you start doing complex styles—for example, when using CSS to lay out a web page. We'll call these quirky browsers.

Unlike broken browsers, these are still in use, especially Internet Explorer versions 5 through 6. This means that as a web designer you can't just ignore them, nor can you simply lay the blame on the programmers who created the browser. It's your website (or your employer's, or your client's), and you need to take responsibility for how it appears in common browsers.

The way to deal with these browsers is to understand their quirks and bugs and work around them. One strategy is to use only "safe" CSS code in your designs, even if that limits the effects you can produce in more fully compliant browsers. Another method for dealing with a quirky browser is to use filters and other browser hacks to tailor the style rules given to that browser; techniques of this sort are described in Hour 24.

Some browsers with quirks include:

Internet Explorer 6, 5.5, and 5

Internet Explorer for Mac (no longer in widespread use)

Opera 5 and 6 (no longer in widespread use)

Netscape 6 (no longer in widespread use)

Compliant Browsers

A compliant browser is one that follows the CSS and HTML specifications to the letter. Well, that's not really true—as of early 2006, no browser can legitimately claim 100% standards compliance. However, there are browsers that get very close, to the extent that they can be treated as basically compliant. This is the category we'll call compliant browsers, although if you want to be pedantic, you can think of this as the "almost compliant" group instead.

When designing for compliant browsers, you don't have to do anything particularly special other than follow the CSS 2.1 specification. The selectors and properties you'll learn in later chapters of this book will work as described; text styling and even complex layouts don't present any major obstacles. You won't need to use filters or other browser hacks to deal with compliant browsers.

However, you need to keep in mind that not all browsers out there are compliant. The quirky browsers, in particular, are still around and may require special attention, even if the compliant browsers are going to be well behaved.

The following are generally compliant browsers:

Firefox 1.5

iCab

Konqueror

Mozilla 1.7

Opera 8.5

Safari 1.3 and 2

Web Standards and the Acid2 Test

As you learned in Hour 1, "Understanding CSS," the CSS language is defined by the Cascading Style Sheets Level 1 and Level 2 recommendations from the World Wide Web Consortium, and updated by CSS 2.1. These recommendations function as standards for the CSS language.

Standards are a good thing for developers; the more the browsers support the standards, the easier it is for us to create expressive and attractive designs in CSS and know they'll work reliably. Increased support from standards, the browser makers, the web developer community, and the web software manufacturers will only make our jobs easier.

One group of web designers decided to take their support for standards public and founded the Web Standards Project to encourage browser makers to adhere closely to the CSS recommendations and other web standards. In addition to their advocacy work, the Web Standards Project site contains useful FAQs and links on standards support. Their URL is http://www.webstandards.org/.

In 2005, the Web Standards Project developed the Acid2 test. Acid2 is a web page created with some rather complex CSS rules that hit key parts of the CSS and HTML specifications. If a browser successfully interprets and displays the CSS rules according to the standards, a happy face is displayed. Figure 3.1 is the reference picture showing how a compliant browser should display Acid2.

As of early 2006, four browsers had passed the Acid2 test; in order: Safari, iCab, Konqueror, and Opera. Acid2 isn't the ultimate test of CSS support—it's possible to pass Acid2 and still have serious CSS bugs or quirks—but it is an important benchmark for measuring progress toward standards compliance.

Browser Compatibility Charts

A browser compatibility chart is an invaluable resource for anyone doing serious CSS work. What is it? A compatibility chart lists every CSS property in a matrix, cross-referenced with a number of different browsers (including various version numbers and platforms). For example, if you want to know whether version 5.5 of the Internet Explorer browser supports the text-transform property, you can consult a compatibility chart. For each property you look up, you'll see whether or not it's supported by the browser, and if there are any special notes or known bugs in the implementation.

There are several sources of CSS browser compatibility charts; one that's particularly nice to use is David Hammond's chart at http://www.webdevout.net/. Bookmark that site and refer to it when testing your CSS-based designs. Brian Wilson's Index DOT css site at http://www.blooberry.com/indexdot/css/ hasn't been updated for several years, but it's still useful if you need to dig back through history for information on older browsers.