To pass the test, a browser must use its default settings, the animation has to be smooth, the score has to end on 100/100, and the final page has to look exactly, pixel for pixel, like this reference rendering.

Grab a copy, and see if it is smooth for you. It certainly isn’t for me. It pauses briefly between 18 and 26. This might be splitting hairs- whatever. However, I have to say that I’m incredibly impressed with the browser overall. It’s incredibly fast rendering pages, it finally comes with an auto-update feature including daily snapshots, rewritten regular expression engine adding more speed, enhanced mail features, better transparency support for widgets on Linux/Unix, and a number of other features. Of course, Opera is among the standards-compliant web browsers.

It might be proprietary software, but in my opinion, it’s ahead of Mozilla Firefox in terms of speed and features. What impresses me the most, however, is the size of the binary. It’s considerably smaller than Firefox, yet it boasts better stability, better features and faster rendering. I haven’t looked at the code base for either of them, but I would really like to see some of this code goodness make it into Firefox. Maybe Firefox should do a code cleanup for a major release?

• If no: then Internet Explorer is not the browser to be designing sites for, but, instead, developing for standards compliance browsers like Firefox, Konqueror and Safari.
• If yes: then why haven’t they improved the browser to adhere to standards compliance to ease the pain of development?

Please enlighten me.

This site is best viewed with Internet Explorer at 1024 x 768 resolution.

Yeah. Thought you’d never have to see that again, did you? Sorry. I’ll be quick.

There’s a new intolerance growing on the web, and it’s the lack of web standards from developers. When browsing the web, users are getting more and more impatient about pages that don’t render correctly. Even worse, when they’re told to use a certain browser or screen resolution. My own wife, who hates using the computer, except when she needs to, hates visiting sites that don’t adhere to standards. “Why does this site look so bad?” or “Why can’t I see this page?” are common questions that she’ll ask me. Luckily, I don’t have to hear it all that often. “Because dear, that web developer is a moron.”

Fortunately, the W3C and WaSP are making great strides in this area. More and more, developers are adhering to standards. But there is more to developing great pages that just adhere to standards, there are also pages that adhere to cross-browser and cross-platform compatibility. I should be able to visit a site with any browser (adhering to standards too) on any platform with any resolution. The site should also deprecate nicely if I decide not to use JavaScript.

With all this said, me being a very big advocate of such standards, you can imagine my shock when I visited this site: UpdateSport (scroll to the bottom). The funny thing is, I was looking for news on Firefox using Google News when I stumbled on that site. I couldn’t believe my eyes. You have got to be kidding, right?

Sure, they’re advocating the good word of Firefox, so brownie points there, but come on! Learn how to develop a site, so if I have a resolution of 800×600 (which 17% of web browsers still do, according to the W3C), then I can view your site nicely, without cursing under my breath. Learn how to develop that caters to all users, not just a select ‘elite’.

At any rate, I calmed down, and sent the web master a kind email encouraging him to use standards when developing a site. I hope that he realizes what he can do to fix it, so users with smaller screen resolutions, can visit the site, and enjoy the content that’s there. If he doesn’t, at least he is aware of one user who isn’t excited about his lazy attitude towards web dev.

Disclaimer: This isn’t a bullet-proof way to fool bots, but if you plan on putting your email address on pages, it does work very well.

Just about every character in the English language has a ASCII equivalent associated with it. This we know. So, why not use the ASCII code on your website instead of publishing the actual email address? Here’s how it works: every number, character and letter has an ASCII, decimal and hex-based equivalent. Here is a table of just the HTML-ASCII codes for lowercase letters, numbers and a couple of punctuation characters:

Cool. So, using my name, aaron, this is how it would look in HTML ASCII:

aaron

Pretty cool, eh? The best part is the HTML rendering. Your browser will render the ASCII codes as plain text, just as if the ASCII didn’t exist. So to the average user, no one knows the different. However, to the bots scanning the source, they won’t know what to do with the codes, and skip right past it. Again, though, it isn’t difficult to code a bot to render ASCII, but suffice it to say, most bots aren’t that advanced. And, if you want to obfuscate it even further, just put opening and closing HTML formatting tags in the ASCII.

Again, this isn’t bullet-proof, but it works well. Probably the most sure fire way to avoid bots altogether is putting your email in an image, but even then, I don’t think that is 100% either.

You may have noticed, then again, you may have not noticed, that I put the ever-so-popular “Too Cool For IE” image at the bottom-right corner of the browser window. That is, if you are using Firefox, Opera, or any other standards compliant browser. If using IE, you will find that the transparent .png file is not transparent at all, and it sits up the in the upper right of the page. This is because IE is not very fond of the CSS attribute “position: fixed;”, so it puts it where it pleases, and it doesn’t know how to handle transparent .png images.

