By
Dewey Williams
Quirks, Hacks and Bad Programming - How Can All This Web
Stuff Work?
HTML, CSS, browsers by the dozens, servers, scripts,
programs; where does it end? It is a wonder anything can be seen
on the web with all the disparate parts interconnecting and
depending on each other to talk properly with one another. So,
how is all this magic accomplished?
In the early days of HTML and Mosaic/Navigator/Internet
Explorer, it was decided by the programmers and designers that
future versions of HTML and browsers should be backward
compatible with what came before it. That is, if a new browser
came out, it should not only show pages written in the latest
version of HTML, but should also understand and show correctly,
pages written in ALL the older versions of HTML.
This placed a great burden on web browser programmers in that
they could not correct mistakes found in the older browsers for
fear of not being compatible with older HTML rules. The
programmers also wanted to add features to their browsers so
they could beat the other guys to the punch. In this way we
ended up with non-standard HTML commands that only worked with
Internet Explorer or Netscape Navigator. Web page designers
scrambled trying to make use of the new features and also
support all the different types of browsers. In some cases they
had to write many different web pages, each for a different
browser, or use hacks that exploited the shortcomings of poorly
written browsers, just so things would look right on a Mac, a PC
using Internet Explorer and a PC using Netscape. What a crazy
way to run things!
Unfortunately, the web standards committee (W3C) was
overwhelmed with ideas from the browser programmers, the web
designers and web users, all demanding that this feature be put
in the next version of HTML, that this browser did things better
or more correct than that other browser. They were so many
things to consider that it took months for any standards to be
authorized and for new HTML standards to be published. The
standard committee was so slow that many of the browser
programmers went ahead and did things their own way regardless
of the standards. For this reason a web page viewed in Internet
Explorer may or may not look the same as one viewed in Netscape.
For a look at the problems that non-standard browsers cause,
take a look at these compatibility charts. Listed in the charts
are different versions of each browser and the HTML objects they
support and how well the standards are adhered to. http://hotwired.lycos.com/webmonkey/reference/brows
er_chart/ http://www.itts.ttu.edu/documentation/html/html07.ht
ml
A quick look will show that the early browsers supported the
basic features but were slow to accommodate new features added
to the HTML specs. The W3C was also slow to decide if and how
they were going to add requested features to the HTML
specifications. All in all, the web looked different depending
on the browser you used. Web page designers used all types of
tricks to make things look the same. Then, along came Cascading
Style Sheets (CSS).
As with early versions of HTML, CSS got off to a rocky start.
First of all, the older browsers didn't understand CSS at all.
The first CSS-capable browser often got things completely wrong,
or, at least, interpreted some of the specs differently.
When you look at the charts, it appears that the latest
browsers (IE5/6, Mozilla 1+, Opera) support the HTML
specification. However, each of these browsers has their quirks
in which they don't quite render pages the same. Even today, web
designers are forced to incorporate tricks and hacks into their
web pages to fend off non-standard HTML and CSS rendering by
browsers.
So how does all this work? A web page is a file containing
text which could be HTML code, CSS code, or links to a CSS
template and possibly JavaScript or PHP code. For this example
we will stick with a simple page of text, CSS and HTML code.
When you click a link or type/choose a web page in your
browser, it makes a request for that page to the web server. The
server finds the page in its directory, checks to make certain
you are authorized to view the page, and sends the page to you.
Your browser receives this text and looks at each bit and byte,
determining what it is (text, html, css, etc) and parsing it
properly according to the rules programmed into it.
Inside the browser there is are Document Type Definitions
that tells the browser how to interpret the different tags and
text in the data it receives from the server. The first part of
a properly written web page tells the browser what DTD to use.
There are several DTD's available, for different versions of
HTML, and for the latest acronym, XHTML.
The DTD tells the browser what tags (code) are valid and how
to use those codes to make the web page. The problem web
designers STILL run into is that not all web browsers adhere to
the HTML standards. One browser renders pages differently than
another because the browsers interpret and execute the DTD
differently.
In the Web Design SIG, we will learn much more about what
lies behind the web; how to write HTML and CSS, what the
differences in browsers are, how to get around these differences
and how to create web pages that look great in all/most
browsers. Hope to see you there.
The Web Design SIG meets at CompUSA-South Blvd on Wednesday
night during SIG week. See our web page for more information:
http://www.pc3.org
