Lambda the Ultimate

I think the following workshop may be of interest for LtU readers.

CALL FOR PARTICIPATION

SIGPLAN Programming Languages Mentoring Workshop, Rome

Tuesday January 22, 2013

Co-located with POPL 2013

PLMW web page: http://www.doc.ic.ac.uk/~gds/PLMW/index.html

After the resounding success of the first Programming Languages
Mentoring Workshop at POPL 2012, we proudly announce the 2nd SIGPLAN
Programming Languages Mentoring Workshop (PLMW), co-located with POPL
2013 and organised by Nate Foster, Philippa Gardner, Alan Schmitt,
Gareth Smith, Peter Thieman and Tobias Wrigstad.

The purpose of this mentoring workshop is to encourage graduate
students and senior undergraduate students to pursue careers in
programming language research. This workshop will provide technical
sessions on cutting-edge research in programming languages, and
mentoring sessions on how to prepare for a research career. We will
bring together leaders in programming language research from academia
and industry to give talks on their research areas. The workshop will
engage students in a process of imagining how they might contribute to
our research community.

We especially encourage women and underrepresented minority students
to attend PLMW. Since PLMW will be in Rome this year, we particularly
look forward to seeing Eastern European students at the workshop.

This workshop is part of the activities surrounding POPL, the
Symposium on Principles of Programming Languages, and takes place the
day before the main conference. One goal of the workshop is to make
the POPL conference more accessible to newcomers. We hope that
participants will stay through the entire conference, and will also
attend the POPL tutorials on Monday 21st January which are free to
PLMW registered attendees.

Through the generous donation of our sponsors, we are able to provide
scholarships to fund student participation. These scholarships will
cover reasonable expenses (airfare, hotel and registration fees) for
attendance at both the workshop and the POPL conference.

Students attending this year will get one year free student membership
of SIGPLAN

The workshop registration is open to all. Students with alternative
sources of funding are welcome.

APPLICATION for PLMW scholarship:

