david-mark

#How to Detect the Device Type?

The question of how to detect the device type running the given browser comes up a lot these days. It's virtually the same question as how to detect the browser (or browser version). It's often incorrectly "solved" in the same way, using indirect inferences based on browser sniffing.

##What is the Problem?

As with most such problems in browser scripting, it's best to look at what is to be inferred from such information. We know from experience that such information will often be based on coincidence and will expire at some point in the future, so it is best not to rely on it. An issue at the turn of the century was how to determine whether the browser was IE or not. But why was that information thought to be necessary? For example, at the time IE used attachEvent instead of the standard addEventListener to add event listeners.

##Indirect Inferences

david-mark

#Why Does jQuery Still Contain "Sizzle"?

The download of jQuery 3.1 contains the huge and complicated attempt to simulate the standard Selectors API called "Sizzle", allegedly to fix browser bugs.

It also attempts to make all CSS selectors work in supported browsers, but that's fairly pointless. If you need to support queries IE 8, then don't use CSS selectors that are unsupported in IE 8 (you'll know when you hit one as a friendly exception will be thrown). Same goes for IE 9 and 10, which are the only other browsers alleged to be supported by jQuery that contain significant gaps in CSS3 support. And even for those, it's a pretty short list of selectors that are missing in the browsers and supported (or attempted) by Sizzle.

As we'll see, jQuery doesn't support IE 8 at all, other than through old (1.x) and largely unmaintained versions that may well have problems in newer browsers (jQuery's designs have always required pe

mlhaufe

Moved to

david-mark

'use strict' Considered Pointless and Harmful

What is strict mode?

According to the MDN reference, it is:

ECMAScript 5's strict mode is a way to opt in to a restricted variant of JavaScript [sic].

It goes on to say:

david-mark

Often see library code similar to this:

// NOTE: Do not use this or similar code

(function(global) {
  'use strict';

  global.$ = {};
})(window);

david-mark

Always dubious on articles that open with "You're missing the point of..." as they so often demonstrate only that the author has missed a trick (or two or three).

It starts out with a note that one of the most popular implementations of Promises is (and will likely remain) broken:

Contrary to some mistaken statements on the internet, the problems with jQuery’s promises explained here are not fixed in recent versions; as of 2.1 beta 1 they have all the same problems outlined here, and according to one jQuery core team member, they will forever remain broken, in the name of backward compatibility.

Have heard rumors that this is fixed in jQuery 3.0, but jQuery should be a dead issue by now. Perpetually updating a long since irrelevant (and also non-standard) implementation of the browser-provided Selectors API is a non-starter. Using such a thing for a tacked-on Promises implementation can only be attributed to some sort of misguided bran

david-mark

Having had some of the first words on "modern" host object detection and testing, feel like it's time to try to issue a final word. At least I hope it is the last word as I've seen a lot misinformation spread over the last several years. The Web is great for that. :)

The original observations and concepts came about from discussions on comp.lang.javascript (CLJ) and were written up by Peter Michaux almost a decade ago.

The first rule to remember is that - with regard to detection - we don't know anything about host objects. How are they implemented? Why do they behave like they do? We can never really know as - unlike objects native and built into javascript (JS) implementations - there are no ECMA specifications for host objects. They are described in t

david-mark

Progressive Destruction

Last time we looked at the decade-long (and failed) effort to reinvent event listener attachment. We saw that the inherent graceful degradation of HTML still beats the equivalent "unobtrusive" patterns and is certainly a better bet for prototyping an application than the usual suspect DOM libraries.

There's a myth that progressive enhancement is somehow a "better" technique for browser scripting, but the fact is that they are not mutually exclusive and each has its place. This may remind you of a similar argument regarding feature detection vs. browser sniffing, but it certainly doesn't apply in that context.

We left off with the start of a draggable toolbar that works with any manner or combination of pointing devices (including your fingers).

david-mark

Unobtrusive JS === Unrealistic JS

In general, Web developers want to be seen using the very latest and "greatest" Web technologies. We want to add buzzwords to our CV's as soon as they are coined and want to be considered "cutting edge" developers who are "moving the Web forward". Unfortunately, history takes a dim view of our exuberance and science ignores it completely.

Best to start at the beginning with DOM0, which came out in the 90's. Here we have a button that alerts when clicked:

<button type="button" onclick="window.alert('Hello world!')">Click me!</button>

david-mark

Was asked to look at this thing again; only reviewed the JS portion. Last I checked, the CSS was similarly reality-challenged. Graphics are nice, but are tantamount to the paint job on a used car. Under the hood, this thing is all junk. It's hard to imagine the innards of any Web or mobile device-based application would end up like this, which raises the question of whether the authors have ever written such applications (or any amount of meaningful JS).

/**
 * @class Ext
 * @singleton

There (still) are no "classes" or "singletons" in JS (starting off on the wrong foot by mangling JS terms).