39 comments

[ 1.2 ms ] story [ 47.7 ms ] thread
There are 2 webs.

web apps and web sites.

web apps require a [java|ecma]script whatng cartel web engine, more and more only the gogol one (blink) will "correctly" work (abuse of dominant position).

web sites are noscript/basic (x)html ("forms" and the <audio> <video> elements). Usually a "semantic" 2D table with proper ids for navigation.

The older ones among us remember when XML took over the world and everyone was supposed to use strict XHTML. It turned out that the strength of the HTML ecosystem was its fault tolerance. HTML4 was the "sloppy" answer to XHTML. It brought HTML back from a data language to a markup language. Every Markdown parser is similarly fault-tolerant as HTML parsers.

However, CSS and JS are not error-tolerant. A syntax error in a CSS rule causes it to be ignored. An unhandled JavaScript exception is a hard stop. This way, web does not run on tolerance.

> It turned out that the strength of the HTML ecosystem was its fault tolerance.

I don't think this was a "strength" of html so much as a necessity to not break the internet. I certainly preferred the formal nature of xhtml to html 5. But, we're stuck with needing to render obviously formally-broken documents.

Nonsense. Open the console on l any mediocre webpage and you’ll see a stream of JavaScript errors. But it’s still working. One script crashes? Doesn’t matter to any other script. Unhandled exception? Rest of the app is still working fine. Hell, that button may work if you just click it again.

And CSS syntax error causing only that single line of code to be ignored while every other line of code works fine is the very definition of fault tolerance.

What else could you possibly want?

> HTML4 was the "sloppy" answer to XHTML

I think you mean HTML5, which exhaustively specified how to do parsing in a fault-tolerant, normalizing way. HTML 4 (and 4.01) predated XHTML 1.0, and HTML 4.01 attempted to take things in a stricter direction, introducing a "Strict" DTD that did things like drop the <font> tag, in pursuit of separating structure and presentation.

