I love Oliver Steele's work with dynamic languages, and have really enjoyed doing "instance first development" with OpenLaszlo, and miss it now that it's gone obsolete, because I haven't found anything quite like it.
It's about iteratively programming from the ground up, avoiding premature and unnecessary abstraction, smoothly and rapidly developing prototypes into reusable components and working products, and organically growing and easily abstracting only when needed.
I think there's still a lot to be learned from OpenLaszlo and applied to new systems. It would be great to inspire somebody to take the idea of instance first development, and run with it in a modern framework.
Oliver is an old school Lisp Machine hacker, so OpenLaszlo had a very declarative prototypical Lispy feel to it! Another "dynamic language" Oliver created was Dylan at Apple.
OpenLaszlo was a VERY enjoyable system to work with, because of the way instance first development dovetailed with constraints, prototypes, and data binding, that really got me into an extremely productive groove.
Of all the frameworks I've learned about, Svelte seems the most like OpenLaszlo, philosophically. They both have a JavaScript to JavaScript compiler that wires up reactive constraint dependences automatically, for example. But I don't think Svelte has an instance creation syntax that parallels its class definition syntax, to enable the "instance substitution principal" that supports instance first development: An instance of a class can be replaced by the definition of the instance, without changing the program semantics.
Oliver Steele describes "Instance First Development", which the language he designed, OpenLaszlo, supported through the "Instance Substitution Principle". I've written about it here before, and here are some links and excerpts.
In the right context, prototypes can enable Instance-First Development, which is a very powerful technique that allows you to quickly and iteratively develop working code, while delaying and avoiding abstraction until it's actually needed, when the abstraction requirements are better understood and informed from experience with working code.
That approach results in fewer unnecessary and more useful abstractions, because they follow the contours and requirements of the actual working code, instead of trying to predict and dictate and over-engineer it before it even works.
Instance-First Development works well for user interface programming, because so many buttons and widgets and control panels are one-off specialized objects, each with their own small snippets of special purpose code, methods, constraints, bindings and event handlers, so it's not necessary to make separate (and myriad) trivial classes for each one.
Oliver Steele describes Instance-First Development as supported by OpenLaszlo here:
1 comment
[ 2.7 ms ] story [ 13.4 ms ] threadhttps://en.wikipedia.org/wiki/OpenLaszlo
It's about iteratively programming from the ground up, avoiding premature and unnecessary abstraction, smoothly and rapidly developing prototypes into reusable components and working products, and organically growing and easily abstracting only when needed.
I think there's still a lot to be learned from OpenLaszlo and applied to new systems. It would be great to inspire somebody to take the idea of instance first development, and run with it in a modern framework.
Oliver is an old school Lisp Machine hacker, so OpenLaszlo had a very declarative prototypical Lispy feel to it! Another "dynamic language" Oliver created was Dylan at Apple.
https://en.wikipedia.org/wiki/Dylan_(programming_language)
OpenLaszlo was a VERY enjoyable system to work with, because of the way instance first development dovetailed with constraints, prototypes, and data binding, that really got me into an extremely productive groove.
Of all the frameworks I've learned about, Svelte seems the most like OpenLaszlo, philosophically. They both have a JavaScript to JavaScript compiler that wires up reactive constraint dependences automatically, for example. But I don't think Svelte has an instance creation syntax that parallels its class definition syntax, to enable the "instance substitution principal" that supports instance first development: An instance of a class can be replaced by the definition of the instance, without changing the program semantics.
https://svelte.dev/
Here's some stuff I recently (and not so recently) posted about OpenLaszlo (with some broken links fixed):
https://news.ycombinator.com/item?id=22025026
Oliver Steele describes "Instance First Development", which the language he designed, OpenLaszlo, supported through the "Instance Substitution Principle". I've written about it here before, and here are some links and excerpts.
https://news.ycombinator.com/item?id=14418108
In the right context, prototypes can enable Instance-First Development, which is a very powerful technique that allows you to quickly and iteratively develop working code, while delaying and avoiding abstraction until it's actually needed, when the abstraction requirements are better understood and informed from experience with working code.
That approach results in fewer unnecessary and more useful abstractions, because they follow the contours and requirements of the actual working code, instead of trying to predict and dictate and over-engineer it before it even works.
Instance-First Development works well for user interface programming, because so many buttons and widgets and control panels are one-off specialized objects, each with their own small snippets of special purpose code, methods, constraints, bindings and event handlers, so it's not necessary to make separate (and myriad) trivial classes for each one.
Oliver Steele describes Instance-First Development as supported by OpenLaszlo here:
Instance-First Development
http://blog.osteele.com/2004/03/classes-and-prototypes/
[...]
A showcase of shard-db. Data from the Hacker News API. Refreshed every 15 minutes.
Source · Live DB stats