Lambda the Ultimate

"... we describe and compare two modern, dynamically typed languages Converge and Metalua, which both have macro-like systems. We show how, in different ways, they build upon traditional macro systems to explore new ways of constructing programs."

Contrasting compile-time meta-programming in Metalua and Converge

I don't know if this post strays too far from programming language theory for this forum, so please let me know if I'm criminally Off Topic. That said, I'm writing a parser library for C++ which uses a limited form of backtracking that resembles functional stream parsing. I find this parse strategy to be elegant and powerful, but it makes locating source of parse errors seemingly impossible. Does anyone know how to generate specific/useful error information in a functional stream parser?

In the hope that maybe some of you will find this interesting, I decided to post some details about my Master's thesis project. Inspired by the Join calculus and Martin Odersky's Funnel language, I have developed a concurrent language (code-named Vodka) which separates the definition of function symbols and function bodies, combining familiar Join-calculus synchronization solutions with a multimethod-based approach to object-orientation. Here is a Dining Philosophers solution, explaining the decoupling of function symbols and bodies and a set of slides about the whole project. More code examples are available from the website.

Python and Ruby have been of some inspiration, too, which is reflected in Vodka's dynamic nature and its syntactic support for dealing with generators. Generators, however, need not be sequential but can yield values concurrently. There is some more example code (a small web server written in Vodka) which illustrates this.

The Vodka compiler/interpreter is written in Nice and runs Vodka programs on the Java VM. The runtime system allows a close integration of existing Java classes and makes efficient use of multiprocessor hardware, due to a transactional memory model and Doug Lea's work-stealing task library FJTask.

Is there a reference that describes how to define categorical semantics for lambda calculus enriched with dependent types? Both Pierce and Gunter give a good description of the categorical semantics of lambda calculus in their respective books. However, they use a simple type system. I would like to see a description of something more expressive. Examples from any class of dependent type system are helpful--system F, full calculus of constructions, etc...

I am working on a language where I would like to have simple dependent types such as sized lists. I don't really need higher-order abstraction. But, I would like to describe the semantics of /\n.list(n).