Funny enough my impression of JS (the kind you'd write in 2007 more than the type you see now, mind you) is that it's remarkably tolerant; many idioms and operations which would cause, in other languages, runtime errors or compile errors, would just get steamrolled over in JS because of just how much built-in flexibility the uber-weak type system (plus liberal use of the prototype pattern in the stdlib) allows for.

- Wanna subtract a string from a number? That's not a type error, that's a `NaN` -- which is just a perfectly-valid IEEE 754 float, after all, and we all float down here.

  - Hell -- arithmetic between arbitrary data types? Chances are you get `[object Object]` (either as a string literal or an *actual* object), which you can still operate on.
- Accessing an object field but you typoed the field name? No worries, that's just `undefined`, and you can always operate on `undefined` values.

Frankly, while I haven't had a frontend focus in about 15 years, I struggle to think of any situation where calling a stdlib function or standard language feature would result in an actual exception rather than just an off behaviour that'll accumulate over time the more of them you stack on eachother. I guess calling an undefined variable is a ReferenceError, but beyond that...

(This comment shouldn't be taken as an endorsement of this school of language design)

> CSS [is] not error-tolerant. A syntax error in a CSS rule causes it to be ignored.

That is error-tolerant, in basically the same way HTML is.

> An unhandled JavaScript exception is a hard stop.

A more appropriate example here is that a JS syntax error stops the entire script from running. That’s the XML parser approach.

> However, CSS and JS are not error-tolerant. A syntax error in a CSS rule causes it to be ignored.

This is good though as it provides a means for progressive enhancement using new features only when they are available and falling back on previous rules if they are not. It's very different from the syntax error -> RIP page nonsense of XHTML.

But in contrast, web communities run on moderation, i.e. a sort of intolerance of bad content. The lesson is that technical issues and social issues really don't mix. You can't conclude anything from one versus the other. Case in point, cryptocurrency was supposed to be the anarchist's dream, but now it's being adopted by some central banks.
This guy lost me when he started talking about diversity issues instead of tech. I couldn't care less about the race, gender, or sexual orientation of the person(s) who created the hardware or software that I use. Does it work? Is it easy to understand and use? These are the things I am interested in.

I am reminded of an early cartoon of a dog sitting at a computer saying 'On the Internet, no one knows you are a dog!'

I think the Author diverges from the main point - that web standards and browsers' interpretation rules are loosely held (tolerance), towards indirectly attacking the current US administration which is allegedly trending towards intolerance and isolationism. Bit of a weird tangent (Though not inaccurate).
What a bizarre bait and switch. Starts talking about browsers allowing malformed HTML and uses that to draw conclusions about allowing certain types of people.
>But the web works because browsers are tolerant.

This is more of an artifact of needing to be compatibile with other browsers and more of an arbitrary decision where once one browser starts allowing all sorts of input than everyone else may start needing to if content starts relying on it.

>But the world is better for it.

It makes compatibility between different browsers more complicated due to adding a ton of edge cases that all need to be handled the same way as opposed to following a standardized way of writing pages.

>The user experience of XHTML was rubbish. The disrespect shown to anyone for deviating from the One True Path made it an unwelcoming and unfriendly place.

The UX could be improved along with developer tools making it harder to mess up and easy to spot mistakes. For example many internet forums have similar requirements of needing to match formatting tags and those have work successfully despite being strict. I think the real issue was that XHTML was introduced too late. Trying to fix things in a decentralized ecosystem is an extremely big uphill battle. If you don't fix things at the very start things can grow out of one's control.

>The beauty of the web as a platform is that it isn't a monoculture.

There is also beauty in that there is a standard that everyone can follow to ensure that pages written can work the same in all browsers.

>I cannot fathom how someone can look at the beautiful diversity of the web and then declare that only pure-blooded people should live in a particular city.

The way people interact with each other in the real world is very different than the way browsers render pages. I do not think such a comparison makes any sense to make.

>How do you acknowledge that the father of the computer was a homosexual, brutally bullied by the state into suicide, and then fund groups that want to deny gay people fundamental human rights?

Just because someone was in the right place at the right time does not mean that they are of perfect moral character. It's similar to the quote to never meet your heros. The people you may look up to in regards to some achievement may not be the best of character and keeping a distance from them may be the best else your opinion of them may be tarnished.

>When you throw slurs and denigrate people's pronouns, your ignorance and hatred does a disservice to history and drives away the next generation of talent.

I disagree that this happens. At best it discourages a subset of the next generation, but it is not a subset I would like to work with. These kinds of people could also drive away other potential talent too. Simply increasing the number as opposed to trying to build a positive, healthy, culture and growing it I don't think is the best idea.

>This isn't an academic argument over big-endian or little-endian.

It could be about these 2 choices. For example x86 processors were able to be extremely successful despite not being tolerant between big and little endian. By picking a single one and running with it, it's been able to help unify computing on little endian.

This author needs to either be specific about who and what they're talking about or not bother. I don't have the context to understand their specific complaints and I'm not motivated to seek it out.
When I finished reading it I thought it was an anti-Trump piece, but the author also wrote: "That's why it baffles me that some prominent technologists embrace hateful ideologies.". Was Trump a techie too? He must have been behind the creation of JS.

"The ARM processor which powers the modern world was co-designed by a trans woman." This is not factually correct. Roger Wilson was one of the designers of the processor, but he didn't transition to become Sophie Wilson until 9 years after the first release of ARM1 according to Wikipedia.

(comment deleted)
(comment deleted)
XML exists so infinity migration should be allowed?
The right-wing extremism we now have in the US is the expected knee-jerk reaction to the left-wing extremism that came before it.

In both cases there's a few true believers and a lot of opportunists who use the cause as a way to further their own agenda. It happened with the left (the master branch rename being the stupidest example), it's now happening in the right, with big words and performative actions such as ICE raids while the root cause of the problem is not addressed (industries reliant on large-scale illegal immigrant labor are left alone).

The right answer is somewhere in the middle of the two camps. Unfortunately until then people suffer on both sides while opportunists use the conflict for their own interests.

Dude.

HTML4 era was full of parser hacks. Increasingly more and more parser hacks.

XHTML tried to solve that, and make HTML parsing more acessible to everyone. It's not about rigor, it's about making it simpler.

HTML5 goes in the other direction. It formalized all those hacks into very, very strict parsing rules. It's super strict and specific, to the point that only companies with large resources can realistically invest in a proper HTML5 engine.

So, the metaphor does not hold.

You actually don't need a technical-aspect analogue to advocate for better, more inclusive human behavior. It's much better if you don't rely on those. People should not need a spec as a mirror to understand that.

This whole article has, to be ragebait - surely? It's such a inane piece of writing, the world needs to give less time to anyone that genuinely holds these views. They're entitled to hold them, but they're still wrong.

>It had an intolerant ideology.

Without going into the various reasons why its trash, conforming to a spec is not intolerance, it's success. Imagine the Brooklyn bridge design committee saying "requiring exactly 1 inch plate is intolerance!! You can't discriminate against different thicknesses, all thicknesses are equally valuable!"

What a useless position to hold.

What the web runs on is freedom, the freedom to express and disseminate any information one pleases with impunity. That prominent figureheads embrace the hateful ideologies that you speak of is merely a tide of the current times, and will change as soon as they become unpopular, just as they had quit embracing this "tolerance" which was in full force a few years prior. Because they are not about a hate of people, but hate of freedom: hate is merely a pretense, a convenient vehicle through which freedoms can be taken. I think freedom is the most important thing worth fighting for, and you had my support up until now. But then you go on to say that those outside your own window of ideology have no place here. It's much the same methods that the people you complain of employ: to be disingenuous about what you really want-- it's your inability to force your will upon others that you're frustrated with. You have missed the forest for the trees, and the context has already been created for you: you are projecting a battle for the rights of certain groups onto a battle against the rights of all, and you've been turned against yourself. Freedom is something, if you believe in it, you must believe in in its entirety: not almost-freedom, or a convenient sliver of freedom that fits into your own ideological window. You lack the qualifications to exercise tolerance.
Well that took a surprising turn. (1) Friendly dunking on someone named todepond. (2) Interesting ideas about xhtml... looks like I'm going to learn something here. (3) Ideological conflict.

Is there a backstory here? Or is this just random venting?

Anyways, I reject the idea that loose programming is more "tolerant" in any sociological manner.

>You can make your HTML as malformed as you like and the web-browser will do its best to display the page for you. I love the todepond website, but the source-code makes me break out in a cold sweat. Yet it renders just fine.

It renders just fine because it is syntactically valid HTML. HTML is not and is not supposed to be XML. It is originally an SGML application described by its Document Type Definition and SGML Declaration (https://www.w3.org/TR/html4/HTML4.decl). HTML uses and has always used many SGML features not found in XML, such as tag inference (<html><title> becomes <html><head><title>, <p><p> becomes <p></p><p>). Some of these, like SHORTTAG, were never even implemented in browsers. These days HTML is defined by the WHATWG ‘living standard’, which largely just restates the SGML DTD rules in plain language.

(Okay, https://validator.w3.org/nu/?doc=https%3A%2F%2Fwww.todepond.... shows a few minor errors, bet you couldn’t spot them.)

This is independent of the fact that browsers do try their best to render objectively broken markup, usually by ignoring the broken parts. In principle they could do the same with XHTML, but someone decided it would be ‘helpful’ to show the parser’s diagnostic output instead, and the rest is history.

Postel was wrong, and it's got nothing to do with tolerance of other people, and everything with solid engineering (or encouraging the absence thereof). It mattered for rapid adoption, it is the curse of any stable system.

But if we must make stretched analogies, I'll give you instead "The Standard You Walk Past" - https://www.youtube.com/watch?v=s_TfZdIhIgg

It's making a pretty compelling case that keeping standards matters, "anything goes" is a bad idea, and it does all that in the name of tolerance towards other humans.

Postel's Law was one of those Great Mistakes of computing, alongside null pointers, fork(2), and well, C in general. Conform to the spec or be in error. If you allow for sloppiness, you create a problem because different implementations will tolerate different kinds of sloppiness, yielding incompatibilities and horrors like "quirks mode".

XHTML tried to rein this in but by then the cat was out of the bag, and every Tom, Dick, and Mary who was trying to learn HTML was used to the mire tolerant behavior.

I mean no offense but comparing fault tolerance to being tolerant with other people only works because it’s the same word that’s used for both meanings. But that has absolutely nothing to do.

If it weren’t the case, you’d argue that people pushing XHTML were intolerant bastards.

This article is a prime example of false equivalence. The cool thing about false equivalence is that, when you throw the laws of logic out of the window, you can prove pretty much everything. Anyone can write a specular article proving that intolerance is actually good since very stricter programming languages (like Rust and its borrow checker) are inherently safer.
My tolerance for online ads is zero. Do I break the web?