I
was intrigued by Neil Deakin’s recent post “urn:schemas-microsoft-com:office:office” /> where
he says that when he was a young user, he got mad about all kinds of things that,
after a few years as an implementor, he didn’t feel mad about anymore.

I’m
with ya, Neil.  Many of my computer geek
high school friends were rather surprised to learn that I had taken a job at Microsoft,
given my earlier criticisms of all x86 based software.  (I
was an Amiga partisan as a teenager.) I feel the same way you do — I was a naïve
teenager.

Neil,
however, doesn’t actually explain why it is that he finds his former beliefs to be
naïve.  I can’t speak for Neil, but I
can take a stab at explaining what the revelation was for me.  Basically
it comes down to realizing two things:  (1)
good design is a series of difficult compromises,
and (2) software is by its nature incredibly complex.  I
failed to appreciate either of those facts until I’d actually done a lot of it myself.  Once
I appreciated these things, I understood that we have imperfect software BECAUSE the
people who make it are dedicated to writing quality software for end users, not in
spite of that fact.

And
it doesn’t matter what your business model is — open source or closed source, give
away the software and sell consulting, shrink-wrapped boxes, micropayments, freeware,
whatever.  The money story is irrelevant;
all software development is about coming up with an implementable, usable design
for a given group of end users and then
finding enough resources to implement that
design.  There are only a finite number
of programmers in the world, and way more problems that need solving than there are
resources available to solve them all, so deciding which problems to solve for what
users is crucial.

Sometimes
— not always, but sometimes — not fixing a trivial, obscure bug with an easy workaround is the
right thing to if it means that you can spend that time working on a feature that
benefits millions of customers. Sometimes features that are useless to you are life-savers
for someone else.  Sometimes — not always,
but sometimes — using up a few more pennies of hard disk space (ten megs costs, what,
a penny these days?) is justifiable.  Sometimes
— not always, but sometimes — proprietary designs allow for a more efficient design
process and hence more resources available for a quality implementation.   These
are all arguable, and maybe sometimes we humans don’t make the _best_ choices.  But
what is naive is to think that these are not hard problems that people think about
hard.

When
I was a teenager, I thought software engineering was trivial — but my end user was
myself, and my needs were simple.  Software
development doesn’t scale linearly!  Complex
software that exists to solve the real-world problems of millions of end-users is
so many orders of magnitude harder to write, that intuitions about the former can
be deeply misleading.

And
this is true in ALL design endevours that involve tough choices and complex implementations!  I
was watching the production team commentary track for the extendamix of The Two Towers
this weekend, and something that the producers said over and over again was that they
got a lot of flack for even slightly changing the story from the book.  But
before you criticize that choice, you have to really
think through all the implications of being slaves to the source material.  How
would the movie be damaged by showing Merry and Pippin’s story entirely
in flashback?  By not interlacing
the Frodo-and-Sam story with the Merry-and-Pippen story?  By
making Faramir’s choice easy? By adding Erkenbrand as the leader of the Westfold?  Yes,
these are all departures from the book, but they also prevent the movie from being
confusing and weak at the end.  None are
obvious — they’re all arguable points, and ultimately someone had to make a tough
decision to produce a movie that wasn’t going to satisfy everyone fully, but would
nevertheless actually ship to customers!

There
is no perfect software; the world is far too complex and the design constraints are
too great for there to be anything even approaching perfect software.  Therefore,
if you want to ship the best possible software for your users, you’ve got to carefully
choose your imperfections.  As the guy
who writes tools for you software engineers, my mission is to make tools that afford deeper
abstrations and hence require fewer developer
resources to implement.  That’s the
only way we’re going to get past the fundamental problems of complexity and expense.

Tags Rants

Comments (6)

You must be logged in to post a comment.

1. MartijnOK, about that software geek thingie, you are probably right, I can’t tell, but please don’t say they had to make all these changes to the Lord of the Rings book.
   Peter Jackson has a pretty good insight what the books where about, but I think that he has made some fatal errors in the second movie, by changing the story.
   I think the book is all about choices (what do you do when you are confronted with evil/power), and Peter has changed that behavior of some characters in the movy in a really bad way.
2. Log in to Reply
3. November 24, 2003 at 8:11 pm
4. DanielSo what are your thoughts on this:
   http://www.fastcompany.com/online/06/writestuff.htmlcan NASA can get perfect software ?
5. Log in to Reply
6. “This software never crashes. It never needs to be re-booted. This software is bug-free.”
7. November 24, 2003 at 10:02 pm
8. silI agree entirely that your eyes are opened when you get into collaboratively developing code with a big team and putting together proper stuff rather than one-shot code for yourself, absolutely. However, the shift from user (or one-man coder) to software developer can also bring with it less of a focus on usability, because you forget everything that you didn’t know as that user; some stuff is just so *obvious* as a hacker that it never occurs to you that it’s confusing or non-obvious to others. I’m not necessarily suggesting that you’re guilty of this, Eric, but there’s not a lot of difference between “you don’t understand how putting software together works — you’re naive and should learn” and “you don’t understand how software works — you’re naive and should learn”, I feel. Dangerous ground, where it’s easy to sell out those youthful passions and compromise too much…
9. Log in to Reply
10. November 25, 2003 at 2:57 am
11. Stuart DootsonDaniel – no, NASA cannot get perfect software..or rather, they *may* get perfect software, but they cannot know it – they cannot know if there are still defects in their software, unless they’ve decided to leave them in.Log in to Reply
12. The other thing to think about is that by deciding to try and minimise the number of bugs in their software, NASA have effectively decided that they are going to spend an awful lot of money on what is effectively a small functionality set. They probably spend 10-100 times what Microsoft (or any other PC software vendor) spend per function point – possibly more. The testing budget is probably 50-60% of the total budget. (and yes, I’m speaking from experience – I’ve developed safety-critical software to DO-178B Level A).
13. November 25, 2003 at 4:15 am
14. Peter TorrIt would be more correct to say “This software has never crashed”. Also Eric is talking about building software for millions of people who do arbitrarily complex things with it, combine it with other arbitrary software and hardware, and so on. The Shuttle group has an incredibly narrow focus for their software: It must launch the shuttle, and that’s it.Log in to Reply
15. I bet they don’t let the crew watch DVDs or run the SETI screen saver on the same machine that fires the engines 😉
16. November 25, 2003 at 12:41 pm
17. Mike DimmickThe space shuttle software also has an extremely limited range of hardware that it has to run on, while Windows has to run on the entire gamut of PC hardware.Log in to Reply
18. NASA reportedly had a bit of a crisis recently because they weren’t able to source 8086 processors for the space shuttle computers.
19. November 25, 2003 at 2:48 pm

Skip to main content

Follow Us

Popular Tags

C# Scripting JScript VBScript Language Design COM Programming Rarefied Heights Puzzles Rants Performance Security C# 4.0 Non-computer SimpleScript JScript .NET Immutability Code Quality Pages Recursion Books

Archives

• November 2012 (5)
• October 2012 (5)
• September 2012 (2)
• August 2012 (5)
• July 2012 (2)
• All of 2012 (47)
• All of 2011 (66)
• All of 2010 (90)
• All of 2009 (100)
• All of 2008 (43)
• All of 2007 (63)
• All of 2006 (25)
• All of 2005 (97)
• All of 2004 (167)
• All of 2003 (88)

A
reader asked me to clarify a point made in an earlier entry:

