Intentional tool released

apparently Intentional finally shipped.

Martin Fowler's overview.

Download video presentation via MSDN.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

How about becoming a

How about becoming a contributing editor and posting directly to the home page?

sincere thanks for the offer

though to be honest i'm too much of a shrinking violet for that. not trying to fish for complements, just honestly not comfortable with it. :-)

No pressure.

No pressure.

Academic work on Structured Editors

This seems related to academic work on structured & bidirectional editing such as:
Hu, Z., Mu, S., and Takeichi, M. 2004. A programmable editor for developing structured documents based on bidirectional transformations. In Proceedings of the 2004 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (Verona, Italy, August 24 - 25, 2004). PEPM '04. ACM, New York, NY, 178-189. DOI=

Or the Boomerang & Harmony projects.

I think these topics should be of interest to LTU readers in part because they provide an interactive way for an editing environment to develop what amount to abstractions interactively. E.g. by distinguishing between copies of a subtree and duplications of it (whose edits will remain linked together) one distinguishes something similar to C(A(X),B(X)) from (\x -> C(A(x),B(x)))(X), in which upper-case letters refer to editable material and the lambda-abstraction is just to symbolize the linkage.

For reference here are some related LTU threads:
Abstractionless Programming
Intentional Programming
Bidirectional programming

I wonder what other readers think about these connections.

i wonder what the base abstraction is?

for example, .net has been criticized for saying "oh we support different languages" when perhaps in fact the different languages are forced to be similar: witness the VB debate, or the hurdles for Eiffel .net.

so since it sounds like Intentional programming has a core representation of languages, and then projects out to concrete syntax of Ruby or C# etc., i wonder how restricted it all is due to any missing features of the core representation? e.g. i doubt they can project to full-featured Haskell.

(i don't mean that makes Intentional useless, i'm just curious about the limits of it.)

The intentional tree?

My understanding was that they munged all the different data models down into the same document, the intentional tree. Something feels wrong about this, although it's hard to put my finger on what exactly. I think I prefer to think of each domain being a separate algebraic that when you want a hybrid view, you create a new domain that explicitly combines the domains you want to munge together. In practice it may not be much different from the intentional approach, but perhaps less ad hoc "under the hood".

I'm not sure what the meaning of a giant heterogenous intentional tree is. Is each node type equipped with its own semantics?

I can imagine that you could tie yourself in some knots with all the different views and transformations, but that feels like essential complexity, in a way. With some clever process (and tool) engineering it should be possible to be more constrained most of the time. All that popping up of meta-levels blew me away...

Overall, impressive but its significance ultimately boils down to how general it all is - i.e. how it works, not whether it works.

Still in stealth mode?

As Fowler noted there is no announcement on the website and you have to contact them to get....something?

Anybody have any info on whether they're going to put out a demo?

Not stealth, but limited

They have "shipped" to Cap Gemini, Thoughtworks (presumably more for analysis than actual line production) and perhaps one other. The demo at DSL DevCon was eye-popping and much more advanced over previous demos they've given, but they're not ready to make the product broadly available.

They invited people interested in working with the product to "contact them." Presumably you'll discuss your scenario, expectations, be vetted by them (there's got to be a huge learning curve to use the environment), and go from there.

You have bits or not

in 2009 if you wanna be a player you put some bits out or you have something that totally kicks ass

screw open source, but just throw a bone out...especaally for us excell(how can we do better)

Well, just to mention this.

Well, just to mention this. I've seen a quite elaborated demo presentation of the Intentional software on ECOOP 2001 presented by Mr. Charles Simonyi. So they are cooking it for about a decade and more.

The response of the conference participants was quite comparable: "where is the semantics"? However I wouldn't underrate the replacement or augmentation of parse trees by those DAGs ( "Intentional Trees" ) and editing the latter in the first place. We've seen that Lisp syntax is deep at the surface and I'd expect that Intentional is just probing the next step in this direction.

Ya, we've seen the demos and

Ya, we've seen the demos and heard the talks, but Intentional Software seems to be turning out to be the Duke Nukem Forever of PL. I hope when it finally comes out its not just a niche product but something revolutionary.

we"ll see what mps has to offer

but i wanna hear what dm and zboe hav to tsay about this.....sinc thy hav too much tim on tir handsd

Related and informative article

It is a strange coincidence that I happened to read the Language Workbenches article by Martin Fowler just yesterday. I would recommend it to anyone who wants to get an idea of what this tool means but doesn't understand it yet. There's even a small section devoted to Intentional Software.

See LtU discussion here.

See LtU discussion here.

Computability versus Logic

There's some good stuff in there, though I think that their focus is a little bit off. My experience with agile development, working with domain experts, making DSLs and so on has been that language syntax and typing things into a computer is not that big an issue, and I think that this is borne out by the hundreds of thousands or possibly even millions of "non-programmers" all over the world who daily program in Excel.

The big problem I've encountered, and they refer to it directly and indirectly a couple of times in the presentation, is teaching the domain experts to specify things with rigour, and to face up and deal with their logical issues rather than ignore them.

In other words, as in their quote from Grace Hopper (in the separate slides, not on the video), "Anyone who can state his problem logically can write a MATH-MATIC program for it." Those of us with experience in this area understand that statement to mean, "the common, untrained person can't use it without professional help."

When they thus state, "Domain representation does not need to be computable" (which I don't think that they truly believe), my reaction is that a) non-computability will not make teaching domain experts about how computers are going to deal with their problem any easier--it's just not so difficult to train them to deal with current "computable" languages appropriate to the situation, and b) non-computability is actually quite harmful to the whole project, because it lets domain experts leave resolving conflicts in domain logic to the programmers. They implicitly admit this themselves about 35 minutes in when they demonstrate error checking, tests and debugging of domain logic aimed at having the domain experts themselves deal with this.

And yeah, the question that really gets to the core of all of this is, "where are the semantics?" I get the feeling that they're on a much longer and slower version of the same path that Robin Milner trailblazed in the 1970s, and with less chance of such stunning (albeit little-known in the commercial world) success.

rings true

i work on a video game that has a scripting system, and the folks who are writing the scripts are to be felt sorry for. they just want to do X but in reality that means you have to watch out for a bunch of edge cases that are just because (a) logic is hard but also (b) programming is hard.

would that there were a way to help bridge that natural language to logic gap. the only thing that springs to mind would be some kind of star trek interface that would take what you said and then spit back all sorts of examples of how foobar that idea is, and let you refine it iteratively to get to something somewhat water-tight.