Lambda the Ultimate

I found it odd that we hadn't mentioned this paper before on LtU (that or my Google-fu has failed me).

I think this is a quite interesting basis from which to go beyond the static vs. dynamic debate and think interesting thoughts about static and dynamic living together in harmony (except for some bouts of blaming each other that all good friends are bound to have on occasion. ;-) )

Hopefully it won't be too controversial (!) for me to add that my interest in this topic was sparked by the growing feeling that we are starting to bump up against the limits of what can sensibly be done with homogeneous, pure static type systems (both theoretically and practically), and that the direction for future work may depend on finding ways to get different type systems or different degrees of typing to play well together.

Hi Folks

I was just having a discussion with a friend and this question might not seem logical but - just like any code structure can be represented by closures and any control flow can be modelled by continuations, is there any type system in which all type systems can be represented ? Does this concept even make sense ?

FringeDC is a group in Washington DC interested in fringe programming languages such as
Lisp, Erlang, Haskell, Prolog, etc.

Web Site:
http://www.lisperati.com/fringedc.html

Nov 6th Meeting Info:
http://www.lisperati.com/nov10.html

The Open Quark team is pleased to announce version 1.7.0 of the Open Quark Framework for Java.

Open Quark is a BSD-licensed lazy functional runtime for Java, with a native language called CAL.
The motivation for Open Quark is to allow embedding of lazy functional logic within Java applications, including full functional metaprogramming (under Java control) if required. The framework also allows standalone CAL applications to be created.

1.7.0 is a feature release, with important enhancements, including:

• A tool to create standalone library JARs, with multiple entry points (complementing the existing ability to create standalone applications with a single 'main' function as the entry point).
• New/enhanced libraries, including a full XML parser and encoder and a Parallel module for concurrency control, amongst others
• Ability to declare record instance functions straightforwardly in CAL
• Improved refactoring and other support in the Eclipse Plug-in
• A Record Creation special Gem in the Gem Cutter
• Improved memory use

Please see the release notes for a full description.

Downloads are available on the main Open Quark site.

Feedback and other contributions to the project are very welcome. Please visit our discussion forum.

I'm a senior undergraduate looking into graduate schools with an eye towards PL. I am strongly considering taking a year off after graduation but figured I should start looking now. Given LtU's audience I thought here would be a good place to ask if anyone has any particular recommendations for places to apply to. Also any tips on getting in to such a program would be welcome ;)

The biggest point against me I think is that I'm coming from a liberal arts college (so we take just Algorithms, not Algorithms 101, 102, and 103). Most of my learning so far has been self driven. My college has a PL course but it's mainly oriented towards making sure students are exposed to FP before they graduate rather than formal semantics or type theory. Instead I'm taking PL as an independent study geared towards the more advanced -- I've read most of my prof's old copy of The Denotational Description of Programming Languages (Gordon) and will soon move on to lambda calculus and eventually type theory. I expect that as my formal knowledge develops I might find specific PL researchers I would be interested in working with, but alas I'm not at that level yet.

I find everything from formal semantics down to the compiler to be interesting, except for parsing, but perhaps it has simply not been presented in an exciting way yet. :)

Years ago I read a quote regarding non-local effects in programming which said something along the lines of:

Writing a computer program is like building a skyscraper where, if the fit of the door to the janitors cupboard in the basement is wrong, the whole building could collapse.

(of course, that only applies if you're using a language which allows non-local effects :-)

I've been struggling to locate the reference, though - does it ring any bells for anyone here? Failing that, can anyone point me at a similar quote?

Thanks in advance!

Paul.

THANKS!

I wrote a tutorial a couple months ago on programming models for shared-memory concurrent pseudorandom number generation:

http://www.cs.berkeley.edu/~mhoemmen/cs194/Tutorials/prng.pdf

It was meant for upper-division computer science undergraduates, but I was wondering if you all think it has potential to be adapted for more general use.

The article argues for making PRNGs efficiently thread-safe by choice of programming model, and offers examples of how different kinds of parallel PRNGs fit into the offered models.

mfh

Luke Simon, Ajay Bansal, Ajay Mallya and Gopal Gupta Co-Logic Programming: Extending Logic Programming with Coinduction 2007

In this paper we present the theory and practice of co-logic programming (co-LP for brevity), a paradigm that combines both inductive and coinductive logic programming. Co-LP is a natural generalization of logic programming and coinductive logic programming, which in turn generalizes other extensions of logic programming, such as infinite trees, lazy predicates, and concurrent communicating predicates. Co-LP has applications to rational trees, verifying infinitary properties, lazy evaluation, concurrent LP, model checking, bisimilarity proofs, etc.

It is nice to see that coinduction is making its way into Logic Programming.

I couldn't find a free link to this paper [Edit: The link now points directly to the paper], but I found the following useful slides on Gopal Gupta's webpage. Slides from ICLP'07

I was watching the interview with Dave Thomas. Dave mentioned very early in the interview Smalltalk has a "keyword syntax" which makes it easy to implement (embedded) DSL.

What's "keyword syntax"?

And, what makes a language a good platform for (E)DSL?

I know Haskell has been a good platform for doing EDSL. It looks like to me its Type Class and high-order functions enable us to implement EDSL. But, are they essential? LISP doesn't have type class, but i think it's also a common candidate for EDSL. So, what are the essential language features for EDSL?