
Intentional Software raises the curtain - gfodor
http://martinfowler.com/bliki/IntentionalSoftware.html
======
extension
Assuming this actually exists and mere mortals can one day get their hands on
it, I predict that at best, it will eliminate some of the boilerplate
gruntwork common in enterprisey programming and at worst, it will just be
another over-engineered FactoryFactoryFactoryFramework productivity killer
with an aggressive cult following.

I understand the concepts involved and they are sound, but as with any pie in
the sky invention, the devil is in the details. Until they show us how they
handle those details, they don't really have anything to say.

~~~
wlievens
I'm not sure. If you do this the right way, you could build a Smalltalk the
way it should have been. And that's not really an over-engineered enterprisey
thing by itself is it?

~~~
vorador
What do you mean by "the way it should have been" ?

~~~
wlievens
Smalltalk (at leas the flavor I used) stores code as a data structure rather
than plain text. That same idea is at the core of the language workbench
concept Fowler is championing. What the language workbench concept adds to
that is that you can render and edit your "code" data structure in a multitude
of languages. That includes graphical flow languages, for instance. One could
take Smalltalk and take it to this step, too.

I agree that right now it all looks like slideware, but I do think the concept
has merit.

------
ntoshev
I understand the concept of intentional programming in this way:

1) start with Lisp, complete with macros

2) add multiple skins: some of them are basically a C-syntax representation of
the program, some might be visual programming (connecting diagrams or
spreadsheet-like), they can be of different level of abstraction and can be
mixed freely. Remember, lisp macros pretty much do this, only they are
constrained to S-expressions while intentional programming should be freely
skinnable.

3) they claim the result is great

If it is, I'd be surprised. They developed it for what, 10-15 years, without
showing it to the public, and even without using an axiomatic approach (they
didn't start from Lisp, they started from C and built APIs to manipulate the
syntax trees).

The most important things about their system:

\- how easy would it be to build new abstractions in this environment

\- how easy is it to mix and match abstractions developed independently and
unaware of each other

\- how comfortable are hackers with the requirement for heavy supporting tools
from a single vendor

Early previews don't really say much about these points.

~~~
plinkplonk
One of my friends was working at Intentional on this very system and after he
raved about it for a while, I said "this sounds like an MVC implementation
with an Abstract Syntax Tree being the model and the various"projections" (or
whatever the terminology was - I forget - it has been a few years) being the
View. Did I get the idea right?". He was a bit deflated but said "yeah that is
what it is " and changed the topic.

------
danbmil99
Is this article in English? I don't have a clue what in the world they are
talking about.

Why does everyone assume the whole world understands the hyper-specialized
jargon of your little garden patch of intellectual pursuit?

~~~
danbmil99
Checked out IP in Wikipedia. Not only do I understand it, I'm fascinated by
this approach, and have fiddled with similar ideas for years. Yay wikipedia!

------
tumult
I read the article, watched some of the presentation, and I still don't know
what this is supposed to be. I don't think they do, either.

~~~
extension
Imagine you are contracted by a circus to write some custom software to manage
their operation. The software has to do things like track the length of the
bearded lady's beard, find the best deal on insurance for the sword swallower,
calculate the trajectory of the human cannonball, and of course cross-
reference everything to generate insightful reports.

You start by grilling the customer until you have a full understanding of how
the whole operation works (aka the "domain") and exactly what the software
needs to do (requirements).

You could then take the fast and dirty approach which would be to just hard-
code the requirements, hand it to the customer and run. You would probably
write a lot of code that you feel like you've written a million times before,
but this case is just different enough that you can't reuse anything, so a lot
of time and money is wasted writing redundant code. And hopefully, you'll be
over the horizon by the time the bearded lady decides to grow a moustache and
they want to track that too, because your app doesn't do that.

If you want to be all innovative and outside the box, you might make a DSL
called ClownML to describe circus management workflows:

    
    
      attraction AmazingGeorge {
        type = HUMAN_CANNONBALL
        weight = 85kg
        distance = 100m
      }
    
      attraction LovelyLucy {
        type = BEARDED_LADY
        hair_types = [BEARD,MOUSTACHE]
        hormone_level = 7
      }
    
      preshow {
        check Cannon.pitch == AmazingGeorge.required_angle
        check LovelyLucy.beard_length >= 3 feet && LovelyLucy.moustache_bushiness >= 2 furlongs
      }
    

Now the customer, without the aid of a programmer, can use this simple,
intuitive language to adapt your application to their changing needs. Of
course, they won't actually touch this "code" with a ten foot pole, but at
least _you_ can use the language to make maintenance easier on yourself.

But wait, now they want to launch someone out of a catapult instead of a
cannon and ClownML doesn't have a catapult type. They also want the person
they launch to be Lovely Lucy and that's an even bigger problem because having
the same person be two different attractions is not even expressible in
ClownML. You go back to the drawing board and create ClownML 2.0 which has
classes, inheritance, polymorphism, lambdas and syntactic macros. There is no
conceivable requirement that could not be expressed in this language.
Unfortunately, you've simply wasted a huge amount of time inventing a general
purpose programming language which is twice as verbose and half as powerful as
Ruby or Python and looks like Perl on acid.

The circus fires you (out of a cannon) and hires Charles Simonyi. They pay him
$100M, he hands them a copy of Domain Workbench and blasts off to Neptune in a
Russian rocket, never to be seen again.

The circus ringleader sits down with Domain Workbench and using [intuitive
interface X], describes the general domain of circusology, much as he
described it to you. Using this input, the software generates an abstract
language which can describe circus management applications in a very concise
way, much like you tried to do. The language is abstract in that it has no
single concrete representation. Rather, it can be represented, and edited, as
text, tables, diagrams, trees or graphical morphing hypercubes. The ringleader
chooses his favorite representation, one which is intuitive and non-
programmery, and uses it to implement his specific requirements. If he later
finds that he can't describe something in circusology language, maybe because
the very nature of his business has changed, he can go back to [intuitive
interface X] and quickly alter the definition of circusology language just
enough to accommodate that change, without breaking his existing code.

Exactly how the things in the previous paragraph work, Intentional Software
has left as an exercise for the reader. If they are to be believed, they have
it all figured out and have just been waiting for the right time to fill the
rest of us in, for the last decade or so.

------
JesseAldridge
The twitter comments make this sound like a pretty big deal:

* @pandemonial Quite impressed! This is sweet! Multiple domains, multiple langs, no question is going unanswered

* @csells OK, watching a live electrical circuit rendered and working in a C# file is pretty damn cool.

* @jolson Two words to say about the Electronics demo for Intentional Software: HOLY CRAPOLA. That's it, my brain has finally exploded.

* @gblock This is not about snazzy demos, this is about completely changing the world we know it.

* @twleung ok, the intellisense for the actuarial formulas is just awesome

* @lobrien This is like seeing a 100-mpg carburetor : OMG someone is going to buy this and put it in a vault!

------
henning
Hopefully this will wind up being more than another good idea that never
catches on, or takes 40 years to catch on.

------
snprbob86
Is there a video or demo link buried in all that text somewhere? I'd really
like to SEE this thing...

~~~
hsuresh
There is a presentation here ->
<http://www.infoq.com/presentations/intentional-software> . I haven't watched
it yet though :)

~~~
JesseAldridge
This is an old presentation, not to be confused with the one Martin is talking
about.

