Program your Intentions

Programmers spend days understanding the requirements and needs for building

a software solution for an organization. They interact with business domain

experts like financial analysts, HR personals, or marketing managers to

understand what they need and try figuring out the specific business

functionalities required to build the software solution. Despite all these

efforts, the software solution doesn't come out as desired by the domain

experts, mainly due to the fact that the programmers have to convert the domain

expert's knowledge into their own programmatical knowledge to build the

software. Now suppose the domain experts have the liberty to design the software

solution as per their needs and the software solution reflecting the exact

intentions of the domain expert who designed the solution, then the whole

concept of Intentional Programming (IP) is achieved. With IP, the domain expert

can use his expertise in form of graphical representations to define the logic

of the tasks for the application.

What is Intentional Programming?



Intentional Programming was a research project led by Charles Simonyi at

Microsoft, until early 2001. Later Simonyi found his own startup company

'Intentional Software Corporation' in year 2002, which was focused on making

software based on his concept of IP.

Simonyi wanted to develop upon the concept in which the programmers could

concentrate more on capturing the intentions of the computer users rather than

fiddling with source codes, programming syntaxes, etc. The intentions are the

expectations of the business users of an organization for what an application

has to perform. The programmers work in tandem with the domain experts in

determining these intentions that the software application must possess. The

idea of intention is the representation of the 'intent' of the programmer of how

the code for a particular application has to function, and how these 'intents'

are viewable to programmer in the language of his choice. And as we know, it's

the source code that we use to view, edit, and save changes to the intents. It's

the source code of all the programming languages that is represented as text,

and where symbolic names are given to all objects, variables, and tasks. IP

extends upon this idea of direct representation of task to source code by

introducing an intermediate language as the standard representation of the code.

This means the programmer can design or envisage his intent for an application

in a standard language but its executable code can be viewed in any of the

programming languages.

IP at Work



As we are already familiar with 'What You See Is What You Get'

(WYSIWYG)-based software like text editors, GUI designers among others where the

WYSIWYG software lets the computer users to manipulate and design the appearance

on screen without having to master the underlying code for the software. On same

principles, the IP facilitates the computer user to express needs in his own

familiar language using the domain workbench, then allowing the comprehensible

views of the emerging design before assembling the executable code. The Unified

Modeling Language (UML), developed in mid 1990s at Rational Software, too relied

on philosophy of graphical representations to represent a program's function,

structure, and behavior. Unlike UML diagrams that cannot be converted to

finished products, the IP-generated representations can be transformed to

finished products.

Using workbench, the Domain Experts design the domain code, which is used by programmers to build the language-specific generators for execution

Intentional Programming is similar in concept to WYSIWYG processing programs.

It's a collection of concepts that enable software's source code to reflect the

precise information termed as 'intention', which a programmer had in mind while

building any software solution. The IP process starts when the programmer

defines a proposed application's intended functions through a WYSIWYG format

interface. After that an automated system utilizes this information for

generating the final software product. The WYSIWYG interface that the programmer

uses in the IP concept is called as domain workbench.

The domain experts are presented with an interface where they put along the

various components to represent the detailed functioning processes of the

software application, as per their intents. And this 'domain code' created by

domain experts using the domain workbench is like a flowchart that represents

how the actual user screen will look like and what is the formal logic

associated with it. This way the domain experts are able to conceptualize their

intentions into real-time applications that the business users will be

accessing.

The programmers now come into picture who will, depending on the 'domain

code', create the program generators that will be used for manufacturing the

actual target code that the computer will be able to compile and execute. If the

final software product does not perform as per the requirements, the programmers

can again work with the domain experts on the domain workbench for redesigning

of the software. This way the domain experts and the programmers can fiddle with

their visualizations of the application until the desired domain code is arrived

upon for generating the final target code for the application.

Advantages of IP



Intentional Programming has few great advantages over conventional programming.
One is that the people who design the program are those who have the complete

understanding of the task and its functioning that is needed to be automated.

Thus, there is no mismatch of functioning of the product when the programmers

come out with the final product. Second, the design and the layout of the app

can be manipulated simply and easily. This eliminates the scenario where in a

simple change for text-based code, one had to go through thousands of lines of

codes. But as in IP, every task is represented in graphical manner, the change

in part gets reflected to whole of the program. Also the programmers have to

focus on application generator part only to build the executables for the

application, resulting in reduced bugs and errors in the app. Thus, with IP, the

programmers will be able to focus more on detailing of meeting the computer

users' intentions rather than meeting and coding the computer hardware

requirements.

With its advantages, IP has supporters in the software industry as it

addresses real and critical issues being faced by the programmers. But at

Intentional Softwares, Simonyi is in no hurry, as of now, to come out with a

product, but has showcased some demos of the concept and that does show that the

future has some innovative programming change to witness alongwith narrowing the

rift between the programmer's understanding and domain expert's requirements.