Software Visualisation – The next big leap?

Seeing what a program is doing (aka “Software Visualisation” or whatever you name it) may be the next big leap in software development.

This follows logically from the 4 stages of  evolution of programs and programming languages namely – Assembly programming, Sequential programming, Functional Programming and present day OOP. At each stage, we tried to manage the lower level complexity by abstracting away using more intuitive models. But if you look back, the life of a software developer hasn’t changed much since the last 40 years.

The situation hasn’t improved much because abstraction was only a band-aid, it never solved the complexity problem. OTOH, Visualisation is  a permanent cure, because it aims to show what the program is doing at various levels in various (intuitive)views and hence allows us to come out of the black box mode of development we do today.

Now that we have figured out the solution, the challenge now is to do it right.

powered by performancing firefox

Software Visualisation: The other side of the coin

I think software visualisation is the other direction for future research. It is atleast as important as other directions of research because the present day software systems are so huge that no single person can ever understand the whole system.

The pace at which human cognitive skills evolve is neglible compared to the speed with which we build new software systems. Given the lack of high-level paradigms that might make programming more easier, the time is ripe for researching mechanisms that will extend and aid human-cognition to understand the a software system. These mechanisms should do to human-cognition what telescope did to the human-vision.

Given that we are building systems almost the same way for the past 50 years, it would be a deliberate mistake and hurting in the long run to ignore this direction of research.

Note: The post is deliberately authoritarian (which i aspire to be ). I am trying to see if i can write that way.

Frameworks for Data Visualisation

These are the frameworks for data visualisation.

• Prefuse
• Some work on visualising huge data sets.

Frameworks for manipulating visual environments.

• Processing

A few more similar links:

• Information Visualisation tools

Plate

Plate is an interesting project.

Some excerpts from the website:

Plate integrates all the common programming interfaces into a unified visual space. This projects begins with the assumption that a text-based language is an appropriate and powerful method of representing a program.

Unlike a traditional text-editor, in which any series of letters may be generated, Plate breaks up the programming language elements (which are generally few in number) into immutable plate objects. When rearranging these plate objects into meaningful structures, the user is constrained so that only syntactically correct statements may be composed. This effectively eliminates the plentiful syntax errors which are such a bane to both novice and experienced programmers.

In short, each plate is an expression and each immutable plate maps to a statement. Though Unified interfaces and text-based programming are good insights, the claim that syntax errors are a bane does not hold ground given the kind of IDE's and languages we have today. This approach to building programs may not scale when the language is dynamic.

But the best thing i like about this project is the interface which is quite good and the best i have seen to visualise the execution of a text. Unfortunately, this interface doesn't work well when there are lots of variables in scope because the UI assumes that value of variables will be in the viewers head during the evaluation of the expression. The below image is a cheesy gimp work, that will fix this problem by showing the values of variables on top while evaluating the expression.

Sadly, the author did not publish any papers and hence the implementation details remain unknown. Also, the website does not mention if the environment re-executes the procedure everytime a value is changed, I think it does.

I plan to build a similar UI for NPL, when the user wants to see the execution of a single function.

Visualisation : Must reads

The following links are must reads for people interested in visualisation.

• Why looking isn't always seeing: readership skills and graphical programming
• Software Visualisation (Book by MIT Press)

Visualisation as an AST tree

A program can be visualised as a tree. Because a program is basically a tree. But there are 2 problems with visualising programs as a tree:

1. Many programmers think that program can be visualised as a tree because, the program we write is an AST (abstract syntax tree) We understand the execution of code, by visualising the execution of abstract syntax tree. For most part executing AST works well. But it fails when you have side-effects. The expression a=5 is an example. Though it can visualise (=,a,5), it cannot show how the values are stored in the symbol table. Though the ramifications of this in a procedural language might be less, they would be glaring once the language acquires name spaces and OO.
2. Though we visualise code as an executing AST, an AST is pretty much static. Though it can be visualised, it is no better than a call grah. It can only tell you what has happened, but not why and how it has happened.

These arguments apply equally well to pure functional languages because, though they do not have side-effects, they do have closures, which should be visualised in a similar fashion.

Some links to projects which visualise AST.

1. HOPS