Mutating primordials and versioning

William Edney bedney at technicalpursuit.com
Tue Jan 19 10:05:42 PST 2010


Mike -

Here's some specific answers to these questions. I've also been advised to read the old E4 versioning proposal and maybe try to get this issue on the Jan 28-29 agenda. Any tips on that process would be helpful.

1. We've done both modification and replacement of prototypes in the past, although we've backed off of replacement of prototypes in the past few years, as the implementations (well, JScript) supported it very poorly. Obviously the modification of prototypes (and 'static' properties of the core 8 constructors) is really what I'm arguing for below. The scenario of replacement of prototypes is mostly around 'exporting' our 'enhanced' versions of these constructors to other 'global' contexts (i.e. windows in a browser). Unfortunately, due to the E3 spec not being prescriptive enough around object literals, the JScript engine does strange things with the prototype chain for objects created using object literals such that they follow a different chain than objects created with 'new'.

2. The fact that an API-incompatible method named 'create' was placed on Object was what broke our 'create' call.

3. By versioning, I mean a mechanism whereby any new features of the language beyond ES5 (originally the intent was ES3, but now since that language is indistinguishable from ES5, there's no use) are explicitly opted-in. Therefore, the 'baseline' is ES5 and new features are only enabled if a statement such as "use ESHarmony" or "use ES6" or whatever the committee comes up with (much like 'strict mode' must be strictly opt-ed into). Originally, 1.5 years ago, I had proposed on this list to use the older syntax of specifying the JS version in the <script language="JavaScript1.5"/>, etc. but there were concerns about using that approach in ECMAScript engines that were not hosted in a browser. So that's fine - a 'language level' switch would be ok. As I stated above, I'll reread the old E4 versioning proposal to see if there are potential answers there.

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 technicalpursuit.com>:
>> 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 mozilla.org
>> https://mail.mozilla.org/listinfo/es-discuss
>> 



More information about the es-discuss mailing list