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.