Suppose you have the following piece of code in an arbitrary language X:

plus(1, 2);

This code calls a function "plus" with parameters 1 and 2, which adds the two parameters and returns a result (3). If the language has dynamic properties and lets you write code like this:

plus(a, b) = { return a + b; }

you have two options when compiling the code. The first one is to use a static symbol table and resolve a symbol "plus" like any other language would: simply look for a prior definition of "plus" and use that. The second option is to do a runtime lookup into a symbol table to find out what the value of symbol "plus" is at the point of execution. This has a benefit of being able to redefine symbols at runtime but with an obvious downside: every time a symbol is encountered a runtime lookup must be performed. Assuming we're not dealing with extraordinary JITting technologies that will go back and rewire all calls to "plus" every time "plus" is modified at runtime, which method would you prefer? Why? I'm currently in the process of making a decision and I'd like to see some discussion on the topic.

Well, depends, as long as the language ends up in a semi compiled state, then doing a runtime lookup wouldn't be all that costly, and would add a very interesting to play with feature. Although, I doubt I would be redefining plus :P

So, I would guess that my vote is for the later.

I think it should do both, depending on when it's appropriate. Perhaps specifiying it like you specify a virtual function, indicating that the actual function is to be determined at run-time. Or perhaps, having default to static as long as so situation is setup where it's impossible, then do it run-time. Although the latter method is much more difficult, if not impossible, and probably prone to side-effects. Personally, I think the language should always let the programmer decide.

Well, let me put it this way. Ever since learning Caml, I've found it quite annoying to write in any language that didn't have closures (never mind that it has a positively beautiful standard library).

Sure, you could implement a lookup table that lets you remap global function names to specific calls. In C, it would not be that hard. But it would be very lightly troublesome because of typecasting issues. A macro could be constructed, however, to half-wrap this.



Now, would you want to? Not really, for any purpose other than virtual machines, interactive-parsed languages, and scripting. There are cleaner solutions for everything else.