Lambda the Ultimate

The word that he had long taken to mean "one" (hoi, on a falling tone) is used by the Pirahã to refer, more generally, to "a small size or amount," and the word for "two" (hoi, on a rising tone) is often used to mean "a somewhat larger size or amount."

Light reading from The New Yorker - April 16, 2007 about LtU's favourite amazonian tribe (previously on LtU Piraha Exceptionality: a Reassessment).

Language Support for ... (pdf)

"... using advanced programming language and verification techniques, it is possible to provide and enforce strong system-wide invariants that enable efficient communication and low-overhead software-based process isolation. Furthermore, specifications on communication channels help in detecting programmer mistakes early—namely at compile-time—thereby reducing the difficulty of the message-based programming model."

(And ppt slides)

The below email was recently forwarded to me.

From: Kent Dybvig 
To: qobi@purdue.edu
Subject: Re: benchmarking Chez

Jeff,

[...]  By longstanding policy, we do not publish nor support others in
publishing benchmarks comparing Chez Scheme with different versions of
Scheme or with other languages.

Kent

Discuss.

Katahdin is a programming language where you can define new language constructs such as expressions and statements as easily as new types or functions. For example, you could define a new operator, a new type of loop, implement a syntax from another language that you like. After defining a new construct you can use it on the next line in the same file, so there is no need to recompile each time you want to add a new construct. Katahdin is powerful enough that you can define an entire existing language, or design a new language from scratch, making Katahdin a universal language interpreter.

For example, most programming languages have a modulo, or remainer operator. To define one from scratch in Katahdin it is only a few lines:


class ModExpression : Expression {
  pattern {
    option leftRecursive;
    a:Expression "%" b:Expression
  }

  method Get() {
    a = this.a.Get...();
    b = this.a.Get...();
    return a - (b * (a / b));
  }
}


Katahdin is an application of parsing expression grammars and packrat parsing, an active area of research. The site contains a master's thesis and public domain source code.

Personally I'm very comfortable with using a combination of C++ (with STL, Fusion2, Phoenix2), Python (with PyGTK, SciPy) and SWIG. But then programming is just a single hobby of mine (audio stuff and some quantum mechanics, mainly).

So I'd like to hear some opinions from more experienced or even professional developers out of curiosity. What do you think about the common PLs in use with regard to large scale development? Please don't compare different languages, but instead tell me about a particular PL you have used and why it is suited for a bigger team of programmers or why it is a hindrance.

EDIT: "large scale" = "more than a handful of developers"

The Open Quark team is delighted to announce a new version of the Open Quark Framework for Java, and its associated Eclipse Plug-in.

Open Quark supports efficient non-strict functional evaluation in Java, and allows complete interoperability with Java, functional metaprogramming and evaluation control. Functions can be created programmatically in Java via a number of object models, and the full-featured Haskell-like language CAL allows large functional libraries and applications to be expressed conveniently. There is an increasingly complete Eclipse plug-in to support development in the CAL language. There is also a graphical language to create new functions.

As usual, the software packages and collateral can be downloaded at the main Quark Framework page.

A discussion forum can be found at on Google Groups.

Version 1.5.0 is a feature release adding several important enhancements, including:

• The ability to create minimal JAR files with a static main method. For those using CAL to write standalone applications without the need for metaprogramming or control from Java code, you can now create convenient JARs that are extremely small in size with very fast start-up (the CAL workspace and support for dynamic programming is not loaded).
• The Eclipse plug-in has wizards to help set up new projects and modules.
• The Eclipse plug-in has CAL templates
• The Eclipse plug-in supports shift/control hover to see the source code of a symbol
• CAL source formatting is much improved
• Help is now available in Eclipse

I just came across an article regarding Intel having massive multicore CPUs ready in the near future. This kind of CPUs will require a fundamental change of how we write programs, or so they say (there are plenty of discussions around about this).

But do we really have to change the way we write software? I wonder if there can be a part on the chip that automatically makes different threads of execution out of a single thread, by correlating data dependencies at run-time. Just like branch prediction, a similar piece of logic could be used to 'predict' data correlations, and thus separating the instruction stream into different threads, as if the code was multithreaded. A special lookaside buffer could be used to prevent simultaneous access to memory locations: since data are always fetched from the cache, the cache itself could contain flags that can be used to monitor simultaneous access. The CPU would catch the simultaneous access event and modify its threads and prediction statistics accordingly, so as that next time the simultaneous access is avoided.

I am asking LtU for this because I think the problem is essentially a software problem. In my mind, an instruction always targets a memory location (either directly or indirectly through registers), so the CPU could monitor dependent instructions and separate them into different threads of execution. The mechanism could be extended to registers, since registers are essentially memory locations inside the CPU.

Assuming that dependency tracking could take place in run-time, what programming language semantics are required in order to help the hardware run the software more efficiently? Is the C semantics enough? For example, Fortran loops can be automatically vectorized because they do not contain pointer aliases.

Finally, are purely functional programming languages better, on the semantics level, for automatic parallelization? on the surface, it certainly seems so, but what about languages that are translated to C (or equivalent) code? aren't those programs under the same constraints as C? would we have to eliminate C as the middleman and encode parallelization tips (coming straight from the FP semantics) directly in the instruction stream?

Hello Everyone,
Two questions from a person with too much time on his hands:
1) What is the next (LtU-related) book/paper/etc you would read, if you had the chance?
2) What introductory material would you recommend to a layman interesting in learning more about the topic from the book mentioned in question 1?

Just curious,
-Ryan

Edit: Generalized question from "books" to "books, papers, or similar things".

Oz supports distributed objects, JINI can move objects. But Erlang generally speaking moves only data around, and in the Web Services debate there are folks who say that data-centric is the best way to go.

As with all design issues there are probably several dimensions involved in deciding what approach to take; I'm curious to hear what people believe those are (the web services article lists "evolution, intermediaries, and recoverable operations") and when the tipping point shows up in favor of one approach or the other.

Has any one heard of Carnap Programming Language? Steven Ericsson-Zenith posted a comment on my blog inviting me to take a look. Since LTU is the coolest place to get new language information, I thought I would mention it here. I have been interested in programming multi-core and have been tracking Erlang and a few other developments.

The Link to Carnap Programming Language: http://www.carnap.info/

The first two paras from this page:

Carnap is a general purpose programming language for the next generation of many-core devices, many many-core systems and their applications. It introduces a process oriented programming model that allows programmers to seperate the concerns of data structures and the concurrent processes that act upon them.

"The primitive process of a Carnap program is called an action. An action determines a local or shared state. Actions are assembled by construction to form the component processes of a program. Programs consist of concurrent processes that construct and interact via logically shared data structures and resources called contexts.

Dorai Thodla
www.thodla.com