There seems to have been a lot of buzz surrounding the “Too Cool For IE” images that are popping up all over the place. Generally, the acceptance has not been positive, but rather, quite negative. And yet we are seeing them everywhere, more and more. One particular post that I stumbled upon that just made me laugh was at Pink Thinker. Let me give you the highlights:

• She (or he- guys can like pink) is fairly open-minded.
• Only Firefox users have embraced the paradigm.
• I am be too lazy when I design pages that don’t support IE.
• Sites are made to function in browsers and not the other way around.
• You don’t adjust your browser settings for your liking.
• Don’t tell your visitor that their browser is wrong, because you’re not Microsoft.
• No “normal visitor” will ever study different browsers.
• “Normal visitors” don’t have the time to use alternative browsers.
• “Normal visitors” who see the orange “Too Cool For IE” will immediately leave the site, regardless of the information presented.
• This trend started for the wrong reason.
• “Normal visitors” don’t care if IE doesn’t position a page correctly.
• “Normal visitors” also don’t know you (that’s a relief) or your browser of chioce.
• “Normal visitors” are all male.

There it is in a nutshell. Now, I have a lot of concerns in that post. So, where to begin? How about the start? Sounds like a good place.

First, the whole you’re an open-minded sort of person. I have a hard time with that, regardless of how petty it seems. The people who claim they are open-minded never are. It’s just like the people who say they are humble, yet somehow, always end up to be the most cocky. Your post was not open-minded, and it didn’t lead me to believe so.

Second, I love your claim that only Firefox users have embraced this trend. Where did you get that data? Browsing the site shows more than just Firefox, but Opera, Omniweb, Camino and Safari. So, certainly, you can’t get that claim from the people who started it. How about the people embracing it? Well, I don’t know these people or the browser they use (I’ll get to that in a minute), but I imagine that these people use other browsers than just Firefox.

Thirdly, your claim about laziness, coding pages for the browser and adjusting your browser settings. Where are you going with this? You probably didn’t do very good in history class, did you? If you did, you would remember the browser wars of the ’80s, and how each browser manufacturer was designing new HTML tags that worked only in their browser. You obviously don’t remember what a mess that was. Pages are not meant to be designed “for the browser” any longer. This is the new paradigm shift that browser makers need to embrace: standards. If a page is developed on standards, then “cross browser compatibility” will no longer be an issue. And designing pages after standards is far more difficult than designing pages that work in all browsers. Being a web dev, I know. It is way too easy to just throw up some HTML code, and make it render in every browser flawlessly. Lastly, the user should not be changing the browser settings, but the browser software company should. Ultimately, the user is the one affected, and will decided which browser to use. If the browser doesn’t render the page properly, then they will use a new browser. Which brings me to my next point.

If I’m not Microsoft, I can’t tell the visitor that the browser they are using is wrong? Why? Since when did I need their permission? Although this may come across as a little defiant, I am wondering what your point is here. Last I checked, within legal ramifications, this is my site, and I can tell whomever I please whether or not they are using the right browser. Heck, using just a little code, I could prevent you entirely from accessing my site until you are using a browser that I think you should use. Sounds a little like a dictatorship? Ever been to Windows Update with a non-IE browser? That’s what I thought.

Next, you get into this whole “normal visitor” stuff. Define “normal visitor”. Really. I’m interested in your definition. My parents are the most computer illiterate people on the face of the earth, and they use Firefox. Heck, the whole family does, including my 9 year-old brother, and I had hardly anything to do with it. So, because my family uses an alternative browser, they are not defined as a “normal visitor”? Just curious. “Normal visitors” do take the time to study not only different browsers, but much much more. “Normal visitors” are concerned about their security, just as much as your are, and when they learn IE isn’t secure, they begin to look elsewhere. Also, your usage of the term “normal visitors” leaves me to believe that they aren’t educated, and don’t have a clue. I would be more concerned about offending people in your post than trying to twart off a trend.

You mention that this trend started for the wrong reason, yet you never give what the reason is, what it should be, or how it can be resolved- if in fact it is the wrong reason. You just continue to make assumptions about browsers and “normal visitors” and designing pages, etc. Really. Please define what you mean when you say this trend started for the wrong reason.

