Lambda the Ultimate

Hi,

I hope this is the right place to ask, but I've read a lot of good comments on other topics here so I'll just ask. At the moment I'm searching for a topic for my dissertation (Ph.d in non-german countries I think), which must have to do something with parallelism or concurrency, etc. but otherwise I'm quite free to chose what I'm interested in. Also Everything with GPU's is not reasonable, because a colleague of me does already research on this topic and we'd like to have something else for me :)

So, the magic questions is: What would you say are interesting topics in this area? Personally I'm interested in parallel functional programming languages and virtual machines in general but I'd say that a lot of work has been already done there or is actively researched (e.g. in the Haskell community).

I'd greatly appreciate any help in pointing me to other interesting topics.

Best regards,
Michael

Surprised to see there hasn't been a mention of Microsoft's recent PDC. They have some interesting talks available on the web.

There are a couple of videos on "Oslo," their DSL framework. Discussion of finding bugs in concurrent programs. An introduction to F#. For me, the most interesting, and the most unexpected talk was on contracts being integrated into .NET as a library. These pre/post conditions and invariants can be checked at compile time and another project "Pex" can use them to generate unit tests.

I recently came across Mark Tullsen's paper on First-Class Patterns, and I was wondering if anyone ever applied this work. I know there has been other work in reconciling pattern matching with abstraction, most notably Wadler's views as featured in Haskell and F#, but Tullsen's approach is an interesting contrast for its simplicity and effectiveness.

IIT Kharagpur

KSHITIJ 2009

THE ANNUAL TECHNO-MANAGEMENT FEST

29th Jan- 1st Feb
THE OVERNITE ACM ICPC 2009 MULTI PROVINCIAL PROGRAMMING CONTEST
( http://overnite.ktj.in )

* C/C++/JAVA to be used as medium of coding.
* An all night coding event.
* Wild card entries to be given through online prelims .
* ONLINE PRELIMS: 29th Nov,2008

OPENSOFT

What would you call a body without soul?
Confused? Yes, this is the same scenario with hardware without
software.

Moreover this event is open source, thus enabling later modifications,
debugging and improving upon the origin software.

JAVAWISE

Open Source Java is the missing piece of the puzzle to enable broader
open source development from desktop to server.

The event challenges the participants to develop an application to be
used on a mobile phone or a PDA.

ìMouse4D

Introduces the latest innovation in the field of Robotics,the
Microsoft Robotics Studio,to tackle one of the best known problems in
the field of Artificial Intellegence,MicroMouse

It requires the competitors to face the challenge in a virtual
world,simulating the task done in the physical realm.

HACKED?...If you have the fire to combat the e-world this is a
platform that we present to you.

FramED9211...Ever wondered how they nab those over-speeding vehicles?

www.ktj.in

I've been mulling over a language design issue which would be nicely solved if tuples behaved like a monoid. Is anyone aware of a language where tuples can be arbitrarily extended?

For example, if # is the tuple extension operator:

f :: a -> b -> a#b 
f x y = x # y


f 1 "dog" ==> (1,"dog")
f (1,"dog") true ==> (1,"dog",true) 
f () ("dog", true) ==> ("dog", true)

It seems that type inference is still possible here, though I'm not sure exactly how it would work. (ie, how do you unify types a*b*c and d#e?)

I have a list of the rooms(e.x. ((1 2) (2 4) (IN 1) (IN 3) (1 3) (4 5) (5 OUT)),where () means that rooms are connected with each other "IN"-entrance,"OUT"-exit).Would you be so kind to explaine the algorithm ,which can find the exit ?

It seems to me that Haskell imitates subtyping for numeric types by implicitly passing number literals to the coercion functions fromInteger or fromRational. Is it possible to give subtyping and overloading a more elegant/complete way to coexist?

If, for example, the literal "1" has type int, what needs to be added to an ML-like type system so that "1 + 0.3" will be typed as a float?

Thanks,
Alex

I was just struck with a minor revelation. The informal explanation for α-equivalence in λ-calculus is that a function "does the same thing" regardless of the particular names that we might choose for its internal variables. But this seems like just a particular case of the general extensionality principle!

Technically, α-conversion means that a bound variable may be renamed to another one as long as no free variables are captured:

    y ∉ FV(e)
―――――――――――――――――― (α)
λx. e = λy. e[y/x]

And indeed, it turns out that in the presence of the η-rule, which expresses the extensionality principle, the above rule is derivable:

y ∉ FV(e)
―――――――――――――       ―――――――――――――――――― (β)
y ∉ FV(λx. e)       (λx. e) y = e[y/x]
――――――――――――― (η)   ―――――――――――――――――― (ξ)
λx. e  =  λy. (λx. e) y  =  λy. e[y/x]

This is of course quite trivial. However, I've read a fair number of tutorials to λ-calculus, and I don't recall having ever seen this particular tidbit mentioned anywhere. I'm unsure whether this is because I just haven't read the right papers, or the matter is so trivial that no one bothers mentioning it explicitly, or there's something wrong with my reasoning.

So, just to ease my mind, could someone please either direct me to some respectable source where the redundancy of α in the presence of η is confirmed, or else point out what I'm missing here?

Thanks.

The process of programming language creation is a subject of too little reflection and retrospection. Newcomers to the field (including, in some measure, us) regularly propose new languages without quite understanding what they are getting into or how big the task is.
... This paper describes the motivation and early design evolution of the BitC programming language, making our excuses in hindsight and providing a compilation of some of the things that we learned along the way.
... The ML module system [18] is fully understood only by David MacQueen, and only on alternating weeks. The Scheme module system [8] required the combined brilliance of Matt Flatt and Matthias Felleisen (and six revisions of the language standard) to achieve. From the perspective of a mere operating systems weenie, it's all rather discouraging, but what is the reluctant programming language designer to do?
... The real reason we stuck with the LISP-ish syntax is that we didn't want to be fiddling with the parser while designing the language, and (to a lesser degree) because we didn't want to encourage programmers until we thought the language was ready.

The Origins of the BitC Programming Language Warning: Work in Progress

Ola Bini, a core JRuby developer and author of the book Practical JRuby on Rails Projects, has been developing a new language for the JVM called Ioke. This strongly typed, extremely dynamic, prototype based object oriented language aims to give developers the same kind of power they get with Lisp and Ruby, combined with a nice, small, regular syntax.

InfoQ has a Q&A with Ola about Ioke.