Lambda the Ultimate

What is the potential of visualisable languages?

A visualisable language is one whose code is written as text,but the interpreter can visualise(in 2D/3D graphic medium) the execution details of the code with the semantics of the language intact.

A feature like this will make it a lot easier to write,learn(from examples) and maintain software. If the visualisation can be done right, i see a lot of advantages of such an approach.Allowing cutomisation of the visualisation and advanced user interaction will be a bonus for such a language.

I also feel that this approach is better than Visual Programming Languages as almost all of them lack the expressive power compared to text.Infact, its is the best of both worlds(textual and graphical).

I also feel that visualisation caters well to everyone.It helps systems designed badly (tightly coupled systems being an example) stay in game because they can be managed even if it is with great difficulty.At the same time it allows good designs to prosper faster because it will be easy for people to understand the design and (re)use it.

I also feel that it will help manage complexity. From my understanding people define something as complex, when they do not understand it well.In software, we define something as complex, when we do not know what the system is exactly doing or cannot predict what the system would do given a set of parameters.Going by this definition of complexity,visualisation helps reduce complexity because it tells us what the system is exactly doing.

Comments on this issue are welcome.Also,Did someone already try this?

I am a programmer, and have recently been toying with the idea of creating a language. In this case, a language with mathematical syntax; however, what I really want to get is a grasp of the ideas. Does anyone know of useful websites/books/resources on designing a language? I really have no idea where to start. Thanks.

An interesting project at jscience.com.

From their description:

 Let's take the following example:

        class Person {
            void setWeight(double weight);
        }

Should the weight be in pound, kilogram ??
With quantities there is no room for error:

        class Person {
            void setWeight(Quantity<Mass> weight);
        }

Not only the interface is cleaner (the weight has to be of mass type); 
but also there is no confusion on the measurement unit:

        double weightInKg = weight.doubleValue(SI.KILOGRAM);
        double weightInLb = weight.doubleValue(NonSI.POUND);

Quantities work hand-in-hand with units (also parameterized). 
For example, the following would result in compile-time error:

        double weightInGal = weight.doubleValue(NonSI.GALLON); // Compile error, Unit<Mass> required.
        

----
Edit: fixed lt, gt signs

Derrick Coetzee has recently announced an interesting new wiki called LiteratePrograms. LP is based on Wikipedia's MediaWiki system, but adds some capabilities from the noweb literate programming system. Quoting from the LP website:

LiteratePrograms is a unique wiki where every article is simultaneously a document and a piece of code that you can download, compile, and run by simply using the "download code" tab at the top of every article. See Insertion sort (C, simple) for a simple example. To date we have 3 articles.
Based on Donald Knuth's concept of literate programming, LiteratePrograms is a collection of code samples displayed in an easy-to-read way, collaboratively edited and debugged, and all released under the liberal MIT/X11 License (see LiteratePrograms:Copyrights) so that anyone can use our code and text for any purpose.

While it's obviously just getting started, and thus has fairly minimal content, I think that the idea behind LP is an interesting one. It seems like there's a lot of potential for the LP wiki to become both a handy resource for (well-documented) code-snippets, and a great educational tool.

Having stumbled across Brzozowski's paper on partial derivatives of regex's I went looking for similar papers and have found manay mentions of McBride's The Derivative of a Regular Type is its Type of One-Hole Contexts, often with a URL.

Unfortunately, all these references I've found so far are 404 links that seem to be assorted misspellings and minor variations of http://www.dur.ac.uk/~dcs1ctm/diff.ps (which is itself 404). Anyone have a good link to this paper, or even just a softcopy?

Ta.
Keith

Seems like an interesting (if not very in-depth) read.

Our aim is to automatically generate high quality code taking advantage of the wide range of heterogeneous parallelism for Scale-Up and Scale-Out architectures. We propose "single source" compiler solutions for heterogeneous memory and computational subsystems using automatically-partitioned code and data, as well as software-managed cache for irregular data accesses. We exploit parallelism at all levels, including data and task level parallelism as well as SIMD parallelism.

One such heterogeneous platform is the Cell Broadband Engine (TM) (referred to thereafter as Cell), which includes a Power-Architecture processor and eight attached streaming processors with their own memory and DMA engines. In addition, each processor has several SIMD units that can process from 2 double-precision floating-point values up to 16 byte-values per instruction.

We propose techniques that include compiler optimizations partitioning for data and code to run on the multiple heterogeneous processor elements in the system, automatic generation of SIMD code, and other specialized optimizations for processor elements in the Cell architecture. Measurement indicates that significant speedups are achieved with a high level of support from the compiler.

I was wondering if any research had been done on the effects of massively parallel programs on reliability and/or exception handling. Intuitively, it seems that a massively parallel program is automatically more fault-tolerant, simply because errors are necessarily localized, and thus would cause a resource starvation as opposed to a fault that would crash the system.

Anyway, I wasn't sure if anyone had done any papers on it, if my intuitions were correct, or if they were way off base.

I don't remember how I stumbled upon this, but I've been interested in K for quite some time but could not find much in way of information and examples (outside of the Kx Systems commercial site).

A fresh Fortress Language Specification Version 0.866
was posted on February 16th, 2006 The new spec. version has 272 pages vs. 204 for the previous one,
as well as a new outline structure.

Hello all,

I could really use some help in enumerating the various languages which provide support for signature based polymorphism, structural subtyping and/or duck typing. Thanks in advance!