Lastly, I like how halfway through the page, all of your “normal visitors” become male. Now, I’m getting a little ridiculous here, and I can’t stand political correctness, but it is too funny to pass up. I was just curious why you chose this sex. Again, going back to your implying that “normal visitors” aren’t educated, leads me to believe that you are saying males aren’t educated which further leads me to believe that you are a well educated male-hating female. Married? Boy-friend? College degree? Just curious. And of course people don’t know who you are or what your browser of choice is. Why would they care? How would they know? That comment in your post leads me to believe that you aren’t as educated as you try putting yourself up to be. Do you honestly believe that people know the webmaster (or the site owner) when visiting the page? Again, just being ridiculous, but I had to.

To wrap up (I know this has been a lengthy post), the reason the “Too Cool For IE” images are showing up, is because we are sending a message to everyone, and hopefully Microsoft that we want to begin seeing standards compliance in IE. See, you’re missing the whole point of the trend. It isn’t to shove alternative browsers down peoples throats and force them to use it when visiting a site (like Microsoft does), but make people aware that they are missing out on a greater experience. Sure, IE controls the market right now, but it is slipping. You know that. I know that. Firefox is continually burning a hole in the dominance the IE has played for so many years. And when IE finally catches up to the features that so many of these browsers currently include, Firefox (and other browsers) will have passed that spot so many years prior. The trend isn’t about arrogance or anarchy, but awareness. The trend is about fashion. The trend is about standards. The trend is about letting people know how they can improve their experience if they would just use another browser.

Prince 5.1 was released yesterday making it the fourth after Safari, Konqueror and iCab to pass Acid2 beating out Firefox, Internet Explorer and Opera.

See the news here.

Opera 9 rendering Acid2 almost flawlessly

Will this be the first browser for Linux to pass the test? I have heard that builds of Konqueror can pass it, but I have to find and download a copy of the browser. Safari was the first to pass the test many months ago, but I have heard that it hasn’t been included in the Mac OS X releases yet. What are they waiting for? I would also like to know what the Firefox dev team is waiting for. The Acid2 test in Firefox looks horrible, and with such a promising future, what’s up?

