Fil 's Bookmarks tagged intentionality →  View Popular

See also





• Programming paradigms


• Code generation


• Object database


• Artefaktur (AAL)


• Abstract syntax tree (AST)


• Language syntax tree (LST)


• Semantic resolution tree (RST)


• Interpretation syntax tree (IST)


• Code generation syntax tree (CST)


• Domain-specific programming language







References





1. ^ "Simonyi itched to take his idea out of the lab and put it in front
   of customers, but that was awkward under the circumstances. He explains, "It was impractical, when Microsoft was making
   tremendous strides with .Net in the near term, to somehow send somebody out from
   the same organization who says, This is not how you should do things--what if you did things in this other, more disruptive
   way?""[1] (Quote
   from "Part II: Anything You Can
   Do, I Can Do Meta: Space tourist and billionaire programmer Charles Simonyi designed Microsoft Office. Now he wants to reprogram
   software.", Tuesday, January 09, 2007, Scott Rosenberg, Technology
   Review.)







External links





• Intentional Software - Charles Simonyi's
  company


• The Death Of Computer
  Languages, The Birth of Intentional Programming, a technical report by Charles Simonyi (1995) (FTP links)


• Intentional
  Programming - Innovation in the Legacy Age, a talk by Charles Simonyi (1996)


• Lutz Roeder, Talks and Papers website


• Citations from
  CiteSeer


• Edge.org interview with
  Charles Simonyi (interviewer: John Brockman)


• Is programming a form of encryption?, by Charles Simonyi (2005)


• The information contents of programs, by Charles Simonyi (2005)

Identity




IP focuses on the concept of identity. Since most programming languages
represent the source code as plain text, objects are defined by names, and their uniqueness has to be inferred by the compiler.
For example, the same symbolic name may be used to name different variables, procedures, or even types. In code that spans
several pages - or, for globally visible names, multiple files - it can become very difficult to tell what symbol refers to what actual object. If a name is changed, the code where it is used must carefully be
examined.




In an IP system, on the other hand, all definitions not only assign symbolic names, but
also unique private identifiers to objects. This means that in the IP development
environment, every time you refer to a variable or procedure, it's not just a name - you're actually linking back to the original
defined entity. The major advantage of this is that if you rename a definition, all of the references to that entity in your
program are changed automatically. This also means that if you use the same name for unique definitions in different namespaces
(eg. ".to_string()"), you won't rename the wrong references as is sometimes the case with Search/Replace in current editors.




This feature also makes it easy to have multi-language versions of your program. You can have a set of English names for all
your definitions as well as a set of Japanese names which can be swapped in at will.




Having a unique identity for every defined object in the program also makes it easy to perform automated refactoring tasks, as
well as simplifying code checkins in versioning systems. For example, in current code
collaboration systems (i.e. CVS, SVN), when two programmers commit
changes that conflict (i.e. if one programmer renames a function while another changes one of the lines in that function), the
versioning system will think that one programmer created a new function while another modified an old function. In an IP
versioning system, it will know that one programmer merely changed a name while another changed the code.






Levels of detail




IP systems also offer several levels of detail, allowing the programmer to "zoom in" or out. In the example above, the
programmer could zoom out to get a level that would say something like:




<<print the numbers 1 to 10>>




Thus IP systems are self-documenting to a large degree, allowing the programmer to
keep a good high-level picture of the program as a whole.






Similar works




There are projects that exploit similar ideas to create code with higher level of abstraction. Among them are:





• Concept programming


• Language-oriented programming


• Literate programming


• MDA


• Software factory


• http://www.answers.com/topic/metaprog

Separation of source code storage and presentation

Key to the benefits of IP (and a likely barrier to acceptance from the programming community) is that source code is not stored in text files, but in a proprietary
binary file that bears a resemblance to XML. As with XML, there
is no need for a specific parser for each piece of code that wishes to operate on the
information that forms the program, lowering the barrier to writing analysis or
restructuring tools. The video demonstrates how the system handles languages that use a text-based preprocessor by surveying the specific usages of macros in a body of code to
invent a more hygienic abstraction.

Tight integration of the editor with the binary format brings some of the nicer features of database normalization to source code. Redundancy is
eliminated by giving each definition a unique identity, and storing the name of variables and operators in exactly one place. This means it's also easier to intrinsically distinguish between
declarations and references, and the environment shows declarations in boldface type. Whitespace is also not stored as part of the source code, and each
programmer working on a project can choose an indentation display of the source that they
like. More radical visualizations include showing statement lists as nested boxes, editing conditional expressions as logic gates, or re-rendering names
in Chinese.

The project appears to standardize a kind of assignPa