Thanks! I was thinking of dropping that into the post as an example of the late-binding philosophy going into the future, but I've been linking it quite a bit lately, and decided to go without it for once.
In my view of it, Piumarta's COLA is very strongly "of The Lisp Philosophy". As a matter of fact, I would call it the future of Lisp (the philosophy) :)
When things are truly late-bound, it makes as little sense to split computational instructions into these "language" silos. Allowing users (and creating tools) to modify syntax is fundamental to breaking this tribal idiocy around "languages" as atomic sets of programming system design decisions.
@When things are truly late-bound, it makes as little sense to split computational instructions into these "language" silos.
I can't understand you. Can you rephrase?
@Allowing users (and creating tools) to modify syntax is fundamental to breaking this tribal idiocy around "languages" as atomic sets of programming system design decisions.
It's far from tribal idiocy, and has more to do with modularity and substitutability. Most programmers do not realize what heights of engineering .NET|Mono, the JVM, Smalltalk, Symbolics Genera all are. .NET's MSIL, in particular, is the most modular stack-based assembly language I know of... especially version 2. It's pretty impressive once you realize you can specify modules at the assembly level. Granted, even in the '90s people were designing typed assembly languages, like TAL/T, which supported run-time code generation and could be certified for safety at compile time, link time and run time.
Really, I think talking about "not an acceptable Lisp" in broad strokes undermines attention to good engineering and striving to be great engineers.
>> @When things are truly late-bound, it makes as little sense to split computational instructions into these "language" silos.
> I can't understand you. Can you rephrase?
Oops, think-o, that should have said "it makes as little sense to split computational abstractions into these language silos".
To clarify: there are "languages" like Haskell/Ruby/Python/Java/C that make an enormous number of decisions about the kinds of abstractions we use to describe what it is a computer is to do. A "language" is a set of decisions about syntax, type systems, functional or object-oriented abstractions, memory allocation and garbage collection, call stack traversal. If one decides to compile to a VM instead of machine code, that introduces another set of variables - from JIT compilation techniques to the kind of VM specifications you publish (do you publish a reference VM like Squeak, or a bunch of papers and tests like the JVM). "The Java language" is a set of hundreds of those kinds of decisions. So is "the Python language". Comparing the two is really difficult, because for almost any problem, some subset of Java's decisions will be better, while another subset of Python's decisions will be better. But these sets of decisions aren't atomic (they can be split!).
Every time you late-bind a decisions to the user, it removes a dimension from the decision space that the "language" lives in. It expands the power of the language to span that entire dimension. Hence, the most powerful language is one that makes the most irreversible decisions.
talking [...] in broad strokes undermines attention to good engineering and striving to be great engineers
That sounds right, and I should avoid it if it's needless. However, it's also important to always try to unify concepts to simplify our models of things. The important thing is to make sure the simpler model is just as accurate.
The hallmark of COLA is recursive design, which sort of makes it more like Smalltalk than Lisp (but this is a fruitless point, and the key is to encourage you to dig deeper into what COLA is rather than what "it's like...").
The hallmark of COLA is recursive design, which sort of makes it more like Smalltalk than Lisp
Late binding is certainly a big part of the smalltalk philosophy as well, and recursive design is a great way of implementing late binding. A system uses the same "user interface" internally, it certainly makes it easier to let people modify the internals.
The big difference I see between Smalltalk and Lisp (correct me if I'm wrong) is that Lisp systems tend to use compile-time abstractions Lisp->machine code->execution, while Smalltalkers from early on started thinking about interpretation and VM's - using abstractions which require run-time data to make decisions.
It depends who you ask what the big difference b/w Smalltalk and Lisp is.
Model-driven architecture weenies like me will tell you the biggest difference is methodological, and that real-time object-oriented systems engineering has its roots in most of Kay's ideas.
I'm not sure what you mean by the following:
@Lisp systems tend to use compile-time abstractions Lisp->machine code->execution
I don't think so. The whole reason I enjoy Lisp is for how it has inspired me to do streaming models of compilation. When you're updating things dynamically, the most important thing is to have a logical object model - starting with getting your "(UML) package diagram" correct. Otherwise you end up with a large system that requires the entire system to be locked up for minutes while you do the upgrade, because different parts of the system depend too much on physical model details. That's why you separate message from method. So you can do this in any language, some easier than others.
linky: http://piumarta.com/software/cola/
Thanks! I was thinking of dropping that into the post as an example of the late-binding philosophy going into the future, but I've been linking it quite a bit lately, and decided to go without it for once.
In my view of it, Piumarta's COLA is very strongly "of The Lisp Philosophy". As a matter of fact, I would call it the future of Lisp (the philosophy) :)
When things are truly late-bound, it makes as little sense to split computational instructions into these "language" silos. Allowing users (and creating tools) to modify syntax is fundamental to breaking this tribal idiocy around "languages" as atomic sets of programming system design decisions.