In any case, congratulations Opera! No doubt they will have the CSS level 2 spec completed in its entirety by the time they publicly release version 9. I have been a user of Opera ever since they relinquished the ads, and I look forward to using version 9. Opera has set the bar high on every release, and it’s really quite astonishing that they don’t have more of the browser market share.

       Decimal   Octal   Hex    Binary     Value
       -------   -----   ---    ------     -----
         000      000    000   00000000      NUL    (Null char.)
         001      001    001   00000001      SOH    (Start of Header)
         002      002    002   00000010      STX    (Start of Text)
         003      003    003   00000011      ETX    (End of Text)
         004      004    004   00000100      EOT    (End of Transmission)
         005      005    005   00000101      ENQ    (Enquiry)
         006      006    006   00000110      ACK    (Acknowledgment)
         007      007    007   00000111      BEL    (Bell)
         008      010    008   00001000       BS    (Backspace)
         009      011    009   00001001       HT    (Horizontal Tab)
         010      012    00A   00001010       LF    (Line Feed)
         011      013    00B   00001011       VT    (Vertical Tab)
         012      014    00C   00001100       FF    (Form Feed)
         013      015    00D   00001101       CR    (Carriage Return)
         014      016    00E   00001110       SO    (Shift Out)
         015      017    00F   00001111       SI    (Shift In)
         016      020    010   00010000      DLE    (Data Link Escape)
         017      021    011   00010001      DC1 (XON) (Device Control 1)
         018      022    012   00010010      DC2       (Device Control 2)
         019      023    013   00010011      DC3 (XOFF)(Device Control 3)
         020      024    014   00010100      DC4       (Device Control 4)
         021      025    015   00010101      NAK    (Negative Acknowledgement)
         022      026    016   00010110      SYN    (Synchronous Idle)
         023      027    017   00010111      ETB    (End of Trans. Block)
         024      030    018   00011000      CAN    (Cancel)
         025      031    019   00011001       EM    (End of Medium)
         026      032    01A   00011010      SUB    (Substitute)
         027      033    01B   00011011      ESC    (Escape)
         028      034    01C   00011100       FS    (File Separator)
         029      035    01D   00011101       GS    (Group Separator)
         030      036    01E   00011110       RS    (Request to Send)(Record Separator)
         031      037    01F   00011111       US    (Unit Separator)
         032      040    020   00100000       SP    (Space)
         033      041    021   00100001        !    (exclamation mark)
         034      042    022   00100010        "    (double quote)
         035      043    023   00100011        #    (number sign)
         036      044    024   00100100        $    (dollar sign)
         037      045    025   00100101        %    (percent)
         038      046    026   00100110        &    (ampersand)
         039      047    027   00100111        '    (single quote)
         040      050    028   00101000        (    (left/opening parenthesis)
         041      051    029   00101001        )    (right/closing parenthesis)
         042      052    02A   00101010        *    (asterisk)
         043      053    02B   00101011        +    (plus)
         044      054    02C   00101100        ,    (comma)
         045      055    02D   00101101        -    (minus or dash)
         046      056    02E   00101110        .    (dot)
         047      057    02F   00101111        /    (forward slash)
         048      060    030   00110000        0
         049      061    031   00110001        1
         050      062    032   00110010        2
         051      063    033   00110011        3
         052      064    034   00110100        4
         053      065    035   00110101        5
         054      066    036   00110110        6
         055      067    037   00110111        7
         056      070    038   00111000        8
         057      071    039   00111001        9
         058      072    03A   00111010        :    (colon)
         059      073    03B   00111011        ;    (semi-colon)
         060      074    03C   00111100        <    (less than)
         061      075    03D   00111101        =    (equal sign)
         062      076    03E   00111110        >    (greater than)
         063      077    03F   00111111        ?    (question mark)
         064      100    040   01000000        @    (AT symbol)
         065      101    041   01000001        A
         066      102    042   01000010        B
         067      103    043   01000011        C
         068      104    044   01000100        D
         069      105    045   01000101        E
         070      106    046   01000110        F
         071      107    047   01000111        G
         072      110    048   01001000        H
         073      111    049   01001001        I
         074      112    04A   01001010        J
         075      113    04B   01001011        K
         076      114    04C   01001100        L
         077      115    04D   01001101        M
         078      116    04E   01001110        N
         079      117    04F   01001111        O
         080      120    050   01010000        P
         081      121    051   01010001        Q
         082      122    052   01010010        R
         083      123    053   01010011        S
         084      124    054   01010100        T
         085      125    055   01010101        U
         086      126    056   01010110        V
         087      127    057   01010111        W
         088      130    058   01011000        X
         089      131    059   01011001        Y
         090      132    05A   01011010        Z
         091      133    05B   01011011        [    (left/opening bracket)
         092      134    05C   01011100        \    (back slash)
         093      135    05D   01011101        ]    (right/closing bracket)
         094      136    05E   01011110        ^    (caret/cirumflex)
         095      137    05F   01011111        _    (underscore)
         096      140    060   01100000        `
         097      141    061   01100001        a
         098      142    062   01100010        b
         099      143    063   01100011        c
         100      144    064   01100100        d
         101      145    065   01100101        e
         102      146    066   01100110        f
         103      147    067   01100111        g
         104      150    068   01101000        h
         105      151    069   01101001        i
         106      152    06A   01101010        j
         107      153    06B   01101011        k
         108      154    06C   01101100        l
         109      155    06D   01101101        m
         110      156    06E   01101110        n
         111      157    06F   01101111        o
         112      160    070   01110000        p
         113      161    071   01110001        q
         114      162    072   01110010        r
         115      163    073   01110011        s
         116      164    074   01110100        t
         117      165    075   01110101        u
         118      166    076   01110110        v
         119      167    077   01110111        w
         120      170    078   01111000        x
         121      171    079   01111001        y
         122      172    07A   01111010        z
         123      173    07B   01111011        {    (left/opening brace)
         124      174    07C   01111100        |    (vertical bar)
         125      175    07D   01111101        }    (right/closing brace)
         126      176    07E   01111110        ~    (tilde)
         127      177    07F   01111111      DEL    (delete)

Taking the decimal value and adding a “&” and a “#” before the number, and a “;” after it, results in the HTML code for that ASCII value. For example, my email address would be as follows (broken-up over a couple of lines to fit better on pages with smaller screen resolutions):

Now tell me that web bots are going to make sense of that. Becuase bots scan the source code of the HTML rather than the parsed code, you can rest assured that your email address will remain secure from spam and the such.

Becuase of this new found idea I had over the weekend (I doubt it is that new- I am sure someone else thought of this as well), I decided that I will be coding a simple HTML page with forms that will parse any ASCII character into the HTML obfuscated code. I only see this useful for hiding email addresses on web pages, and making web pages W3C compliant. I decided to use Perl as my language of choice. This page should be quick to code, including the Perl script. When the code is complete, I will post the results online, for all to use and share.

• Enhanced web page rendering
• Major security fixes
• Improved automated update system
• A few bug fixes

Way to go on the security and bug fixes, however, if it isn’t passing the Acid2 test, I am not too terribly excited about the web page rendering, at least when it concerns CSS. There is no reason why Firefox cannot fully support CSS Level 2 properly. However, with that said, Safari and Konqueror are the only browsers that passes the Acid2 test. I guess making rendering engines for browsers standards compliant is a low priority.