The scholarship application can be accessed from the workshop web site
(http://www.doc.ic.ac.uk/~gds/PLMW/index.html). The deadline for full
consideration of funding is 9th December, 2012. Selected participants
will be notified from Friday 14th December, and will need to register
for the workshop by December 24th.

SPONSORS:

Imperial College London
Jane Street
Monoidics
NSF
Resource Reasoning
SIGPLAN
vmware

I've just finished a short one-page paper with the title 'Accounting: counting with balanced Debits and Credits'. The paper aims to eradicate the notion of zero and thus division by zero. There is some humour to be found in the paper but I'm serious about the ideas. Here is the abstract:

Division by zero is undefined, so we have decided to eradicate zeros completely. We do this by introducing a new kind of Integer, called an Account, which is an ordered pair of two Naturals - Debit and Credit.
Naturally, we also introduce a new kind of Rational, called the Super-Rational, which is an ordered pair of two Accounts - Numerator and Denominator.

Note: I've been posting a lot of stuff here lately so it may appear like a one-man show. If you think I'm out of line please say so.

Is there some important semantic distinction I'm missing - if we only consider _function_ and, thus, perhaps algebraic type _constructor_ definitions - or does this just end up being a simple matter of syntactic convenience or inconvenience (e.g., imagine mutually recursive object "methods" facilitated via different class "forward declaration" - just an example for which some typical Scheme "letrec" or "fix" styled syntax might be challenged).

Any and all sagacious wisdom greatly appreciated. Thanks!

- Scott

Code Generation 2013 is a practitioner conference focussing on emerging tools, technologies and approaches in Model-Driven Software Development. The event takes place from 10 – 12 April 2013 in Cambridge, UK.

Call for Speakers:
Submission Deadline: Friday December 14th 2012

We are seeking high-quality session proposals covering any aspect of MDSD (including Domain-Specific Languages (DSLs), Model-Driven Architecture (MDA), Domain-Specific Modelling, Generative Programming, Software Product Lines and related areas).

Sessions could cover topics such as:

- Defining and implementing modelling languages
- Code Generation and Model Transformation tools and approaches
- Language evolution and modularization
- Domain Analysis and Domain Engineering
- Tool and technology adoption
- Meta Modeling
- Runtime virtual machines versus direct code generation
- Approaches to code generation
- Approaches to combined development (partial code generation with partial handwritten code)
- Flexibility in code generation

Case studies and interactive sessions based on these and related approaches are particularly encouraged although more theoretical sessions are also welcome.

Accepted speakers have their conference fees waived.

For full details and instructions on how to submit a session please visit: http://www.codegeneration.net/cg2013/submissions/index.php

The conference, now in its 7th year, is organised by Cambridge-based software events specialist Software Acumen.

Hear what previous participants thought in this short video clip:
http://www.youtube.com/watch?v=OsKQeuCCSvg

I've just finished a small article on multimaps which (among other things) defines an interesting recursive definition of numerals. Here is the abstract:

Ordinary maps must contain only single occurrences of their domain values, while multimaps may contain multiple occurrences of both domain and range values.
In this short article we relax the occurrence type to be of any type - if such type obeys some kind of number law. Because of this relaxation and because multimaps behave like numbers, multimaps can be the occurrence type of other multimaps.
We explore this idea with some sketchy code snippets and finish with a recursive multiple of nothing.

In this post, I try to show something you can do with Terms but (I think) not easily (idiomatically) with other logic systems. I know there is people in this forum that know a lot more about "other logic systems" than myself, and that with a cursory glance at what I propose would be able to judge whether what I propose is bullsht or is useful. So in all humility I would appreciate any judgement about it.

Thanks.

I'd been playing around with interpreting Javascript in Javascript, building off the Narcissus interpreter. Then I implemented some sucky pseudo code and that got me thinking about algorithm visualisation and how to improve pseudo-code on the web. In an interactive medium there really is little reason why algorithms should still be presented as static text.

So I rewrote the Javascript interpreter in continuation-passing style, so that it's execution could be paused. And the result is Javascript code that runs in the browser but can be controlled and visualised. Code that a user can pause and step through to see the control flow. The interpreter is currently passing 95% of the ECMAScript Language test262 test suite.

On top of the Javascript interpreter I built an experimental wiki to explore making algorithms interactive on the web. There are still lots of things to do and to figure out (eg. security), but I think it is very promising.

I also mangled it with the WebKit inspector to produce a Javascript IDE, although it's a bit rough and buggy.


I'm very curious to hear what people think, and any suggestions.

More info: http://will.thimbleby.net/removing-the-pseudo-from-pseudo-code/
Wiki: http://will.thimbleby.net/algorithms
IDE: http://will.thimbleby.net/algorithms/inspector

Summarizing from the Emscripten blog, there is a new eliminator pass, a new parallel optimizer, and a new relooper.

The self-hosting part:

Note that this update makes Emscripten a 'self-hosting compiler' in a sense: one of the major optimization passes must be compiled to JS from C++, using Emscripten itself. Since this is an optimization pass, there is no chicken-and-egg problem: We bootstrap the relooper by first compiling it without optimizations, which works because we don't need to reloop there. We then use that unoptimized build of the relooper (which reloops properly, but slowly since it itself is unoptimized) in Emscripten to compile the relooper once more, generating the final fully-optimized version of the relooper, or "relooped relooper" if you will.

Emscripten seems to be quite an undertaking. I'm never sure whether I should be more impressed or more appalled. I started leaning more toward "impressed" when I found out that the Google gmail app (the one you run in your browser) is written in Java, the bytecode then compiled to javascript, and the resulting javascript identifiers rewritten for compression and interpretation efficiency.

I just had this argument crystallize for me after a conversation with Manuel Simoni: http://akkartik.name/blog/libraries

I'm realizing I'm pretty far-out liberal on Steve Yegge's spectrum of programmers, so I'd love to hear reactions from people here -- who seem to be from all over the spectrum.

Memoization is an interesting technique that could be used to implement a purely functional spreadsheet, without the need of maintaining a dependency graph. I've written a small article on the subject.
Abstract:

There are many ways to implement incremental computation. One popular method - implemented by spreadsheets - is to keep an up-to-date topologically sorted dependency graph of all cells. 
After modification of a cell, a spreadsheet can optimally determine which cells need to be recalculated (without recalculating everything) given its dependency graph.

In this short paper we will discuss another approach that is based on memoization. 
An example is given that uses a divide and conquer algorithm to maximally re-use sums of integers. Next to that, we sketch a possible implementation based on uniquely represented confluently persistent treaps.

edit: small typo