Note
that JScript .NET arrays do not have any of the methods or properties of a CLR array.
(Strings, by contract, can be used implicitly as either JScript .NET strings or as System.String values,
which I’ll talk more about later.) But JScript .NET arrays do not have CLR array fields
like Rank, SetValue,
and so on.

It’s
actually pretty straightforward.  When
you have a string in a JScript .NET program, we allow you to treat it as both a System.String
and as a JScript object with the String prototype.  For
example:

var s
= ”   hello   “;

print(s.toUpperCase());
// calls JScript string prototype’s toUpperCase

print(s.Trim());
// calls System.String.Trim

Which
is it?  From a theoretical standpoint,
it doesn’t really matter — you can use it as either.  From
an implementation standpoint, of course we use System.String internally and magic
up the prototype instance when we need one — just as in JScript classic all strings
are VT_BSTR variants internally and we magic up a wrapper when we need one.  So
JScript strings and CLR strings really are totally interoperable.

Arrays
aren’t quite so seamless.  As I mentioned
earlier, when you try to use a JScript .NET array when a CLR array is expected, we
create a copy.  But when you go the other
way, things are a little different. Rather than producing a copy, using a CLR array
as a JScript .NET array “wraps it up”. No copy is made. The operation is therefore
efficient and preserves identity. Changes
made to a wrapped array are preserved:

function
ChangeArray(arr : Array) : void

{

print(arr[0]);
// 10

arr[0]
+= 100;

//
JScript .NET methods work just fine

print(arr.join(“:”));
// 10:20:30

}

var arr
: int[] = [10, 20, 30];

ChangeArray(arr);

print(arr[0]);
// 110

The
principle rule for treating a hard-typed array as a JScript .NET array is that it
must be single-dimensional. Since all JScript .NET arrays are single-dimensional
it makes no sense to wrap up a high-rank CLR array.

Once
the array is wrapped up it still has all the restrictions that a normal hard-typed
array has. It may not change size, for instance. This means that an attempt to call
certain members of the JScript .NET Array prototype on a wrapped array will fail.
All calls to push, pop, shift, unshift and concat as
well as some calls to splice will
change the length of the array and are therefore illegal on wrapped CLR arrays.

Note
that you may use the other JScript .NET array prototype methods on any hard-typed
array (but not vice versa). You can think of this as implicitly creating a wrapper
around the CLR array, much as a wrapper is implicitly created when calling methods
on numbers, Booleans or strings:

var arr
: int[] = [10, 20, 30];

arr.reverse();    //
You may call JScript .NET methods on hard-typed arrays

print(arr.join(“:”));   //
30:20:10

There
may be a situation where you do want to
make a copy of a CLR array rather than wrapping it. JScript .NET has syntax for this,
namely:

var sysarr
: int[] = [10, 20, 30];

var jsarr1
: Array = sysarr; // create wrapper without copy

var jsarr2
: Array = Array(sysarr); // create wrapper without copy

var jsarr3
: Array = new Array(sysarr); // not a wrapper; copies contents

In
the last case jsarr3 is
not a wrapper. It is a real JScript .NET array and may be resized.

Tags JScript JScript .NET Scripting

Comments (3)

You must be logged in to post a comment.

1. Dan ShappirI think some of that reader’s misunderstanding is a result of the use of the word “contract” where the word “contrast” was intended.function ChangeArray(arr) : void
   {
   print(arr[0]); // 10
   arr[0] += 100;
   }Log in to Reply
2. Would it still convert the CLR array to a JScript.NET array? Or have I created a generic function that works for both types with no conversions?
3. In any event, thanks for the info.
   A question though: suppose I had changed the ChangeArray implementation to:
4. November 23, 2003 at 5:33 am
5. Peter TorrDan, your changed function does not specify a type for the ‘arr’ parameter, so it will be compiled as “Object” and all operations on ‘arr’ will be late-bound. Thus it will work with JScript arrays, CLR arrays, and indeed anything that has an overloaded indexing operator.
6. Log in to Reply
7. November 23, 2003 at 12:56 pm
8. Eric LippertYeah, I guess the spell checker didn’t catch that one, did it? 🙂
9. Log in to Reply
10. November 24, 2003 at 6:02 pm

Skip to main content

Follow Us

Popular Tags

C# Scripting JScript VBScript Language Design COM Programming Rarefied Heights Puzzles Rants Performance Security C# 4.0 Non-computer SimpleScript JScript .NET Immutability Code Quality Pages Recursion Books

Archives

• November 2012 (5)
• October 2012 (5)
• September 2012 (2)
• August 2012 (5)
• July 2012 (2)
• All of 2012 (47)
• All of 2011 (66)
• All of 2010 (90)
• All of 2009 (100)
• All of 2008 (43)
• All of 2007 (63)
• All of 2006 (25)
• All of 2005 (97)
• All of 2004 (167)
• All of 2003 (88)

You
might have noticed something odd about that last example using SetValue.
If you actually look up the method signature of SetValue in
the CLR documentation it notes that the function signature is:

public
function SetValue(value : Object, indices : int[]) : void

The
odd thing is the annotation on indices.
It is typed as taking a .NET array of integers but in the example in my last entry
we give it a literal JScript array, not a hard-typed CLR array.

JScript
.NET arrays and hard-typed CLR arrays work together, but because these two kinds of
arrays are so different they do not work together perfectly.
The problem is essentially that JScript .NET arrays are much more dynamic than CLR
arrays. JScript .NET arrays can change size, can have elements of any type, and so
on.

The
rules for when JScript .NET arrays and CLR arrays may be used in place of each other
are not particularly complicated but still you should exercise caution when doing
so. In particular, when you use a JScript .NET array in a context where a CLR array
is expected you can get unexpected results. Consider this example:

function
ChangeArray(arr : int[]) : void

{

print(arr[0]);
// 10

arr[0]
+= 100;

}

var
jsarr : Array = new Array(10, 20, 30);

ChangeArray(jsarr);

print(jsarr[0]);
// 10 or 110?

This
might look like it prints out 10 then 110, but in fact it prints out 10 twice. The
compiler is unable to turn the dynamic JScript array into a hard-typed array of integers
so it does the next best thing. It makes a copy of the JScript array and passes the
copy to the function. If the function reads the array then it gets the correct
values. If it writes it, then only the copy
is updated, not the original.

To
warn you about this possibly unintentional consequence of mixing array flavours, the
compiler issues the following warning if you do that:

warning
JS1215: Converting a JScript Array to a System.Array results in a memory allocation
and an array copy

You
may now be wondering then why the call to SetValue which
had the literal JScript .NET array did not prompt this warning. The
warning is suppressed for literal arrays. In the case of literal arrays the compiler
can determine that a literal array is being assigned to a CLR array type. The
compiler then optimizes away the creation of the JScript .NET array and generates
code to create and initialize the CLR array directly. Since there is then no performance
impact or unexpected copy, there is no need for a warning.

Note
that if every element of the source JScript .NET array cannot be coerced to the type
of the hard-typed CLR array then a type mismatch error will be the result. For instance,
if you tried to coerce an array containing strings to an array of integers then this
would fail:

var
arr1 : int[] = new Array(10, “hello”, 20); // Type mismatch error at runtime

var
arr2 : int[] = [10, “hello”, 20];          //
Type mismatch error at compile time

Note
also that this applies to multidimensional arrays. There
is no syntax for initializing a multidimensional array in JScript .NET:

var
mdarr : int[,] = [ [ 1, 2 ], [3, 4] ]; // Nice try, but illegal

