Mutating primordials and versioning

Mark S. Miller erights at
Tue Jan 19 11:59:52 PST 2010

On Tue, Jan 19, 2010 at 11:15 AM, William Edney <bedney at
> wrote:

> For the record, here was our wish list for ES3 back in 2000:
> An interesting wish list

> - Getter / setter support
> - Choosing whether or not to make a property enumerable

As you said, done in ES5.

> - Remove support for automatic semicolon insertion (or you suffer from what
> one of my team has affectionately referred to as 'autosemicolonoscopy' ;-) -
> yes, that can be as painful as it sounds)

LOL! Integrated over time, semicolon insertion has caused me much more pain

We kept trying to find a way to make it at least less painful in ES5-strict.
But we never came up with partial limitations on semicolon insertion we
could agree on, and we could never agree to remove it entirely. Since this
problem can be solved well enough by using external tools like JSLint, it
would be hard to lobby for a new opt-in for imposing this restriction.

> - A 'doesNotUnderstand' (i.e. 'noSuchMethod') hook (i.e. catchall
> setters/getters)

Have you seen <>? It
is on the agenda for the January meeting.

> - null / undefined as Real Objects, preferably singleton instances of the
> Null and Undefined type (this'll never happen for reasons previously
> discussed on this list, but it was a real wish at the time. Being able to
> use a catchall getter when a variable is null or undefined would serve the
> use case that this item was meant to solve).

Agreed on both counts. I'd prefer they be objects too, but that is not a
possible change.

> - Weak references

Have you see <>? Also on
the January meeting agenda.

> With ECMA e5, we got the first 2 of those 6, so (to paraphrase Mr. Loaf),
> "2 outta 6 ain't bad" :-).

If things go as I hope, that may become 4/6 in an ES >= 6.

> Cheers,
> - Bill
> >
> >> 4. Obviously, things like 'defineProperty' help the situation somewhat,
> although its of limited value if the system can still find and invoke/access
> the property. I'm not concerned with making the property visible/enumerable.
> I'm concerned with the engine finding it and invoking it. The module
> proposal has more usefulness here.
> >>
> >> 5. Opt-in security extensions don't bother me all that much, since I
> never plan to opt-in, just like 'strict mode' in ES5.
> >>
> >> 6. Obviously, this is what has been discussed on the list for the past
> week or so. I'm still thinking through the implications here. I can imagine
> a scenario where our framework is 'one big module', so as long as there are
> no code size limitations here, I'm somewhat noncommittal. Need to review and
> think more here.
> >>
> >> Thanks for your response.
> >>
> >> Cheers,
> >>
> >> - Bill
> >>
> >> On Jan 18, 2010, at 9:49 PM, Mike Samuel wrote:
> >>
> >>> Do you both modify prototypes, e.g.
> >>>  Array.prototype.indexOf = ...;
> >>> and replace prototypes,
> >>>  Date = ...;
> >>> ?
> >>>
> >>> Which ES5 changes in particular broke your create calls?
> >>>
> >>> What do you mean by versioning?
> >>>
> >>> Let me also list a few trends, and get your thoughts on them
> individually:
> >>> (1) Features that allow better patching, such as Object.defineProperty
> >>> which allows patchers to define non-enumerable extensions.
> >>>
> >>> (2) Opt-in security extensions that assume frozen primordials.
> >>>
> >>> (3) Module schemes that might allow a module to be unaffected by other
> >>> modules' extension.
> >>>
> >>>
> >>> 2010/1/18 William Edney <bedney at>:
> >>>> All -
> >>>>
> >>>> I've been lurking here, just to make sure you all were talking about
> what I thought you were talking about (didn't know the context under which
> the term 'primordials' was being used, but I understand it now to be
> built-in objects, such as Array, Boolean, Function etc. - if this isn't the
> case, please correct me and ignore the rest of this post).
> >>>>
> >>>> As co-authors and maintainers of a rather large framework, we've been
> 'mutating primordials' for over 10 years and have every intention to
> continue doing so. We do this for 2 main reasons, both of which drive right
> to the core of our framework:
> >>>>
> >>>> Polymorphism: Being able to retrofit an API onto the built-ins is
> crucial. JavaScript is a very dynamic language (maybe that rubs some of the
> people here the wrong way, but there it is - sorry), and being able to treat
> all objects in a true polymorphic fashion is one of the most powerful
> aspects of dynamism. Objective-C recognized this need long ago and allowed
> for "Categories", which allowed existing types to be extended (even compiled
> code).
> >>>>
> >>>> Bugs: I know that no one here has ever run into a browser bug (tongue
> firmly in cheek), but the ability to monkey-patch a buggy implementation of
> a browser native method to fix a bug has allowed us to maintain a consistent
> API with methods that have already been standardized, but are broken in a
> particular implementation. For instance, older versions of IE have a problem
> with negative indexes on methods like slice(). We were able to 'repair'
> those by monkey-patching. Simple and elegant and, most importantly, no
> deviation from the well established standard. Bug-free JS implementations
> exist in the same world as the Tooth Fairy and Sandy Claws.
> >>>>
> >>>> There seems to be an obsession on this group to try to turn the clock
> back 10 years and change some of the choices made when ECMAScript ed. 3 was
> standardized in late 1999. Well, as Austin Powers would say, "That train has
> sailed". We're gonna be living with E3 from now until the end of time (or
> until the Web becomes something else entirely). Too much code has been
> written and, as I've stated on this list before, much of it is behind
> corporate firewalls, etc. that will never be known, never be 'surveyed',
> never be 'measured' - and to which the author of said code wandered off 5
> years ago.
> >>>>
> >>>> We will continue to express our grave concern, as we did 1.5 years ago
> on this very list, that without a versioning mechanism in place and a
> requirement for engines to continue to support older language semantics (and
> requiring explicit opt-in for the 'new' language - think "use Harmony" or
> whatever) we're on the fast train to hell here. The assumption that new
> method names can be added to existing objects and that's "ok, because its
> additive and so no one would've used that" is just wrong. Even HTML has
> standards mode vs. compatibility mode. Anything else would have broken the
> web. The same requirement exists for JavaScript.
> >>>>
> >>>> What we know for sure, regardless of agreement on best practices or
> coding or lack thereof, is that the work done on ES5 broke our framework.
>  We used 'create' as a wrapper around our own alloc/init sequence and now,
> thanks to ES5, we've had to rebuild every single type and all calls to our
> constructors. If there is no plan for a versioning model moving forward,
> we're anticipating the worst from Harmony.
> >>>>
> >>>> Cheers,
> >>>>
> >>>> - Bill
> >>>>
> >>>> "The beauty of creating a language, or any tool for that matter, is
> that people take it and use it in ways you could never imagine...unless of
> course you go to the trouble to ensure they can't possibly do anything
> outside of the box you currently imagine."
> >>>> _______________________________________________
> >>>> es-discuss mailing list
> >>>> es-discuss at
> >>>>
> >>>>
> >>
> >>
> _______________________________________________
> es-discuss mailing list
> es-discuss at

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list