rc3.org

Strong opinions, weakly held

Tag: HTML

It isn’t too early to start using HTML5

A representative of the W3C says it’s too early to start using HTML5. Scott Gilbertson of WebMonkey argues to the contrary. Given the pace at which Internet Explorer users upgrade, if you are opposed to using HTML5 now, you’ll probably still be opposed to it a decade from now:

The fact is HTML5 is here and you can use it today, you just need to use shims, fallbacks and workarounds for older browsers. Yes, that’s unfortunate, but that situation isn’t going to change any time soon. If IE8 — which lacks support for most of HTML5’s features — has even half the longevity of IE6, we’ll still need fallbacks even when 2022 rolls around and HTML5 is, in the W3C’s opinion, finally ready.

In the meantime, developers are building awesome things with HTML5, CSS3, and JavaScript. Check out PaintbrushJS, a new library written by Dave Shea that enables you to apply filters to images using CSS and JavaScript. Not only can you change the way images appear on the page, but you can also allow users to save the filtered images.

Obviously we can’t just migrate to HTML5 wholesale yet (unless we’re creating Web sites optimized for iOS and Android), but the time to weigh whether using HTML5 and compensating for old browsers makes more sense than using older techniques that work in all browsers has arrived.

Defending view source

Dojo developer Alex Russell continues to look out for view source:

If HTML is just another bytecode container and rendering runtime, we’ll have lost part of what made the web special, and I’m afraid HTML will lose to other formats by willingly giving up its differentiators and playing on their turf. Who knows, it might turn out well, but it’s not a vision of the web that holds my interest.

I linked to his previous warning on this subject back in January.

The risky aspect of HTML5

The theory is that if all the User-Agent providers implement all these algorithms exactly as specified, complete interoperability will be achieved and people who build Web applications need no longer concern themselves with the differences between User Agents. Which would of course be wonderful.

Will it work? Nobody knows; it’s a science experiment. Just because nobody has ever succeeded in specifying a workable networked object model doesn’t mean this project will likewise fail. But it does mean that when considering the future of HTML5, we should recognize that this is a very hard problem, and there’s no guarantee that that part of it will come off.

From a blog post on HTML5 by Tim Bray.

Links for August 27

  • Simon St Laurent looks at reasons why there’s buzz around HTML again.
  • Mac OS X Automation explains Services in Snow Leopard (my copy arrives tomorrow). Via Daring Fireball.
  • A new poll reveals that people don’t actually even know what the public option is. The public option is a government-managed insurance plan that will compete with plans from private insurers in an exchange, available to individuals and small businesses that do not participate in group insurance. Here’s a longer explanation. In the meantime, the current Republican talking point seems to be that Medicare is a poorly run government program that we should preserve at all costs.
  • The MySQL Performance Blog looks at the Redis database. Redis is one of those schema-less databases people are all talking about these days.
  • Matt Raible takes a look at Java REST frameworks.
  • The UK is looking at plastic alternatives to traditional pub glasses. That wins my “stupidest thing I read today” award. Via Bruce Schneier.

Disparate impact in practice

Shelley Powers describes the hoops you need to go through to submit changes to the HTML5 specification:

The draft of the HTML5 spec out at the W3C is under continuous change, the formal Working Draft hasn’t been updated for some time, so we’re having to make changes on the run. To actually make these changes requires a degree of technical proficiency that has nothing to do with HTML markup. We’re told that to propose changes to the document for consideration, we need to, first of all, send our SSH2 public key into the Michael Smith, who will then set us up so that we can check out the existing documents, using CVS. We will then need to use a variety of tools, SVN, CVS, makefiles, XSLT, and so on, just to get reach a point that our concerns and suggestions are actually taken seriously.

And here’s the effect of the barriers:

HTML is a web document markup language. It is not a programming language or operating system. It is not WebKit, the Apache project, or the Linux kernel. Why it is being treated as such is because of group demographics. The recommended processes to work through issues are symptomatic of the fact that there is little or no diversity in the HTML 5 working group, virtually none in the WhatWG group. What we have is a working group run by tech geeks: not designers, not accessibility experts, graphic artists, web authors, not even web developers. Hard core, to the metal, geeks. And to a geek, the way around a problem is to throw technology at it; the way to filter input is to use technology as a barrier.

I couldn’t make up a more perfect example that bears out the point I was making in my post on disparate impact a couple of weeks ago.

HTML 5/XHTML 2 link roundup

This is a special link roundup related to the W3C killing off XHTML 2 and putting all its eggs in the HTML 5 basket. I’ve posted about this myself here.

A new way of writing a standard

I’ve been paying attention to the various goings on in the world of markup this week, and there will be lots of relevant links in the next roundup I post, but I wanted to comment on this email from Shelley Powers on Ian Hickson’s decision to give every browser maker veto power over any of the features listed in the HTML 5 specification. Powers absolutely hates this idea, but I confess that I’m intrigued.

Hickson has decided that the spec will not contain any features that browser vendors have not committed to support. This is very different from the usual standard-writing process, especially when it comes to W3C standards. In the past working groups have come up with lots of exciting new features and various rules to be obeyed and then the programmers go off and create something loosely based on that standard. The degree to which browsers are compliant with recent standards is a running joke, although things are much better now than they were a few years ago.

When asked whether each browser vendor can, by themselves, prevent a feature from being included in the HTML 5 recommendation, Hickson responds:

Not immediately, but if you had notable market share and we could not convince you to implement these new features, then yes, I’d remove them and then work with you (and everyone else) to try to come up with solutions that you would agree to.

Even if you did not have notable market share, I would work with you to understand your objections, and try to resolve them. (Naturally if your goals are substantially different than the WHATWG’s goals, then this might not go anywhere. For example, if Microsoft said that we should abandon HTML in favour of Silverlight, without making Silverlight backwards- compatible with HTML, then this would be somewhat of a non-starter, since backwards-compatibility is an underpinning of our work.)

What I find interesting about Hickson’s approach is that he makes the presumption of good faith. His process will only work if the browser vendors wish to collaborate to improve the Web experience by adding new features to HTML 5. Powers objects because she assumes bad faith on the part of vendors:

If we continue to allow one vendor/one veto to be the underlying philosophy of the HTML WG, then we might as well end working on it at this point, because I can’t see it being anything more than a race to the bottom, with each vendor looking to cripple open web development in favor of its own proprietary effort.

Worse, this process completely and totally disregards the community of users, of web developers, web designers, accessibility experts, and gives ultimate power to five companies: Google, Apple, Microsoft, Mozilla, and Opera–with Microsoft having the largest veto power. The rest of us might as well go home, because we have no say, no input, nothing of value to add to the future of the web. Not unless we crawl on bent knee to each vendor and ask them, “Please sir, I want some more.”

So here’s what I like about the Hickson philosophy. It will expose whether browser vendors want to work together to build new things everyone can benefit from, or if they want to rekindle or perpetuate the browser war. The thing is, we’ll know it earlier in the process than we would otherwise. Powers proposes a “three vendor” standard — if three vendors promise to implement a feature, it will be included. But then what happens is that the features go into the spec, those three browser vendors implement the feature, and the intransigent vendors do not? As professionals we can’t use new features anyway until they’ve been implemented. Under Hickson’s approach, the inclusion of a feature in the recommendation signals a commitment from all browser vendors to implement. We can plan ahead based on that.

If nothing else, it’s a new approach to an old problem. I’ll be curious to see what the process yields.

Links from June 8th

Links from May 28th

HTML really sucks right now

Over the past year or so I’ve come to realize that getting the markup right is the most difficult part of building Web applications. Had you asked me back a year ago, I’d have guessed that working with JavaScript was the most difficult, but now I know better.

Server side development is in many ways the easiest. For one thing, the tools are great. These days it’s easy to set up a full server environment on your laptop, and the tools for working with code are incredible. Whether you’re a Ruby developer working in Textmate or a Java developer working in Eclipse, NetBeans, or IDEA, the tools are out there to amplify your productivity. The pace of innovation in the server space is incredible as well. Good ideas are being transported from one platform to another at an incredible pace. (Ruby on Rails stole just about everything good from the Java stack, and now the Java folks are stealing all the good ideas they can from Ruby on Rails. PHP is benefitting from both as well.)

The most powerful advantage of working on the server, though, is that it’s empirical. Does this SQL query return what I expect? Does the markup emitted by this method look like what I think it’ll look like? It’s easy to answer these questions, and it’s advisable to write automated tests to verify that the answers to those questions haven’t changed.

JavaScript was once painful to write. You had to write a lot of code to accomplish simple things, the JavaScript implementations varied widely between browsers, and it was difficult to debug your JavaScript code. Most people got by on scripts of dubious quality that they copied from other web sites. Two things have changed, though to make life much easier for JavaScript developers.

The first is that there are now a number of incredibly powerful JavaScript libraries available. They make it easy to accomplish big things with just a little code, and they abstract away the browser differences that made programming in JavaScript so difficult. The second is that the tools have gotten better. FireBug brings a lot of the key features of a good IDE to Firefox. Having a real debugger is a huge help in working out where issues lie in your code. (You can only take window.alert() for so long.)

These days, I find working in JavaScript to be a pleasure, and I never thought I’d say that.

That brings us to HTML and CSS. Given a design, I’m starting to find that it’s not even possible to guess how long it’ll take to get the design to work across all of the common browsers in use today. Generally, I leave the markup to the experts, but for the past couple of months I had to delve deep into CSS and HTML myself. The first thing I discovered is that even making simple stuff look the same in Internet Explorer 6 and Firefox is a challenge. The next thing I learned is that it’s not even easy to make things look the same in Internet Explorer 6 and Internet Explorer 7.

When I went to people who know a lot more about cross-browser issues than I do, even they had to do a lot of experimentation to get things even close to looking right. And the secondary problem is that there don’t seem to be any sort of systemized tools or techniques to make any of this stuff much easier. Yes, FireBug is essential (how else are we supposed to know when styles are being overridden or aren’t being applied), but it seems like we need a lot more help if we want to make writing markup easier.

Is it really as bad as it seems, or am I missing something here? Because it sure strikes me as a rough time if markup is your medium.

© 2024 rc3.org

Theme by Anders NorenUp ↑