Lambda the Ultimate

I'm looking for a tool or library, which allows to combine different frontends and backends to convert sourcecode of one pl into another? Even if the translation is incomplete, a lot of tedious work could be done by a tool like this.

I have been programming in Python for a while and have been using generators as part of the language. However, I have recently found myself wanting to formally reason about a recursive generator function. Is there any formal basis for generators and is there any infomation on the subject on the web?

21st Annual Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2006)

Portland, Oregon
October 22 - 26, 2006
Sponsored by ACM SIGPLAN in cooperation with SIGSOFT

FIRST SUBMISSION DEADLINE: 18 MARCH 2006

OOPSLA 2006, the premier forum for practitioners, researchers, educators, and students in diverse disciplines related to object technology, is seeking contributions. This year, it may be your contribution that spawns a whole new technology--the next "big thing!"

OOPSLA offers an extraordinary array of venues and activities to suit the needs of attendees of all backgrounds. You can immerse yourself in the cutting edge and the future of software development, and interact and network with the best minds in the field. Becoming a participant is easier than you think and will enrich your OOPSLA experience. Just submit a proposal to one of the many events that make up OOPSLA. The following OOPSLA venues are seeking submissions:

* Research Papers -- Present novel technical results, advance the state of the art, or report on significant experience or experimentation.
* Onward! -- Submit a paper or film that presents new thinking and new paradigms for computing.
* Essays -- Present your personal view of a topic, a way of looking at some part of computing terrain, a way that leads the listener in an act of discovery.
* Lightning Talks -- Give a 5-minute presentation on any topic of interest to the community.
* Panels -- Organize a small group of experts who will discuss issues related to object technology, with audience participation.
* Practitioner Reports -- Report on your real-world experiences.
* Tutorials and Certificate Courses -- Present a half- or full-day course on a topic where you have recognized expertise.
* Workshops -- Organize an intensive, collaborative environment where participants surface, discuss, and solve challenging problems facing the field.
* Posters -- Present informal or exploratory work in a visual and interactive setting.
* Student Research Competition -- As an undergraduate and graduate researcher, share your results and gain recognition.
* Demonstrations -- Give a show-and-tell session on a state-of-the art system, language, environment, or application.
* DesignFest® -- Organize a design task for a small group of designers and developers.
* Educator's Symposium -- Promote new ways to teach and learn through paper presentations, interactive sessions, demonstrations, posters, and group discussions.
* Doctoral Symposium -- As a Ph.D. student, attend a one-day session where a panel of experts will provide guidance and feedback on your dissertation topic.
* Student Volunteers -- Donate a few hours of your time, to associate with the top people in technology, research, and software development.

Co-located events:
* Generative Programming and Component Engineering (GPCE'06)
* Pattern Languages of Programming (PLoP'06)
* Dynamic Languages Symposium (DLS'06)

If you have questions, please don't hesitate to contact the event chairs or the general chair. Check out http://www.oopsla.org today! We urge you to help shape the present and future of software development by contributing to OOPSLA 2006. We look forward to your submissions and to seeing you in Portland!

IMPORTANT DATES for OOPSLA 2006

** March 18, 2006 **
Research papers
Onward! papers
Essays
Practitioner Reports
Educators' Symposium
Tutorials
Panels
Workshops

** June 30, 2006 **
DesignFest® Posters
Onward! Films
Student Research Competition
Demonstrations
Doctoral Symposium

** August 1, 2006 **
Student Volunteers

** While space available **
Lightning Talks

CONTACT INFO

Conference Chair
Peri Tarr, IBM Research

Program Chair
William Cook, University of Texas at Austin

Communications Chair
Steve Metsker, Dominion Digital

Mark-Jason Dominus writes about "accidental syntax" in Perl, and wonders if this happens in other languages. I couldn't think of any examples offhand, but I'm sure Common Lisp must have some...

Herb Sutter's website has an interview with the main inventors of C, C++, and Java.

I think they all rightly raise the question of "C family of languages" means but I'm more interested in how the design decisions they discuss. I thought this bit by Gosling was interesting:

There have been a number of things [I would have done differently] -- like, for example, multiple return values -- that these days I kind of wish I had added. That was one where I really liked the feature and most other people just sort of went, "Huh?" Another one that sort of went that way was that I had been going down this route of having a bunch of stuff to do with preconditions and postconditions and assertions in an Eiffel-like way, and actually in the community of people who were using it at the time the average answer was, "Huh? Why would I ever want that stuff?" I think that the average developer today would say that too. But then there's a pretty reasonable crowd of people who believe in things like Design By Contract, and it's one of these things where a lot of people feel like, "If only the rest of the world was educated enough to understand what this is about, they'd be better off." And I actually kind of agree with that. The problem is that most of the world could actually care less.

What is known about the constraints of the Debug-Edit-Compile cycles that enable to modify and reload source code within a running debug session for several languages? Is there any research about this topic or is it plain arcane practical knowledge of compiler/runtime authors?

I just happened to notice that the 13th International SPIN Workshop is coming up. While model checking is kind of off topic, it made me think about SPIN's model checking language Promela.

From the Promela Reference manual:

The language allows for the dynamic creation of concurrent processes. Communication via message channels can be defined to be synchronous (i.e., rendez-vous), or asynchronous (i.e., buffered)

Gerard J. Holzmann's excellent book: The SPIN Model Checker has a complete reference to this interesting C-like language with CSP influenced extensions.

The Unimperative language I posted about nearly a year ago has been reborn as a "concatenative" language, ala Joy. ( personally I would prefer to call it a compositional language, but who am I to buck trends ).

The Unimperative language is also a tiny subset of C++, so I am trying to decide on the concatenation operators. Currently I support separate left-concatenation (f << g == f . g) and right-concatenation (g >> f == f . g). In the end this gets a bit clumsy, and I find hard to read. So I want to overload the comma operator.

My question is this: which concatenative form (left or right) should the comma overload to? In other words should I treat it as a left to right sequencing operator, or as a composition operator?

I think this may have been mentioned before on LTU, but I thought I would post the link again as I found this series of lectures by Jürgen Giesl great for learning Haskell.

The lectures are 2005-SS-FP.V01 through 2005-SS-FP.V26.

Videos 2005-SS-FP.U01 through 2005-SS-FP.U11 are exercise answer sessions, so you probably don't want those.

They are given in english.

Chu Spaces are a simple and surprisingly general mathematical construct with applications to linear logic, concurrency, games, physics, philosophy and foundational mathematics. If he hasn't run across them before, I imagine (at least) Andris Birkmanis will find them quite interesting.