Lambda the Ultimate

Bram Moolenaar, of Vim fame, is designing a new langauge: http://www.zimbu.org/design
What makes this interesting for LtU is that he's making his rationale and his goals public from an early stage.

Hi, I have been looking for some documentation or articles w.r.t what exactly this technology involves and unfortunately have not had much luck. The only source i have is the IcedTea project which requires I pour through source code to make a determination of what these techniques involve and whether they are applicable to the situations I am interested in. Does anyone know of resources which describe the basic motivation/ideas and algorithms that "hide" behind the hotspot umbrella? If anyone here had some insight into these technologies I would appreciate it.

Thanks in advance,

An insight that furthers programming is that ordinarily type systems do not directly affect the value of a computation. Generally type systems are used to restrict inappropriate operations. Spiting typing semantics from that of the base language enables greater expressiveness as well as control. Traditionally language standards are permissive. Compilers are written with extensions (that occasionally contradict the standard). Even specialists have decreasing benefit from increasing effort trying to improve a language. Substantial gain could be had by using a strict standard for a simple yet modifiable language. Modularity at the type interface is not only convenient for modification, but also reduces confusion.

One mechanism of fostering separation of concerns is attribution. A tag can simply be a specially named function which returns its first argument. The name can be recognized and action can be taken. Such a system is particularly good at reducing (and in some cases eliminating) unwanted behavior, increasing performance, and easing porting. These suggestions may relate to a specific context, so it may be appropriate for the compiler to ignore a hint. In another situation, a policy could be strictly enforced.

This design should benefit from a novel compiler architecture. Optimizations and analyses need to be engaged dynamically. For the cost of preserving some invariants the compiler implementation is more accessible to sophisticated algorithms. Balancing compile time optimization with run time scheduling is an area of active research. Separate compilation and dynamic linking of components raise the possibility that properties will be unresolved at compile time. An alternative to using dynamic checking is to provide a version with restricted use. If the constraints are matched, then the preferred target is linked. Multiple variations would provide graceful degradation. The capability of the linker is increased by including some of the functionality of the compiler.

Enabling or suppressing rules provides substantial flexibility. Even greater expressiveness can be obtained by using a meta-interpreter library. The compiler would recognize this library and try to compile the code directly rather than interpreting it. How well this would work would depend on how different the new language is. Considering the difference in effort writing an interpreter verses writing a optimizing compiler may make the occasional success worthwhile.

Using unlimited precision numbers as a primitive type makes them independent of a particular architecture. Performance would be poor without type casting. Since resolving latent types at compile time is an undecidable problem, manual intervention would be necessary. Semi automatic methods are worth investigation. Perhaps combining type inferenceing with profiling could show where a constraint is most needed.

It may be helpful to use multiple notations. Alternative syntax could be a basis for WYSIWYG editing as well. For example mathematical notation or GUI layout could be handy. Finding isomorphism between grammars is another undecidable problem. If our initial language uses a regular grammar, parsing algorithms can be used. A simple language is amenable to grammar coloring. Profiling, unresolved types, pointer analysis, etc. can be highlighted. Coloring can be transferred to alternate notations as well.

Some of these lines of inquiry may not be fruitful. (According to the strong Church-Turing Thesis) Computers will continue in importance to civilization. The means of developing this resource is thereby also important. The scientific establishment has forsaken studying this because of its marked lack of success. Programming language design is still worthy of investigation.

Not sure if this is sacrilege, but... anybody know of a "meta-Scheme" that would be a lowest-common-denominator/logical-intersection (in fact, not just in theory, so code just works) of Scheme among popular Schemes? I want to write meta-Scheme code and have it be valid (and ideally equivalent) in PLT, Gambit, Bigloo, etc. This would be for a kernel with SRFIs, and is explicitly ignoring / not using non-SRFI libraries that might come with the individual platforms.

Or is this just a dumb idea? Thanks :-)

Channel 9 has asked Erik Meijer to do a ground-up introduction to functional programming, because he and other MS programmers have spoken so much about its influence on the design of Visual Basic .NET and C#.

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 1 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 2 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 3 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 4 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 5 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 6 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 7 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 8 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 9 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 10 of 13
C9 Lectures: Dr. Graham Hutton - Functional Programming Fundamentals Chapter 11 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 12 of 13
C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 13 of 13

