additions… #38
…editorial…
same ol' bugs…
Some find it strange that web designers – amateurs and professionals alike – keep on having problems with the same old browser bugs that those of us who have been in the trade for a while figured out how to work around and/or fix years ago. Personally I would find it pretty strange if they didn't.
Anyone who approach something for the first time, will obviously have to learn in order to master it. If that “something” happens to be web design vs. browsers, one inevitably will run into each and every browser bug and bug combitation for the first time at some point during the learning process – and the discoveries and problems won't stop there.
Once problems arise the unprepared designers may either recognize that they've run into bugs in a particular piece of software, or they may mistakingly understand the oddity to be the correct behavior and/or put the blame on and debugging-attempts onto the wrong piece of software.
Since most bugs and shortcomings are in the designer's own head, and not all find it easy to recognize that, most debugging-attempts targeted at software are misplaced. That someone is hacking the livin' daylight out of some software to get around designer bugs actually happens quite frequently – outnumbering real software-debugging with a large margin, and both amateurs and professionals at all levels are guilty of this counterproductive practice.
watch out for the experts
Every single individual who regard himself as qualified today, has run into the same problems and made the same mistakes somewhere along the road. So, no need for the “expert” to become dumbfounded or mystified by the fact that others are still on the road to enlightenment.
Once one has acquired the knowledge and skill-set necessary to master something, mastering it becomes easy. Up to that point mastering anything can be hard, and any true expert knows that.
The simple fact is that most who regard themselves as qualified in a field today, will be behind in a relatively short time if they don't constantly maintain and expand on their knowledge and skill-set. Thus the “expert” of today may end up being the under-qualified person tomorrow, if he or she skips on learning once the comfort-level is reached.
persistent bugs…
Most bugs will at least last as long as the software version they're in lasts, and some browser versions have lasted for a very, very, long time. Just look at Internet Explorer 6 … will be years before we can ignore that old bugger.
In many cases a bug will be left intact in new versions, mainly because so many web designers have come to rely on it without realizing that it is a bug. Numerous examples of “inherited” bugs around. Internet Explorer is again the best example on software that is full of “inherited” bugs, but it most certainly isn't the only one.
In some cases the bugs have been standardized as “features”, which are then copied by other browsers. As a result we can't get rid of them for decades to come, or even call them bugs, no matter how silly they are.
Browser developers also go to great length to reverse-engineer their competitors products, and implement equivalent bits and pieces, with bugs and all, in order to level out major differences in how they handle the same, usually buggy, designs. This may complicate things even more when we try to separate out bugs, but on average this reverse-engineering approach is both necessary and works quite well.
fooled by ones own tools
Since most web designers rely on design tools to some degree, they may neither have much of a clue about what's going on behind the scene, nor have acquired much knowledge about how to interpret, correct or modify the tool-outputs when something doesn't turn out right. Being fooled by ones own tools is actually quite common, in addition to the simple fact that “tools can't think.”
Design tools are software in one form or another, and all software has bugs. Thus, the more automated or semi-automated design tools one has come to rely on, the more complex the buggy relations become and the harder it is to nail down and fix the real bugs in the right pieces of software.
Many excellent design tools around, but one has to master them to near perfection in order to make them do a proper job. Bad tools and/or inadequate mastering-skills often create at least as many problems as they solve.
One also have to keep in mind that since browsers do make serious attempts on handling buggy
documents somewhat like the designer intended – if they can calculate what that intent
might be, one can not trust a single browser to distinguish flawless code from buggy one in a clear way.
This can make it very hard to find out where the real bug actually lies in many cases, which certainly
doesn't make it any easier for the less experienced to pinpoint and eliminate the right bug.
never-ending process…
For those of us who have an interest in helping the next generation of web designers and front-end coders in their climb up to a reasonable level, there will simply be no end to it. The same ol' bugs and case-dependent fixes will have to be pointed at again and again, as new people run into the same ol' problems.
Having a growing set of documentation of bugs and fixes may help some. However, since a high number of existing documentation is incomplete, outdated or plain wrong, and most bugs can only be interpreted and the subsequent fixes be implemented correctly by people who already master the skills to a degree, there will always be a need for case-targeted guidance by those who really want to help others.
I guess all we can, and should, be able to expect from people we lend a hand and our advices to, is that they learn something from the process. When one has repeated the same message to the same individual a number of times, one starts concidering them to be the biggest bug themselves. Subsequently one simply ignores them and let them deal with their own problem whichever way they like – regardless of the outcome.
That the most knowledgeable amongst us are “throwing out” and ignoring people who insist on doing it the wrong way and who keep on making the same mistakes over and over again – ad nauseam, is what can be expected. Everyone deserves a chance, but there is of course a limit to how many chances anybody deserves.
my bug-killing cat…
Some may find it strange that I often credit my cat for “killing” software bugs. However, it is simply a philosophical way of saying that humans have caused the software bugs, all of them, and that it can be good to approach things that don't work as intended, from more practical and logical angles than humans in general tend to do.
Cats look at everything from all angles – also the “impossible” ones, and being opportunistic creatures they approach, pick and choose as they like, without being bothered with methodology or other unimportant matters that may slow down the process.
Having the agility to righting themselves during falls, cats also excemplify one of the most important qualities when dealing with problem-solving in any field: the ability to solve problems quickly, even if by accident, and learn through and from the process.
The author of this document has been professional problem-solver for decades – in many fields. He knows perfecly well what a huge difference it can make if one manages to ignore and/or anonymize people when dealing with technical problems, and only focus on the task at hand.
Cats are pragmatic by nature, so Molly 'the cat' is the perfect stand-in when I'm dealing with purely practical matters – also on the web.
There will always be bugs…
sincerely 
Hageland 18.nov.2008
last rev: 20.nov.2008
additions…