A rectangular multidimensional
array is not an array of arrays. In this case you are assigning a one-dimensional
array which happens to contain arrays to a two-dimensional array of integers. That
is not a legal assignment. If, however, you want a ragged hard-typed
array it is perfectly legal to do this:

var
ragged : int[][] = [ [ 1, 2 ], [3, 4] ];

print(ragged[1][1]);
// 4

Rectangular
multidimensional arrays are indexed with a comma-separated list inside one set of
square brackets. If you use ragged arrays to simulate true multidimensional arrays
then the indices each get their own set of brackets.

Note
that JScript .NET arrays do not have any of the methods or properties of a CLR
array. (Strings, by contract, can be used implicitly as either JScript
.NET strings or as System.String values,
which I’ll talk more about later.)  But
JScript .NET arrays do not have CLR
array fields like Rank, SetValue,
and so on.

Next
time I’ll talk a bit about going the other way — using a CLR array where a JScript
array is expected.

Tags JScript JScript .NET Scripting

Comments (5)

You must be logged in to post a comment.

1. Damit> Note that JScript .NET arrays do not have any of the methods or properties of a CLR array. (Strings, by contract, can be used implicitly as either JScript .NET strings or as System.String values, which I’ll talk more about later.) But JScript .NET arrays do not have CLR array fields like Rank, SetValue, and so on.Log in to Reply
2. I wonder whether you meant to say here that JScript .NET arrays *have* CLR array fields? This paragraph sounds rather confusing to me…
3. November 14, 2003 at 10:51 pm
4. Dan ShappirI found this post very interesting. Recently I’ve added a new module to BeyondJS called BeyondRhino, targeted at the Rhino platform. One of the features this module provides is better interop between JavaScript types and Java types, including arrays and collections.var a = [1,2,3].toJava();OTOH I also added methods to JavaScript arrays that allow access and manipulation of the array object itself via Java’s collection interfaces. For example:returns an List interface on top of the specific array instance. So you can use it to manipulate that instance:Given the highly dynamic structure of JavaScript arrays, it seems to make a lot of sense to enable their use as generalized collection objects.Log in to Reply
5. BTW the reason for this work is that I want to enable the use of JavaScript as a UnitTesting platform for Java.
6. l.add(4);
   for ( var i in a ) print(a[i] + ” “); // outputs 1 2 3 4
7. var a = [1,2,3];
   var l = a.list();
