Guarded algebraic data types subsume the concepts known in the literature as
indexed types, guarded recursive datatype constructors, and first-class
phantom types, and are closely related to inductive types. They have the
distinguishing feature that, when typechecking a function defined by cases,
every branch may be checked under different typing assumptions. This mechanism
allows exploiting the presence of dynamic tests in the code to produce extra
static type information.

We propose an extension of the constraint-based type system HM(X) with deep
pattern matching, guarded algebraic data types, and polymorphic recursion. We
prove that the type system is sound and that, provided recursive function
definitions carry a type annotation, type inference may be reduced to
constraint solving. Then, because solving arbitrary constraints is expensive,
we further restrict the form of type annotations and prove that this allows
producing so-called tractable constraints. Last, in the specific setting of
equality, we explain how to solve tractable constraints.

To the best of our knowledge, this is the first generic and comprehensive
account of type inference in the presence of guarded algebraic data types.

Here's an anecdote I heard once about Minsky. He was showing a
student how to use ITS to write a program. ITS was an unusual
operating system in that the `shell' was the DDT debugger. You ran
programs by loading them into memory and jumping to the entry point.
But you can also just start writing assembly code directly into memory
from the DDT prompt. Minsky started with the null program.
Obviously, it needs an entry point, so he defined a label for that.
He then told the debugger to jump to that label. This immediately
raised an error of there being no code at the jump target. So he
wrote a few lines of code and restarted the jump instruction. This
time it succeeded and the first few instructions were executed. When
the debugger again halted, he looked at the register contents and
wrote a few more lines. Again proceeding from where he left off he
watched the program run the few more instructions. He developed the
entire program by `debugging' the null program.

Neel mentioned this paper when I complained on LtU1 that I haven't seen something interesting enough to post for a while.

It is indeed an interesting, well written, paper.

The authors show the design of Program Trace Query Language (PTQL), a declarative language for querying program behaviour. The PTQL compiler can then be used to instrument a java bytecodes and insert the required data capture operations.

Quite a lot of effot went into making the instrumented code efficient enough to allow queries to be evaluated while the program is running.

HTML isnâ€™t unusual. Documents are hard to design, and general frameworks for families of documents are even harder. The conventional wisdom back in the day was that to get yourself a good DTD designed, you were looking at several tens of thousands of dollars.

Then, once youâ€™ve got your language designed, you start the hard work on the software. Frameworks like XSLT help, but no significant language comes without a significant cost in software design.

As I've often said here ("here" in the general sense that is), XML vocabulary design is language design. Language design is hard. Hard things often cost.

However, Tim wants us to believe that one language is enough. I really hope he is wrong about that...

Welcome the the new LtU (LtU2, or LtU-TNG). Not only are we at a different location we are also running on a new software platform, so there are quite a few technical changes from the old site, the most important of which I'll try to address in this post.

Before going into these details I want to express my heart felt gratitude to all those who offered to help with this migration, and especially those that helped set up the current site.

First and foremost, Anton van Straaten. Anton offered to host LtU. Not only that, he helped choose the software to run the site (Drupal), installed it, and did most of the configuration work. Without him, I am not sure if I could have pulled this off.
Not only did he do all this, but he made the process enjoyable and tried to help in every possible way.

Chris Rathman has been our archiver from the early days of LtU, creating his useful index pages. His archive of LtU messages is now accessible via this site, and will be our main archive until we manage to find a way to migrate the old content to Drupal. Note: The archive page is quite large (600K).

Gordon Weakliem helped us convert the Manila user data.

Chris, Anton, and Gordon, thanks!

Now for some details about the new site.

We made every effort to migrate the LtU members list to the new site.

Since we didn't copy passwords from the old site, you need to reactivate your account by entering your name (as it appears in the LtU database) and clicking "Request new password." A new password will be emailed to your email address.

If this process is problematic (e.g., you email address we use is invalid, you don't remember the user name you chose etc.) you can simply create a new account.

In some rare cases, you may get a messages saying "Sorry. The e-mail address x@xxx is not recognized". In that case, you can create a new account, or email anton@appsolutions.com with the account name you're trying to activate, and the email address you want to use.

Home page items are called stories and can be published by contributing editors only. The forum (click "discussions" on the left hand navigation bar) can be used by any registered member like before.

To see a combined list of all new items on the site use the "Recent Posts" link. I suggest bookmarking it.