New videos will appear every Thursday, and Erik has hinted that he (or someone at Microsoft working for C9?) will be checking the video comments for feedback on what reviewers want to see more or less of. Such interactive aspect is sort of unique, since most "Computer Scientists create Discovery Channel"-style videos are filmed at huge conferences or user group meetings (i.e., Rich Hickey's Clojure TV and Simon Peyton Jones' talks). Probably the most widely watched lecture series on functional programming today is Abelson & Sussman's course on Scheme at MIT, which uses the wizard book (Erik says he is using Graham Hutton's Programming in Haskell).

The webpage mentions Channel 9 has arranged with Cambridge University Press to give everyone 20% off either hardcover or paperback [which isn't necessarily the best deal you can find on the net]).

I'm a grad student at the University of Toronto. My thesis is a case study of DSL maintenance. If you use DSLs in your work, and you can spare half an hour for a non-personal non-confidential interview, please get in touch! ad@cs.toronto.edu.

I've been thinking about macros vs. fexprs on and off for about a year. The following bit of Scheme code exposes, what seems to me, a troublesome difference between function application and special forms.

(define (a) 1)
(define (alpha) (a))
(alpha)             ;  1
(define (a) -1)
(alpha)             ; -1

(define-syntax b (syntax-rules () ((_) 2)))
(define (beta) (b))
(beta)              ;  2
(define-syntax b (syntax-rules () ((_) -2)))
(beta)              ;  2 still!

The function being applied, a, in the first half of the code above, is dynamically determined when the application occurs. A redefinition of a means that calling alpha will reflect that change. Dynamic languages. Late binding. Yay!

In the second half of the code above, the special form, b, is determined and expanded when beta is first defined and redefining b has no affect on later calls to beta.

I know this is an old issue but looking at John Shutt's reasonably recent The Kernel Programming Language (and on wikipedia and here) he seems to have "solved" the problem by inventing $vau expressions which fall roughly into the fexprs category.

It seems a long time ago that Kent Pitman argued influentially against fexprs because they did not play well with the Lisps of 1980 with their dynamically scoped variables. The Kernel Programming Language has lexically scoped variables and the $vau form is not one considered by Pitman.

I've can only find mention of John Shutt's language once on Lambda the Ultimate and am surprised the $vau expression idea has not received more attention. It seems like a great idea enabling a more dynamic and consistently defined language.

I am a mathematics professor ^*. I was approached recently by one of our talented computer-science undergraduates at the university where I work, who is in her senior year and interested in taking a reading course in the applications of mathematical logic to computer science.

This undergraduate recently completed a summer project with the author of Twelf, formalising the ‘simplification’ SASyLF, and I get the impression that her interest is much more in the sorts of logic that arise in computer-assisted (mathematical) theorem proving than in the logic of programming per se—that is, I think that she's not particularly interested in temporal logic and other such proving-programs-correct stuff. She specifically mentioned wanting to understand the SLDNF logic behind Prolog, and I feel qualified to start there, but don't really know where to go next. I guess that I want to dig deeper into HM type inference (although she's already studied TAPL on her own, I believe), the calculus of inductive constructions, and that sort of thing—but these are mostly just (to me) buzzwords that I've picked up, and I'd like to put together some sort of coherent reading course. Suggestions?

^* To clarify, I'm mentioning this not to brag, but rather to give an idea of what a stretch this course will be for me. (I'm a representation theorist, not a logician.) Thus, don't hesitate to give references to things that “everybody knows”—almost assuredly, I don't!

Is anybody aware of a standard "toy" version of Scheme that is used for experimenting with Lisp-like languages? I'm thinking of something similar to MiniML's relationship with the ML family. I'm aware of Clinger's Core Scheme language, but this does not include macros, and I think they will be important for what we plan to do.

Of course, we could define our own language, but being able to point to a standard language will be much better.

Ideally, I'd love to find something like Wilson's GC survey, covering everything from various low level mechanisms such as raw thread/lock manipulation, condition variables, etc. up to much more programmatic stylized idiomatic approaches to concurrency - Erlang style actors, internal pipes or what I have heard called "flow based programming", co-routines and inversion of control strategies (not just performance based approaches).

Also I'm interested in "failed" or, rather, currently unpopular approaches such as parallel-apply (Connection Machine Lisp ?????) and so on and so forth.

While not essential, it would be great to have examples explained in the context of what can be done in a strongly typed language.

Any and all pointers to such materials greatly appreciated.

Scott