Lambda the Ultimate

I was then rebuked (by Felleisen or Friedman, I think) for not realizing that not only does this make static typing a bit of a problem, it is almost certain to lead you to undecidable type systems.

The important distinction is between the static universe of types, and the dynamic universe of values (see sk lecture notes).

However, I'd guess that typed languages with rich macro facilities (Ocaml), must provide mechanisms that allow you to do something similiar to what you had in mind.

Ocaml has a notion of "polymorphic variants" which, in very sharply limited ways, appear to be something like extensible types. This is not run-time extensibility, though. It's more of a modularity issue; when you define a new type you can add constructors to a previously existing variant type (or so I think; the documentation is not easy to understand).

I see what you mean about decidability. However, if you're willing to allow some runtime type errors, you can get away with a lot (he says, not really understanding all the issues involved...).

OTOH this highly dynamic environment makes it possible to more accurately model some domains, e.g. XML objects. That is, a domain that contains objects whose structure is also only known at runtime. While other languages do provide tools to model such domains, such as associative arrays, the JavaScript approach makes it very natural.

(Hack n - Something cool. Not a vague reference to the Curry-Howard isomorphism)

The definition of a type is an interesting one. The historical meaning is something like "an interpretation of a bunch of bits". Hence we can say Scheme is strongly typed: you can only provide one interpretation to a bunch o' bits. To the static typing guys types only exist at compile time, so Scheme is untyped. In this framework you can't talk about generating types at runtime.

From a Smalltalk perspective, types are not defined as bits of data. Rather the type of an object is defined by the messages that it can process. Need to create a new type? Just create a new object and attach message receivers to it - simple as that.

One example is an object that represents a database records. Most languages and libraries I'm familiar with (ODBC, JDBC, OLEDB, ADO, etc) utilize some sort of standard record container that exposes generic facilities to get at fields (BTW such facilities often invalidate the static type checking of the host language because the field type can only be tested at runtime). VB goes as far as to introduce a special operator to access field content:

record!field-name

With JavaScript you can simply access fields as properties on a record object:

record.field

or

record["field-name"]

Another scenario I can think of is an object that models a state machine. The object exposes methods that match the functions available at the current state. As the state changes, so do the methods. This is especially compelling if the structure of the state machine is only known at runtime.

Obviously there are solutions for these types of problems using statically typed languages. But many such solutions in effect mimic the dynamic types that JavaScript has (using such constructs as variant containers and associative maps).

BTW I've done my share of hacks in JavaScript (BeyondJS is case-in-point :) Many of these hacks had to do with self-modifying code and code generated on the fly.

Another BTW, some intrinsically static environments let you generate types on the fly, although it's a lot more work.

I'm currently also hacking a new module in the Beyond library that implements multiple-dispatch. Its allows you to dispatch on an arguments "type" (its basic type or constructor function), prototype and the availability and type of a property. While this is obviously not the same as static type checking, it does assist in the sense that it makes it easier to write code so that at a specific point you know the object provides the required functionaility.

BTW here is a hack that utilizes self-modifying objects for a bit of improved performance:

X.prototype.calcValue = function() {
    var value = some complex calculation;
    X.prototype.calcValue = function() {
        return value;
    };
    return value;
};