Language-oriented programming : an evolutionary step beyond object-oriented programming?
An "evolutionary step" certainly...
... A *new* way of thinking, certainly not! Martin fowler were already speaking about Language Oriented Programming 2 years back after JetBrains became one of the rare company to give a suite using LOP. Unfortunately 2 years ago it was a failure maybe today spirits are more ready for that... (see When visionaries are too much in advance)
According to Wikipedia
"Object-oriented programming roots reach all the way back to the 1960s" "It was not commonly used in mainstream software application development until the early 1990s. Many modern programming languages now support OOP." Smaltalk's Development started in 1969,Publicly available in 1980... So all of that is just to say that mainstream's adoption of paradigms is slow in manyear unit. Just now, java and .net are adopting functional programming features like closures, that has been there for ages. I don't guess LOP adoption is the worst case.
The *new* was for the *new mainstream's* because as you mentioned, mainstream's behavior can't be anticipated.
Martin Fowler writes about concepts that are coming to the fore in enterprise development, I don't think he is a researched uncovering new concepts (nor does he claim to be).
Re: ... at least three major vendors offering this kind of tooling ...
Maybe not "major" vendor, but more advanced than the other three.
REBOL was first released in 1997.
-- It uses "relative expressions" (context dependent dialects) to create a powerful new dimension similar to that found in natural human languages.
-- REBOL introduces the concept of dialecting. Dialects are small, efficient, domain-specific languages for code, data, and metadata.
Certainly, I think it's very interesting to see the development of DSLs in Ruby, simply because it's a language that's well-suited to DSLs. Unfortunately, so far it also seems to be a language that's relatively resistent to tooling. ;)
I'm sure there'll be progress on this front, but I don't think a breakthrough is just around the corner, either.
DSLs are important
While the real language workbenches (and Eclipse's GMF belongs in this category as well) might be ultimate in LOP IDE, approaches like xText (Stratego/XT is another example) seem to scratch my DSL itch best today.
Joost de Vries
As a result I'm not interested in Fowlers 'visionary' tales until good Language Workbenches become widely available.
Joost de Vries
Actually I was very jealous of my Microsoft oriented colleagues working with DSL-Tools.
I looked into finding a Java oriented equivalent.
I got the impression that GMF is the bare bones framework with which someone could build a Language Workbench. Such as Borland, IBM and Markus Voellter have done.
I looked into Openarchitectureware but frankly found the learning curve to steep for perusing the technology while not being able to use it in a project.
I've heard about MetaEdit. Apparently they have been around for a long time.
I had never heard of xText. So thanks for the link.
Is this just for a new buzzword?
The talk does throw out a few non-orthodox but unjustified claims (or they don’t bother to justify them?), such as:
“For the past 20 years or so, we have been trying to model the world with trees. That is the way we model the world in object-oriented languages is build hierarchies, trees, trees of how we model things in code and it turns out that that works out pretty well because most of the world is tree shaped. Most of the world is hierarchical. You can fit things into trees pretty easily but that abstraction breaks down sometimes because a lot of times, we try to model the real world. We model it like this with a nice tree abstract picture of trees, and of course this is idealized. This is not the way the world really looks. The world really looks like this, tangled branches and interconnections and all sorts of other things that are really, really hard to model in these kind of idealized pictures. So what we have been trying to do is model the world with hierarchies but hierarchies fall down at some point and so we invent things like aspects.”
First, they didn’t rationalize why OO is merely about “model the world with trees and/or … build hierarchies.” A plain and obvious fact is that OO programming languages such as C++, Java do not enforce trees and hierarchies other than the inheritance based class extending. For general cases, nothing in these OO languages discourages models and structures of non-tree/non-hierarchy and vice versa. Widely observable from microscope level abstractions (such as linked list) to marcoscope level system designs on UML object diagrams, in the past 20 years, people have been modeling with non-trees/non-hierarchies no less than the opposite.
The argument of
“hierarchies fall down at some point and so we invent things like aspects”sound like to say “the file directory tree structure model fall down, and so we invent things like directory/file access control, monitoring, event triggering and logging”.
Second, DSL folks never claimed that increasing expressiveness of a language for a specific problem domain was contrary to abstracting by hierarchies and modeling with trees. This argument should be the only important new idea in their talk they could safely claim to be their credit, if it could be justified. However, as giving no evidence on their claims of OO discourages modeling with non-trees and non-hierarchies, they did neither bother to justify why designing and using domain specific language grammars are contradictory to modeling with trees and building hierarchies.
It is pretty common that DSL grammars, especially declarative DSL grammars (schemas) are defined by their schema trees. An example is defining DSLs using LISP defmacro. An important concept in LISP is “data is code, and code is data”. Therefore, the new DSL schema defined in by a defmacro is effectively expressed in a s-express (data) tree. Therefore, contrary to their claims, tree expressions is not only applicable in defining DSL grammars but also helpful in DSL abstractions. Here, modeling (data) trees is exactly modeling (code) grammars. This makes LISP one of the most effective DSL environments.
Besides an individual DSL grammar tree, the inheritance and hierarchies are also applicable and significant in DSL grammar abstraction and reuse. A desirable DSL environment should not force all DSLs to be defined from scratch (including copy-paste) but support extending grammars/schemas by inheritance (and therefore grammar hierarchies) and semantic overriding (change the semantics of a syntax in the child grammar). Pocomatic is going to release an open source DSL/DSM framework that supports this inheritance as well as containment based schema extending and reuse. The product is going to be shipped with dozen or so DSL/DSM examples (also in open sources). These DSLs/DSMs are extended (using inheritance or containment) either from the core (root) schema or from other extended schemas and therefore present a DSL grammar hierarchy tree.
Version 4.2 of openArchitectureWare has just been released and its documentation set includes a great bunch of videos that should help you get up to speed as possible. Personally, I found oAW much, much easier in getting some actual stuff done than with Software Factories or GMF (or with AndroMDA for that matter).
JetBrains MPS is DOA.
Microsofts Software Factories are fundamentally flawed (they don't even support iteration in their gen to "create one DAO per business object" or similar which is a baseline requirement - there is a work around, but it is messy. I'm looking forward to 2.0.
Anyone serious about LOP should also check out MetaEdit+ by MetaCase - they have a very smart team and an interesting system.
For anyone into all this, also check out the Code Generation conference in the UK (www.codegeneration.net/conference/index.php) as well as SPLA and Models.
Ben Linders May 28, 2015