(Sorry, this may be a bit off-topic. But I think it's related to PL design.)

Something has been bugging me for quite some time.

SQL is powerful. It's declarative. Complex data-access algorithms can be expressed very concisely. But its syntax is monolithic. A SQL statement cuts across multiple tables (or domain objects as in OOA&D). When I examine many SQL statements at work, many of them share similar patterns: Certain inner joins or where clauses are repeated in many places to achieve the same filtering rules. I can't see an easy way to abstract these patterns out, to reuse snipplets of the statements. (like mixins or traits?) I can't see an easy way to discompose complex SQLs or to compose complex SQL statements out of smaller building blocks in manageable ways.

From the OOP point of view, data access should be hidden in an OR layer and everything should be done via methods on the domain objects. But that's not feasible in many applications. Many of the business processes implemented by the software my company develops are batch-oriented and they already take hours to run. If I insist on having everything going through the OR layer and take away the power of optimized SQLs, the software is simply not usable.

What other alternatives are there? And, is there any research on modularizing SQL or on a modularizable data-access language which is as powerful as SQL? (I couldn't find much from Google.)

This is the Call For Papers for the Eighth Workshop on Language Descriptions, Tools and Applications (LDTA 2008)

LDTA is a satellite event of ETAPS which takes place between March 29 and April 6, 2008 in Budapest, Hungary.

See http://ldta2008.inf.elte.hu/

Scope

LDTA is an application and tool oriented forum on meta programming in a broad sense. A meta program is a program that takes other programs as input or output. The focus of LDTA is on generated or otherwise efficiently implemented meta programs, possibly using high level descriptions of programming languages. Tools and techniques presented at LDTA are usually applicable in the context of "Language Workbenches" or "Meta Programming Systems" or simply as parts of advanced programming environments or IDEs. The applications areas include, but are not limited to:

• Program analysis, transformation, generation and verification
• Implementation of Domain Specific Languages (both visual and textual)
• Reverse engineering and reengineering
• Refactoring and other source-to-source transformations
• Application modelling (MDE, MDA, Software Factories, Product lines)
• Grammar engineering / Grammarware
• Language definition and language prototyping
• Debugging, profiling and testing
• IDE construction
• Compiler construction

LDTA is traditionally a forum where computer science theories are put to the test of real-world software engineering issues, for example by applying:

• context-free grammars to parser generation for real programming languages,
• attribute grammars to static analyzer and compiler generation,
• term rewriting to source-to-source transformation,
• action semantics to programming language implementation,
• model checking to software verification.

Note that LDTA solicits submissions from any technological or theoretical domain, as long as the paper is within the application scope.

Submission Procedure and Publication

Submissions in the following categories are admissible:

• research papers,
• experience reports,
• tool demonstrations.

The final versions of accepted papers will be published in Electronic Notes in Theoretical Computer Science (ENTCS), Elsevier Science, and will be made available during the workshop.

Each submission must:

• be original, i.e. not published or submitted elsewhere,
• contain a clear motivation,
• contain a thorough analysis of the claimed results (not for tool demonstrations),
• be written in less than 15 pages (research papers and experience reports), or less than 5 pages (tool demonstrations),
• specify which category (research, experience, tool demonstration) the paper is to be considered under,
• use the ENTCS style.

The authors of the research papers and experience reports are required to give a 25 minute presentation at LDTA 2008. The authors of the tool demonstrations are required to give a 15 minute introduction to the tool, and to demonstrate their tool in a more interactive (parallel) session during 90 minutes.

The authors of the best full-length papers will be invited to write a journal version of their paper which will be separately reviewed and, assuming acceptance, be published in journal form. As in past years, this will be done in a special issue devoted to LDTA 2008 of the journal Science of Computer Programming (Elsevier Science).

The authors of the best tool demonstrations will be invited to write a short paper and submit the source of code of their tool, which will both be separately reviewed and, assuming acceptance, be published in the special issue on Experimental Software and Toolkits (EST) of the journal Science of Computer Programming (Elsevier Science).

Please email your submission to both a.johnstone@rhul.ac.uk and jurgen.vinju@cwi.nl

Important Dates

• Abstract submission deadline: Friday November 30th, 2007
• Paper and tool demo submission deadline: Friday December 7th, 2007
• Notification of acceptance: Friday February 1st, 2008
• Workshop date: Sunday April 5th, 2008

I mentioned this somewhat passingly a few years ago. So not to make the same mistake again, I'm reposting this as a top-level post (and with current links).

His list of publications and the recent ones. Some relatively recent work by him discussed on LtU is here.

The ones I want to highlight in particular are his applications of the Curry-Howard correspondence to machine code generation and such topics.

The Open Quark team at Business Objects is delighted to announce the release of the Open Quark Framework for Java V1.6, incorporating the CAL language and the CAL 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.

The 1.6 release continues to support the original motivations of the Quark Framework with additional libraries for data and queries. New libraries have also been added for XML, for working with directed graphs, for accessing Java2D drawing, along with some utilities for working with collections.

A new tool called the "IO Source Generator" is included as part of the 1.6 release. This can help in the construction of interfaces to Java data models.

A number of new documents are released with this version of the framework. We hope these will provide further insights into the implementation of the framework and the CAL language.

The Eclipse plug-in continues to evolve and mature with this release.

The full release notes can be read here.

The download packages may be obtained here.

As usual, we value feedback on the project. Community participation is already helping us to shape the future of the framework and tools. Please visit our Google Group.

I vaguely remember reading a paper that proposed semantics in which a trace or history of causes that lead to creation of an object was treated as this object's identity, but am unable to locate it anymore.

I realize that Google is more appropriate for posting such questions than LtU, but for some reason I am unable to persuade it to reply with the right answer...

Any (meta-)pointers/suggestions are very welcome!

Simon Peyton-Jones gave an enjoyable introduction to Haskell at OSCON 2007
for those interested: [part1, part2, slides] including another example of his Programming Language Nirvana chart during the Q&A session towards the end of the video.