8. a is now a Java array of integers (type [I…). You can also pass arguments to the toJava() method to control the type of array generated. The only upside of this technique when compared to what you did with JScript.NET is that it makes it clearer IMO that what you get is a copy of the original array.
9. I also wanted to make it easier to convert between JavaScript and Java arrays. Since I couldn’t modify the behavior of the JavaScript interpreter to automatically convert between array types, I needed to take a more explicit route (well, technically I could modify the behavior since Rhino is open source, but I must admit I’m not feeling quit up to that task right now). My solution was to add a .toJava() method on all JavaScript basic types including arrays. Likewise I added a toJavaScript() function to convert Java arrays to JavaScript arrays. For example:
10. November 15, 2003 at 3:41 pm
11. Eric Lippert> Given the highly dynamic structure of JavaScript arrays, it seems to make a lot of sense to enable their use as generalized collection objects.> I want to enable the use of JavaScript as a UnitTesting platform for Java.Log in to Reply
12. That’s a cool idea, but wouldn’t it be on the face of it easier to use Java as a unit testing platform for Java, rather than making Rhino interoperate better with Java? 🙂
13. Indeed!
14. November 17, 2003 at 2:38 pm
15. Dan Shappir> but wouldn’t it be on the face of it easier to use Java as a unit testing platform for Java, rather than making Rhino interoperate better with Java?There are a couple of advantages in using a language like JavaScript over standard Java:2. It’s easier to construct some data structures using JavaScript than it is using Java. For example, if I want to create a collection containing numbers 1 through 10 that exposes the List interface. All I need to do using BeyondJS is write: (1).to(10).list() Consider the alternative Java code.BTW, It’s not necessarily a putdown of Java to claim that JavaScript may be a better PL for constructing tests than Java. Writing tests, especially dynamic tests, is not the same as writing standard apps. A lot of people are using things like Jython for testing Java, there is even a new PL being design specifically for this purpose: http://groovy.codehaus.org/Log in to Reply
16. There is one significant disadvantage in using Rhino: the Rhino interactive environment doesn’t do code completion or argument tips. But you can use the standard JavaScript facilities to do introspection on Java objects.
17. 3. If you look through the Rhino samples you’ll see that it’s also easier to create event handlers than in Java.
18. 1. Rhino provides an interactive environment, so I can test classes interactively.
19. Maybe, but it wouldn’t be as fun 😀
20. November 18, 2003 at 4:26 am
21. David SmithWouldn’t it just be better to use the real version of javascript instead of jscript which is riddled with problems?It has been my experiance that trying to hack code to try and get it to work differently than it does originally is a bad idea since it is pretty much unsupported by design.
22. Log in to Reply
23. Or for that matter instead of trying to hack code for .Net use sun’s ver of Java + IDE?
24. July 23, 2004 at 1:44 pm

Skip to main content

Follow Us

Popular Tags

C# Scripting JScript VBScript Language Design COM Programming Rarefied Heights Puzzles Rants Performance Security C# 4.0 Non-computer SimpleScript JScript .NET Immutability Code Quality Pages Recursion Books

Archives

• November 2012 (5)
• October 2012 (5)
• September 2012 (2)
• August 2012 (5)
• July 2012 (2)
• All of 2012 (47)
• All of 2011 (66)
• All of 2010 (90)
• All of 2009 (100)
• All of 2008 (43)
• All of 2007 (63)
• All of 2006 (25)
• All of 2005 (97)
• All of 2004 (167)
• All of 2003 (88)

As
I was saying the other day, CLR arrays and JScript arrays are totally different beasts.
It is hard to imagine two things being so different and yet both called the same thing.
Why did the CLR designers and the JScript designers start with the same desire —
create an array system — and come up with completely different implementations?

Well,
the CLR implementers knew that dense, nonassociative hard-typed arrays are easy to
make fast and efficient. Furthermore,
such arrays encourage the programmer to keep
homogenous data in strictly bounded tables. That makes large
programs that do lots of data manipulation easier to understand. Thus, languages
such as C++, C# and Visual Basic have arrays like this, and thus they are the basic
built-in array type in the CLR.

Sparse,
associative, soft-typed arrays are not particularly fast but they are far
more dynamic and flexible than Visual Basic-style arrays. They make it easy to
store heterogeneous data in any table without
worrying about picky details like exactly how big that table is. In other words,
they are scripty. Languages such as JScript
and Perl have arrays like this.

JScript
.NET has both very dynamic, scripty arrays
and more strict CLR arrays, making it suitable
for both rapid development of scripts and programming in the large. But like I
said, making these two very different kinds of arrays work well together is not trivial.

JScript
.NET supports the creation of multidimensional hard-typed arrays. As with single-dimensional
arrays, the array size is not part of the
type. To annotate a variable as containing a hard-typed multidimensional array
the syntax is to follow the type with brackets containing commas. For example, to
annotate a variable as containing a two dimensional array of Strings you would say:

var multiarr
: String[,];

The
number of commas between the brackets plus one is equal to the rank of the array.
(By this definition if there are no commas between the brackets then it is a rank-one
array, as we have already seen.)

A
multidimensional array is allocated with the new keyword
as you might expect:

multiarr
= new String[4,5];

multiarr[0,0]
= “hello”;

Notice
that hard-typed array elements are always
accessed with a comma-separated list of integer indices. There must always be exactly
one index for each dimension in the array. You can’t use the ragged array syntax [0][0].

There
are certain situations in which you know that a variable or function argument will
refer to a hard-typed CLR array but you do not actually know the element type or the
rank, just that it is an array. Should you find yourself in one of these (rather rare)
situations there is a special annotation for a CLR array of unknown type and rank:

var sysarr
: System.Array;

sysarr
= new String[4,5];

sysarr
= new double[10];

As
you can see, a variable of type System.Array may
hold any CLR array of any type and rank. However, there is a drawback. Variables of
type System.Array may
not be indexed directly because the rank is not known. This is illegal:

var sysarr
: System.Array;

sysarr
= new String[4,5];

sysarr[1,2]
= “hello”;  // ILLEGAL, System.Arrays
are not indexable

Rather,
to index a System.Array you
must call the GetValue and SetValue methods with
an array of indices:

var sysarr
: System.Array;

sysarr
= new String[4,5];

sysarr.SetValue(“hello”,
[1,2]);

The
rank and size of a System.Array can
be determined with the Rank, GetLowerBound and GetUpperBound members.

Thinking
about this a bit now, I suppose that we could have
detected at compile time that a System.Array was
being indexed, and constructed the call to the getter/setter appropriately for you,
behind the scenes.  But apparently we
didn’t.  Oh well.

Next
time: mixing and matching JScript and CLR arrays.

Tags JScript JScript .NET Scripting

Comments (5)

You must be logged in to post a comment.

1. Dan ShappirSo far the only potential downside I see in this design is that you cannot write a generic function that works for both JScript arrays and CLR arrays if the arrays have a rank higher than 1. I assume the following function will work on both types of arrays:Would have been even nicer if CLR arrays in JScript were somehow made to support the length property if they were one dimensional.BTW, I can’t resist, using the BeyondJS JavaScript library you could write the above code as:Log in to Reply
2. var sum = arr.fold(“+”);
3. Anyway, you could not write such a function if arr was, say, two dimensional.
4. function sum(arr, length) {
   var result = 0;
   for ( int i = 0 ; i < length ; ++i ) result += arr[i];
   return result;
   }
5. November 13, 2003 at 3:55 am
6. Eric Lippert> I assume the following function will work on both types of arrays:> you cannot write a generic function that works for both JScript arrays and CLR arrays if the arrays have a rank higher than 1> Would have been even nicer if CLR arrays in JScript were somehow made to support the length property if they were one dimensional.> var sum = arr.fold(“+”);Log in to Reply
7. I assume that your fold operator calls eval if the thing passed in is not a function object?
8. Dude, wait for it. I said I’d discuss interoperability in my NEXT blog! 🙂
9. Yep, but there are no JScript arrays with rank higher than one, so basically this is saying that you can’t write a generic function that handles arrays of different ranks — but wait a minute, that is what System.Array is for! ie, those rare cases where you don’t know the rank at compile time.
10. Indeed.
11. November 13, 2003 at 11:14 am
12. Dan Shappir> Yep, but there are no JScript arrays with rank higher than one> that is what System.Array is for> Dude, wait for it.>I assume that your fold operator calls eval if the thing passed in is not a function object?You can also do “-“.toFunctionUnary() or “-“.toFunctionBinary() to control which version is generated. Here is the implenetation:Log in to Reply
13. String.prototype.toFunctionUnary = function() {
    eval(“function __unary__(op) { return ” + this + ” op; }”);
    __unary__.op = this.valueOf();
    return __unary__;
    };
    String.prototype.toFunctionBinary = function() {
    eval(“function __binary__(op1, op2) { return op1 ” + this + ” op2; }”);
    __binary__.op = this.valueOf();
    return __binary__;
    };
    String.prototype.toFunction = function() {
    return “,!,~,++,–,new,delete,typeof,void,”.indexOf(“,” + this + “,”) > -1 ?
    this.toFunctionUnary() : this.toFunctionBinary();
    };
14. BeyondJS implements a mechanism of converting strings to functions:”+”.toFunction() will generate a binary function
    “!”.toFunction() will generate a unary function.
15. You caught me, I’m the impatient type 😉
16. You misunderstood me. I wasn’t looking to write a function that would work for any rank. I was looking for a function that would work for, say, a 2D JScript array and a 2D CLR array. While I fully understand the reasons you chose the indexing syntax used for multi-dimensional CLR arrays, I simply pointed out that as result they are not polymorphic with multi-dimensional JScript arrays.
17. Technically you are correct, but practically you simply create an array of arrays. And the resulting syntax looks just like C++ or Java. That was my point actually, that for a 2D JScript array you write a[1][2] while for a CLR array you write a[1,2].
18. November 13, 2003 at 12:23 pm
19. Eric LippertYeah, there’s no interoperation between ragged arrays and two-d arrays. But there is no interoperation between ragged CLR arrays and two-d CLR arrays either! Ragged arrays and rectangular arrays are pretty much separate concepts. In fact, the whole notion of rank of a ragged array is ill-defined — you can have a ragged array that is 3-d in some axes, 2-d in others, 1-d in still others, etc. There is no sensible notion of “rank”, so making them interoperate is more trouble than its worth.Log in to Reply
20. Your implementation is pretty slick. (A less functional but perhaps more performant approach would be to generate all the unary and binary operator functions once and put them in a lookup table, rather than searching that string every single time and reconstructing the function object every single time.)
21. November 13, 2003 at 12:51 pm
22. Dan ShappirYou are quit correct about both points.With regard to BeyondJS, our motivation was always functionality, with performance a consideration but not more. Anyway, fold generates the function once, and then applies it iteratively to all the members. So the performance hit of generating a new function every time is relatively minor when compared to the cost of the loop.
23. Log in to Reply
24. With regard to ragged arrays: I always found it amusing that C++ employs the same exact syntax for accessing ragged and contiguous array. So a[1][2] would generate wildly different code base on the definition of a. OTOH it did buy you that polymorphic behavior I mentioned before.
25. November 13, 2003 at 3:24 pm

As
I mentioned in an
earlier entry, one of the major differences between JScript .NET and JScript Classic
is that JScript .NET now supports optional type annotations on variables.  The
number of built-in primitive types has also increased dramatically.  JScript
.NET adds value types boolean, byte, char, decimal, double, float, int, long, sbyte, short, uint, ulong and ushort.  In
addition, JScript .NET integrates its type system with the CLR type system — a string
in JScript has all the properties and methods of the string prototype and all
the properties and methods of a System.String.  Backwards
compatibility and interoperability with the CLR were two very important design criteria.

The
primitive types are pretty straightforward though.  Some
more interesting stuff happens when we think about how complex types like arrays interoperate
between JScript .NET and the CLR.  I already
discussed some of these issues regarding JScript and VBScript arrays, so let’s
quickly review the terminology:

A sparse array
may have “holes” in the valid indices. A sparse array with three elements might have
elements 0, 10 and 1000 defined but nothing in between. The opposite of a sparse array
is a dense array. In a dense array all
the indices between the lowest and highest indices are valid indices. A dense array
with elements 0 and 1000 has 1001 elements.

A fixed-size array
has a particular valid range of indices. Typically the size is fixed when the array
is created and it may not be changed. A variable-sized array
does not have any maximum size. Elements may be added or removed at any time.

A single-dimensional array
maps a single index onto a value. A multi-dimensional array
may require any number of indices to fetch a value.

The
number of dimensions an array has is called its rank.
(Other terms such as dimensionality or arity are
occasionally used but we will stick to rank.)

A static-typed array
or hard-typed array is an array where
every element is of the same type. A dynamically-typed or soft-typed array
may have elements of any type.

An associative array
is an array where the indices are strings. A nonassociative array
has integer indices.

A literal array
is a JScript .NET array defined in the actual source code, much as “abcde” is
a literal string or 123.4 is
a literal number. In JScript .NET a literal array is a comma-separated list of items
inside square brackets:

var arr
= [10, 20, “hello”];

var item
= arr[1]; // 20

JScript
arrays are sparse, variable-sized, single-dimensional, soft-typed associative arrays.
CLR arrays are the opposite in every way! They are dense, fixed-size, multi-dimensional, hard-typed nonassociative arrays.
It is hard to imagine two more different data structures with the same name.  Making
them interoperate at all was a pain in the rear, believe me.

This
is a pretty big topic, so I think I’ll split it up over a few entries.  Let
me talk a bit about annotation and typing, and we’ll pick up where we left off tomorrow.

Traditional
JScript arrays are soft-typed; they can store heterogeneous data:

var arr
= new Array();

arr[0]
= “hello”;

arr[1]
= 123.456;

arr[2]
= new Date();

CLR
arrays, on the other hand, are hard-typed. Every element of a CLR array is the same
type as every other element. This difference motivates the type annotation syntaxes
for each. In JScript .NET the traditional arrays are annotated with the Array type
and hard-typed CLR arrays are annotated with the type of the element followed by []:

var jsarr
: Array = new Array()

jsarr[0]
= “hello”;

var sysarr
: double[] = new double[10];

sysarr[0]
= 123.4

Note
that CLR arrays are fixed-size, but the size
is not part of the type annotation; sysarr can
be a one-dimensional array of double of
any size. This is perfectly legal, for example:

var sysarr
: double[] = new double[10];

sysarr[0]
= 123.4

sysarr
= new double[5];

This
throws away the old array and replaces it with a new, smaller array. But once
a hard-typed array is created it may not be resized.

Tomorrow:
true multidimensional arrays in JScript .NET.

Tags JScript JScript .NET Scripting

Comments (1)

You must be logged in to post a comment.

1. How to list the statement of all var ? – Page 2 | keyongtechPingBack from http://www.keyongtech.com/4922739-how-to-list-the-statement/2
2. Log in to Reply
3. January 21, 2009 at 8:05 pm

A
reader asks “can
you explain the logic that a string is not always a String but
a regexp is always a RegExp?
What is the recommended way of determining if a value is a string?”

Indeed,
you are correct:

print(/foo/
instanceof RegExp);             //
true

print(new
RegExp(“foo”) instanceof RegExp); // true

print(“bar”
instanceof String);             //
false

print(new
String(“bar”) instanceof String); // true

print(typeof(“bar”));                       //
string

print(typeof(new
String(“bar”)));           //
object

Why’s
that?

First
off, the question about strings.  In JScript
there is this bizarre feature where primitive values — Booleans, strings, numbers
— can be “wrapped up” into objects.  Doing
so leads to some bizarre situations.  First
off, as you note, the type of a wrapped primitive is always an object type, not a
primitive type.  Also, we use object equality,
not value equality.

print(new
String(“bar”) == new String(“bar”)); // false

I
highly recommend against using wrapped primitives.  Why
do they exist?  Well, the reasoning has
kind of been lost in the mists of time, but one good reason is to make the prototype
inheritance system consistent.  If “bar”
is not an object then how is it possible to say

print(“bar”.toUpperCase());

?
Well, actually, from the point of view of the specification, this is just a syntactic
sugar for

print((new
String(“bar”)).toUpperCase());

Now,
of course as an implementation detail we do not actually cons
up a new object every time you call a property on a value type!  That
would be a performance nightmare.  The
runtime engine is smart enough to realize that it has a value type and that it ought
to pass it as the “this” object to the appropriate method on String.prototype and
everything just kind of works out.

This
also explains why it is possible to stick properties onto value types that magically
disappear.  When you say

var bar
= “bar”;

bar.hello
= “hello”;

print(bar.hello);
// nada!

of
course what is happening is logically equivalent to:

var bar
= “bar”;

(new
String(bar)).hello = “hello”;

print((new
String(bar)).hello); // nada!

See,
the magical temporary object is just that — magical and temporary.  Once
you’ve used it, poof, it disappears.

But
this magical temporary object does not appear when the typeof or instanceof operators
are involved.  The instanceof operator
says “hey, this thing isn’t even an object, so it can’t possibly be an instance of
anything”.  For both consistency and usability,
it would have been nice if “bar”
instanceof String created
a temporary object and hence said yes, it is an instance of String.  But
for whatever reason, that’s not the specification that the committee came up with.

Second,
your question about regular expressions is easily answered now that we know what is
going on with strings.  The difference
between regular expressions and strings is that regular
expressions are not primitives.  Just
because you have the ability to express a regular expression as a literal does
not mean that it is a primitive!  That
thing is always an object, so there is no behaviour difference between the compile-time-literal
syntax and the runtime syntax.

Third,
your question about how to determine whether something is a string is surprisingly
tricky.  If typeof returns “string” then
obviously it is a string, end of story.  But
what if typeof returns “object” —
how can you tell if that thing is a wrapped string?

It’s
not easy.   instanceof
String doesn’t
tell you whether that thing is a string, it tells you whether String.prototype is
on the prototype chain.  There’s nothing
stopping you from saying

function
MyString() {}

MyString.prototype
= String.prototype;

var s
= new MyString();

print(s.constructor
== String);            //
true

print(s
instanceof String);                //
true

print(String.prototype.isPrototypeOf(s));  //
true

So
now what are you going to do?  JScript
is excessively dynamic!  Basically you
can’t rely on any object being what it says it is.  JScript
forces people to be operationalists.  (Operationalism
is the philosophical belief that if it walks like a duck and quacks like a duck, it is a
duck.)  In the face of the kind of weirdness
described above, all you can do is try to use the thing like a string, and if it acts
like a string, it s a string.

Tags JScript Scripting

Comments (8)

You must be logged in to post a comment.

1. Jay HugardVerry interesting. I had most of that already but was thrown off by the “magic temporary” construction.Log in to Reply
2. Thanks!
3. November 6, 2003 at 7:31 pm
4. BlakeEric writes, “…cons up a new object…”Log in to Reply
5. Busted. We knew there has to be a Lisp geek hiding in there.
6. November 6, 2003 at 8:04 pm
7. Eric LippertYeah, I knew someone would bust me.Whoops, did I say that out loud?
8. Log in to Reply
9. In truth, I have never written any nontrivial programs in Lisp, though I did a fair amount of Scheme programming when I was at UW. I just use the expression “cons up” to get geek cred from hard core lisp freaks.
10. November 6, 2003 at 8:41 pm
11. Anonymous> all you can do is try to use the thing like a string, and if it acts like a string, it s a stringOh, and also thanks for the “magic temporary”. Just when you think you know everything about JavaScript, it throws you a curveball. BTW, this “magic temporary” sort of brings C++ anonymous temporaries to mind.
12. Log in to Reply
13. Only problem here is that most anything can come out looking like a string, given the toString() method. Maybe ECMAScript should just go the way of TCL – declare everything a string a be done with it 😉
14. November 8, 2003 at 4:58 pm
15. Dan ShappirMy comment above – again Remember Me doesn’t seem to work.Number.prototype.showType = function() { alert(typeof(this)); }
    (3).showType();The reason I did not think through the full implications of this is that I was caught up in the concept that in ECMAScript everything is an object. Must say I’m somewhat disappointed that this isn’t really the case (even though in most cases you really can’t tell the difference).Log in to Reply
16. BTW anybody who has used Netscape’s LiveConnect (at least version 4.x) knows the situation there is even worse. Strings returned by applets are of the type java.lang.String, which JavaScript identifies only as objects, and not even string objects. You need to apply the String function explicitly to these objects if you want to manipulate them using JavaScript. Rhino OTOH handles this scenario very well.
17. I even made a comment about auto-boxing.
18. After some more though I should have realized the “magic temporary” behavior. If for nothing else then the example I gave for part one:
19. November 9, 2003 at 4:11 am
20. Dan ShappirAs I’ve pointed out in a comment to a previous post, JavaScript uses duck typing, that is it matches functionality by name (of property). In this respect the “real” type of an object doesn’t mater very much, only the functionality it exposes. Consider the following example:Do the objects referenced by a, b and c have the same type? If your answer is “yes, they all have the type Object” you miss the fact that a and b share a common structure. However, by any other criteria mentioned in the posts so far, a and b have nothing in common.b.x = “y”;It is a shame, however, that ECMAScript does not provide a means to do operator overloading or create special properties like String’s length. This would make it possible to create ADTs that are functionally equivalent to the internal types.
21. Log in to Reply
22. The fact that JavaScript objects are so malleable, and can be modified both internally and externally after they have been created, makes much of the type related info irrelevant.
23. To take it farther, what if I tack another property on to b:
24. function foo() { return { hello : “world” , bye : “everybody” }; }
    var a = foo();
    var b = foo();
    var c = new Object();
25. November 9, 2003 at 10:07 am
26. Anonymous> duck typing
    Maybe we should read this as “ducks out of typing” 😉JScript seems to have types but is not typed.
27. Log in to Reply
28. > much of the type related info irrelevant
    So why don’t we just call JScript an untyped (not-typed) language?
    Languages without data types are called “typeless” (BCPL, MCPL)
29. November 9, 2003 at 7:17 pm
30. Centaur> if it acts like a string, it’s a string.
    And if it acts almost, but not entirely, unlike a string, it’s something that is almost, but not entirely, unlike a string, but will be mistaken for a string if the feature that is tested happens to fall in that “not entirely” exception category 🙂
31. Log in to Reply
32. November 10, 2003 at 6:29 am

Skip to main content

Follow Us

Popular Tags

C# Scripting JScript VBScript Language Design COM Programming Rarefied Heights Puzzles Rants Performance Security C# 4.0 Non-computer SimpleScript JScript .NET Immutability Code Quality Pages Recursion Books

Archives

• November 2012 (5)
• October 2012 (5)
• September 2012 (2)
• August 2012 (5)
• July 2012 (2)
• All of 2012 (47)
• All of 2011 (66)
• All of 2010 (90)
• All of 2009 (100)
• All of 2008 (43)
• All of 2007 (63)
• All of 2006 (25)
• All of 2005 (97)
• All of 2004 (167)
• All of 2003 (88)

A number of readers made some good comments on my article on JScript typing that deserve to be called out in more detail.

First, I was being a little sloppy in my terminology — I casually conflated static typing with strong typing, and dynamic typing with weak typing. Thanks for calling me on that. Under the definitions proposed by the reader, JScript would be a dynamically typed language (because every variable can take a value of any type) and a strongly typed language (because every object knows what type it is.) By contrast, C++ is a statically typed language (because every variable must have a type, which the compiler enforces) but also a weakly typed language (because the reinterpret cast allows one to turn pointers into integers, and so on.)

Second, a reader notes that one of the shortcomings of JScript is that though it is a strongly typed language (in our new sense) that it is a royal pain to actually determine the runtime type an object. The typeof operator has a number of problems:

* null is listed as being of the object type, though technically it is a member of the Null type.

* primitives (strings, numbers, Booleans) wrapped in objects are listed as being of the object type rather than their underlying type.

* JScript, unlike VBScript, does not interrogate COM objects to determine the class name.

* If JScript is passed a variant from the outside world that it cannot make sense of then typeof returns “unknown”.

Perhaps there is some other way. Prototype inheritance affords a kind of type checking, for example.

Prototype inheritance works like this.  Every JScript object has an object (or possibly null) called its prototype object.  So suppose an object foo has prototype object bar, and bar has prototype object baz, and baz has prototype object null.  If you call a method on foo then JScript will search foo, bar and baz for that method, and call the first one it finds. The idea is that one object is a prototypical object, and then other objects specialize it. This allows for code re-use without losing the ability to dynamically customize behaviour of individual objects.

Prototypes are usually done something like this:

var Animal = new Object();

// omitted: set up Animal object

function Giraffe(){

// omitted: initialize giraffe object.

}

Giraffe.prototype = Animal;

var Jerry = new Giraffe();

Now Jerry has all the properties and methods of an individual Giraffe object AND all the properties and methods of Animal.  You can use IsPrototypeOf to see if a given object has Animal on its prototype chain. Since prototype chains are immutable once created, this gives you a pretty reliable sort of type checking.

Note that Giraffe is not a prototype of Jerry. Note also that Animal is not the prototype of Giraffe! The object which is assigned to the prototype property of the constructor is the prototype of the instance.

Now, you guys are not the first people to point out to me that determining types is tricky. A few years ago someone asked me what the differences are amongst

if (func.prototype.IsPrototypeOf(instance))

and

if (instance.constructor == func)

and

if (instance instanceof func)

The obvious difference is that the first one looks at the whole prototype chain, whereas the second two look at the constructor, right? Or is that true? Is there a semantic difference between the last two? Actually, there is. Let’s look at some examples, starting with one that seems to show that there is no difference:

function Car(){}

var honda = new Car();

print(honda instanceof Car); // true

print(honda.constructor == Car);  // true

It appears that instance instanceof func and instance.constructor == func have the same semantics.   They do not.  Here’s a more complicated example that demonstrates the difference:

var Animal = new Object();

function Reptile(){ }

Reptile.prototype = Animal;

var lizard = new Reptile();

print(lizard instanceof Reptile); // true

print(lizard.constructor == Reptile); // false

In fact lizard.constructor is equal to Object, not Reptile.

Let me repeat what I said above, because no one understands this the first time — I didn’t, and I’ve found plenty of Javascript books that get it wrong. When we say

Reptile.prototype = Animal;

this does NOT mean “the prototype of Reptile is Animal”.  It cannot mean that because (obviously!) the prototype of Reptile, a function object, is Function.prototype.  No, this means “the prototype of any instance of Reptile is Animal”.  There is no way to directly manipulate or read the prototype chain of an existing object.

Now that we’ve got that out of the way, the simple one first:

instance instanceof func means “is the prototype property of func equal to any object on instance’s prototype chain?”  So in our second example, the prototype property of Reptile is Animal and Animal is on lizard’s prototype chain.

But what about our first example where there was no explicit assignment to the Car prototype?

The compiler creates a function object called “Car”.  It also creates a default prototype object and assigns it to Car.prototype.  So again, when we way

print(honda instanceof Car);

the instanceof operator gets the prototype property (Car.prototype) and compares it to the prototype chain of honda.  Since honda was constructed by Car it gets Car.prototype on its prototype chain.

To sum up the story so far,

Tags JScript Scripting

Comments (16)

Cancel reply

You must be logged in to post a comment.

1. Erik Arvidsson says:Just a side note. The prototype object is usually called __proto__ ( [[Protoype]] in the spec) and almost all ECMAScript engines (except the Microsoft ones) allows read write of this private property.
2. Log in to Reply
3. November 6, 2003 at 2:40 pm
4. Jay Hugard says:Can you explain the logic behind the following madness (in JScript Classic), which appears to mean that a string is not always a String but a regexp is always a RegExp?slit instanceof String => false
   sobj instanceof String => true
   slit instanceof Object => false
   sobj instanceof Object => true
   typeof( slit ) => string
   typeof( sobj ) => object
   typeof( slit ) == typeof( sobj ) => falseAs generated by:function evalprintln( s )
   {
   if( !s ) { println(“”); return }
   var out = s + ” => “;
   try{ out += eval(s) } catch( e ) { out += “Error: ” + e.description }
   println(out);
   }var tests = [
   “slit instanceof String”,
   “sobj instanceof String”,
   “slit instanceof Object”,
   “sobj instanceof Object”,
   “typeof( slit )”,
   “typeof( sobj )”,
   “typeof( slit ) == typeof( sobj )”,
   null,
   “relit instanceof RegExp”,
   “reobj instanceof RegExp”,
   “relit instanceof Object”,
   “reobj instanceof Object”,
   “typeof( relit )”,
   “typeof( reobj )”,
   “typeof( relit ) == typeof( reobj )”
   ];Log in to Reply
5. for( var ix in tests ) { evalprintln( tests[ix] ) }
6. var slit = “Literal String”;
   var sobj = new String( “String object” );
   var relit = /literal regexp/i
   var reobj = new RegExp( “RegExp object” );
7. function println(s) { WScript.echo(s) /*System.Console.Out.WriteLine(s)*/ }
8. relit instanceof RegExp => true
   reobj instanceof RegExp => true
   relit instanceof Object => true
   reobj instanceof Object => true
   typeof( relit ) => object
   typeof( reobj ) => object
   typeof( relit ) == typeof( reobj ) => true
9. Conversly, what is the recommended way of determining if a value is a string?
10. November 6, 2003 at 6:01 pm
11. Peter Torr says:Erik — IIRC, Netscape removed the support for __proto__ from their engine some years ago because it was a bad idea to let people mess with the prototype chain this way. The ECMA standard does not require the property to be exposed, and it is dangerous to do so.
12. Log in to Reply
13. November 6, 2003 at 6:32 pm
14. Peter Torr says:Jay, if you read the ECMA spec you will see that there are string primitives and string objects, just as there are number/boolean primitives and number/boolean objects. Basically you should never use “new String(…)” because it is a waste of time and energy.print(nlit instanceof Number)
    print(nlit instanceof Object)
    print(nobj instanceof Number)
    print(nobj instanceof Object)
15. Log in to Reply
16. var nlit = 42
    var nobj = new Number(42)
17. November 6, 2003 at 6:40 pm
18. IUnknown says:>JScript, unlike VBScript, does not interrogate COM objects to determine >the class name.Log in to Reply
19. This gets the award for the most unrelated error message:
    TypeName(myObject)
    throws, when the type information is unavailable:
    Out Of string space: ‘TypeName’
20. November 7, 2003 at 2:02 am
21. Eric Lippert says:Can I see a repro for that? If the type name is unavailable, it should return “Unknown” or, if it is an IDispatch, “Object”.Log in to Reply
22. TypeName does return “Out of string space”, but only when the attempt to allocate the string for the type name fails.
23. November 7, 2003 at 12:54 pm
24. Erik Arvidsson says:Peter: I know both the Mozilla engines (C and Java) and the Macromedia engine has support for this. I was pretty sure that Opera supported this as well but I just verifed that they do not.fucntion SubClass( args )
    {
    SuperClass.call( args );
    }
    SubClass.prototype.__proto__ = SuperClass.prototype;Log in to Reply
25. Well, well… now that we have ECMAScript v4 around the corner there is no real need for this.
26. I can understand why it is considered dangerous but usage of __proto__ can be very useful. For example it allows you to skip creating an instance that is used as the prototype.
27. November 7, 2003 at 3:14 pm
28. Eric Lippert says:> Well, well… now that we have ECMAScript v4 around the corner there is no real need for this.Log in to Reply
29. That’s news to me. Could you more precisely define “around the corner”?
30. November 7, 2003 at 5:02 pm
31. Isaac says:> conflated static typing with strong typing
    “static typing” unhelpfully confuses when checks are made with the kind of checks that are made.Simpler to understand that JScript is a dynamically-checked untyped (safe?) language.Log in to Reply
32. I think you demonstrated that it’s pretty hard to figure out what the type of a value is in JScript – so why insist on calling it a typed language?
33. Simpler to understand that C++ is a statically-checked weakly-typed language (and also that some things are dynamically checked in C++).
34. November 7, 2003 at 5:26 pm
35. Anonymous says:[quote]Can I see a repro for that? If the type name is unavailable, it should return “Unknown” or, if it is an IDispatch, “Object”. [/quote]Also see this:
    http://groups.google.com/groups?q=typeName+%22Out+of+string+space%22
36. Log in to Reply
37. I got this when trying it on a COM object that uses run-time generated type info (ie. CreateDispTypeInfo). This only provides a minimal implementation of ITypeInfo. This is not common(or recommended) so I wouldn’t worry too much. If it helps the COM object is out of process.
38. November 8, 2003 at 6:05 am
39. Eric Lippert says:OK, then I have a guess as to what is happening. This is a TERRIBLE way to wait for an out-of-proc object (OOPO) to shut down. I’ll bet that there is a race condition here where the stub is returning a pointer to memory that becomes bad when the OOPO shuts down. So the TypeName method essentially gets passed a pointer to bad memory.So what we’ve got here is a memory corruption bug that is not crashing, but returning a bogus error instead.
40. Log in to Reply
41. Now suppose that the bad memory happens to be in a readable committed page, but contains garbage. We assume that the thing is a BSTR, so we look at the value stashed preceding the string body to determine the length. That could be any old number; the odds that the number happens to be larger than the largest remaining heap block are actually very good.
42. November 8, 2003 at 10:57 am
43. Anonymous says:The link I posted was just something I found while searching on the error. My situation relates to using run time type info. Have you tested TypeName with run time type info? It is obsolete and I only use it for testing so this discussion is essentially accademic.I think my object was based on the code found here, so if you want to copy and paste:
    http://docs.rinet.ru:8083/VidimyyC/vcu28fi.htm#I25
44. Log in to Reply
45. My guess is that something similar is happening, ITypeInfo must be returning bogus data. Assuming that you check all error results this could even be a bug in the implementation of ITypeInfo for CreateDispTypeInfo. As mentioned, this is obsolete and probably hasn’t been looked at for a long time.
46. November 9, 2003 at 4:13 am
47. Erik Arvidsson says:”That’s news to me. Could you more precisely define “around the corner”?”Known implemantions of ECMAScript v4:One possible reason for JS2 taking so long might be that ECMA moved all their resources to C# instead?
48. Log in to Reply
49. ActionScript

    QTScript

    JScript 7

50. I guess I was wrong 😥 This has been in the works for way too long…
51. May 2, 2004 at 7:07 am
52. Eric Lippert says:A more likely reason is that Waldemar Horwat, who was the primary driving force behind the E4 spec, no longer works for AOL-Time-Warner-Netscape and hence is no longer being paid to drive the spec process forward. (Rumour has it that he’s at google now.)Log in to Reply
53. Microsoft is still involved in the E4 process, but it is slow going.
54. May 2, 2004 at 8:23 am
55. Fabulous Adventures In Coding says:Log in to Reply
56. October 7, 2004 at 1:32 pm
57. Intercept instanceof | keyongtech says:PingBack from http://www.keyongtech.com/4947719-intercept-instanceof
58. Log in to Reply
59. January 18, 2009 at 12:41 pm

I’m going to make a rare departure from technical stuff for a moment.  I’ve seen Matrix Revolutions twice in the last twelve hours, once in IMAX.

A number of people have asked me for an opinion.  To sum up in a spoiler-free manner:

First off, IMAX was better, though not enormously so.  (Oddly enough, Reloaded was enormously better in IMAX.)  As an example of state-of-the-art action movie making, it kicked ass.  But what about the underlying theme?  Let’s summarize:

The Matrix was a movie about kung fu vs. evil robots that asked and answered the philosophical question “what is the nature of reality?”

The Matrix Reloaded was a movie about kung fu vs. evil robots that asked and answered the philosophical question “what is the nature of free will?”

Matrix Revolutions was a movie about kung fu vs. evil robots that asked and answered the philosophical question “if Neo got into a fight with Agent Smith, who would win?”

We return you now to your regularly scheduled programming.

Commentary from 2019:

As I’ve noted before, the VSTO team code names and whatnot were all taken from The Matrix, and it was a fun theme.

I am not “spoiler averse” but I saw the first movie in the series knowing absolutely nothing about it, and was thrilled to discover that it had kung fu, evil robots, and literal brain-in-a-vat philosophy undergrad thought experiments. Sure, lots of it was hokey and unbelievable, but it had such energy, and was genuinely surprising.

I should not have been surprised by a reversion to the mean in the sequels; the original was hard to top.

I thought I might spend a few days talking about the JScript and JScript .NET type systems, starting with some introductory material.

Consider a JScript variable:

var myVar;

Now think about the possible values you could store in the variable. A variable may contain any number, any string or any object. It can also be true or false or null or even undefined. This is a rather large set of possible values. In fact, the set of all legal values is infinite. Countably infinite, and in practice limited by available memory, but in theory there is no upper limit.

A type is characterized by two things, a set and a rule. First, a type consists of a subset (possibly infinitely large) of the set of all possible values. Second, a type defines a rule for transforming values outside the set into values in the set. (This rule may specify that certain values are not convertible and hence produce “type mismatch” errors.)

For example, String is a type. The set of all possible strings is an (infinite) subset of the set of all possible values, and there are rules for determining how all non-string values are converted into strings.

JScript Classic is a dynamically typed language. This means that any value of any type may be assigned to any variable without restriction. It is often said — inaccurately — that “JScript has only one type”. This is true only in the sense that JScript has no restrictions on what data may be assigned to any variable, and in that sense every variable is “the same type” – namely, the “any possible value” type. However, the statement is misleading because it implies that JScript supports no types at all, when in fact it supports six built-in types.

JScript .NET, by contrast, is an optionally statically-typed language. A JScript .NET variable may be given a type annotation which restricts the values which may be stored in the variable. This annotation is optional; an unannotated variable acts like a JScript variable and may be assigned any value.

JScript has the property that a value can always describe its own type at runtime. This is not true in, say, C, where you can have a void* and no way of asking it “are you pointing to an integer or a string variable?” In JScript, you can always ask a value what its type is and it will tell you.

The concept of subtyping is not particularly important in JScript Classic though it will become quite useful when we discuss JScript .NET classes later. Essentially a type T1 is a subtype of another type T2 if T1’s set of values is a subset of T2’s set of values. A type consisting of the set of all integers might be a subtype of a type consisting of all the numbers, for instance. (This is not how the integers are traditionally construed; the C type system makes integers and floats disjoint types, where the integer 1 and the float 1.0 are different values that happen to compare as equal — but comparisons across types is a subject for a later blog entry.)

Anyway, JScript Classic has six built-in types, all of which are disjoint. They are as follows:

• The Number type contains all floating-point numbers as well as positive Infinity, negative Infinity and a special Not-a-Number (“NaN”) values. It may seem odd that “Not-a-Number” is a Number but this does in fact make sense. NaN is the value returned when an operation logically must return a number but no actual number makes sense. For example, when trying to convert the string "banana" to a Number, NaN is the result. Because numbers in JScript are actually represented by a 64 bit floating point number there are a finite number of possible Number values. The number of numbers is very large (in fact there are 18437736874454810627 possible numbers, which is just shy of 2^64.) Numbers have approximately fifteen decimal digits of precision and can range from as tiny as 2.2 x 10^-308 to as large as 1.7 x 10³⁰⁸.
• The String type contains all Unicode strings of any length (including zero-length empty strings.) The string type is for all practical purposes infinite, as the length of a string is limited only by the ability of the operating system to allocate enough memory to hold it.
• The Boolean type has two values: true and false
• The Null type has one value: null
• The Undefined type has one value: undefined. All uninitialized JScript variables are automatically set to undefined
• The Object type has an infinite number of values. An object is essentially a collection of named properties where each property can be a value of any type. In JScript many things are objects: functions, dates, arrays and regular expressions are all objects.

Types are not themselves “first class” objects in JScript, though they are in JScript .NET. I’ll discuss that, along with the differences between prototype and class inheritance, in later entries.

Notes from 2020

It would be interesting to revisit this series in the context of the TypeScript type system, which is a great example of how rich and powerful a gradually typed language can be. The JScript.NET gradual type system was very simple compared to the TS system!

This series got a lot of good comments from readers. A few highlights from this first episode:

• the typeof operator in JScript bizarrely does not follow the rules of the type system that I just laid out. It identifies null as an object, but does not identify functions as objects, for example. External functions, like DOM functions, may not be identified as functions. It can also return “unknown” in some rare cases.
• Also confusing: typeof(3) is number, but typeof(new Number(3)) is object.
• And also confusing, typeof(this) when called from the body of a user-defined function on the prototype of Number is object.
• A number of inconsistencies and confusions regarding prototypes were also raised; I discuss these in a later episode.
• In the earliest published version of this article I used the terms “strong” and “weak” with respect to the type system, and readers rightly took me to task for that. This was the beginning of a realization that I have since strongly expressed: “strong” and “weak” are so vague that they are meaningless. I haven’t checked lately, but one time when I read the Wikipedia article on strong typing, it listed eleven different contradictory meanings. I’ve since expressed the (strong!) opinion that “strongly typed” simply means “a type system that I admire”. Instead of characterizing type systems as “strong” or “weak”, instead say what properties they really have: what restrictions do they impose, when are they imposed, and in what ways can those restrictions be violated, and what are the consequences?
• Readers similarly noted that “untyped” is vague; it is often used to mean “no restriction is placed on the possible values of variables” (as is the case in classic JavaScript) but is also used to mean “no type system is imposed at all on any values” (as is the case in, say, untyped lambda calculus, where all values are function from function to function; there are no integers or strings at all.)