Forget AMD and that's straight from the source. Sorry for the long build-up on the history, but if I'm to convince you to forget this non-technology, I think it's best you know where it came from. For those in a hurry, the executive summary is in the subject line. ;)
In Spring of 2009, I rewrote the Dojo loader during a requested renovation of that project. The primary pattern used to make it more practical was:
dojo.provide('foo', ['bar1', 'bar2'], function() {
[module code]
});
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).
The big question regarding the upcoming (and thoroughly unneeded) 2.0 version of this most dubious script is whether its authors are foolish enough to leave "Sizzle" (their QSA fallback) in the code. If they are foolish enough to offer a "solution" that breaks IE 8- users (or requires conditional comments to avoid doing so), can they possibly think that they need anything but QSA to query the DOM?
Another looming question is how a project that has no way to keep track of plug-in compatibility with just one fork going to handle two at once? Poorly I imagine, but that's for those who remain on board to worry about.
Let's deconstruct this "magic" script. It's roughly 70% "Sizzle" (and supporting functions), 10% "Live" (an atrocious event system), 10% outmoded special effects (which can be done far more efficiently with CSS3 transitions and animations) and 10% miscellaneous (and often wildly confused) DOM "normalization" functions (e.g. measuring the viewport dimensions, reading and writing attributes/propertie
Have been fighting with some RWD "expert" on Wikipedia of late. At the time of this writing, my edits to the related article are still visible.
http://en.wikipedia.org/wiki/Responsive_Web_Design
RWD is just a buzzword. According to the article (and a fairly recent book it seems), it incorporates these techniques:
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>
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).
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
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
Often see library code similar to this:
// NOTE: Do not use this or similar code
(function(global) {
'use strict';
global.$ = {};
})(window);
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: