Lambda the Ultimate

There's plenty of reading suggestions for authoritative references on various topics, and a few from LtU threads of which I've used. However, sometimes, you just want to read a book, away from your computer without doing exercises or programming at the same time. In fact, in my case, I prefer to do most of my reading this way.

For example, a book like SICP or TAPL isn't exactly something that you lay down on the couch with and just read. Unfortunately, most of the books that are the page-turning type are the "popular" math or compsci books that don't really challenge your brain enough. Is there a happy middle ground here? Any suggestions on titles that might fill this apparent void? Ideally, while I may not get all the details of some topic covered, when later encountered in a more formal text, I'll have already been exposed enough to it to make the full understanding that can only come from solving problems and running/modifying sample code far easier.

I'm mainly interested in functional programming, PLT, and related mathematical topics.

I have always been wondering how a language interpreter would run code that requires that a static library be linked. There must be a way of doing it - all the neccessary information is in the library. Thus there must be a way of doing this in pure code.

Can anyone help on this issue? I have searched the internet many times over the course of a few years and have found nothing.

Having looked around the net for programming resources etc I eventually landed here. This happened more than once and from different directions so thats normally a sign to me that I've found a good resource.

I started studying with the Open University several years ago but their computing type courses are move vocational based so I switched to mathematics. The only way I can see to improve my comp sci education is to self teach myself. So for the last few weeks I've been looking around the net for free on line resources that might aid me. I 'm particular interesting in learning a FPL with a mind to implementing a programming language in one. I'm not expecting to invent anything new or popular I'm more interested in the education.

I'm intending to write up what I do for anyone else on line to use so my main requirements are that the resources are freely available. So far the best source I've found is SICP and I have been working through it. Are there any other resources that I could use. I am also interested in subjects that are not purely PLT specific. Advice, thoughts or pointers most welcome.

NOTE: I am not adverse to purchasing books, I bought SICP because I have a long commute, so if there are any introductory classics in this area please recommend them.

Hello.

I feel like I'm entering the lions den here, but for the past couple of years I've been working on an online book: Exploring Programming Language Architecture in Perl and I'd be very grateful for any comments, criticisms or suggestions on it.

It's purely a hobby project, not for profit. I feel that it may be pitched a little high for your average perl programmer, and it's far too "folksy" for a serious academic text, but I've had fun writing it and I learnt a lot in the process too.

So far it covers basic lexical closure, objects and inheritance, continuations, trampolining, and logic programming using failure continuations and backtracking. I plan to add chapters on garbage collection, types, and Compilation.

Please don't jump to conclusions from the first couple of chapters that it is a lame implementation of Scheme, I get to a proper cons cell structures and the like later on. The purpose of the first chapters is just to get a working interpreter in terms that the average Perl programmer can understand with little effort.

I freely acknowledge that it leans rather too heavily on the classic SICP and EOPL, hopefully I can remedy that in subsequent iterations.

I'm currently working a compiler (not yet on line) targeting a virtual machine also written in Perl. I fully realize that "my first compiler" is not a fit topic for a book, so I'll be throwing that away as a learning exercise and starting it again at some point.

Please be kind.

There was a reddit link to the following a very interesting website about live programming music in scheme. That page has a very interesting video showing someone 'programming' in scheme by dragging and dropping rectangles. It is interesting how scheme's parenthesis are replaced by a pseudo 3d surface, with depth of the layers signifying nested parens. The wiki link on that page also has a few interesting screenshots. Following links on that page eventually leads to fluxus which has lots of examples of live music, animation, etc. The tutorial videos there are also very interesting.

LtU has many discussions on FRP and live programming, but any one know of any papers published about this work? Is this just a variation of FrTime or CELLS or is their technique different?

MLstate - currently in stealth mode - is an IT company, whose functional programming approach to SaaS and cloud computing has been recently recognized by the French Ministry of Research Innovation Award and support from leading investors.

We are research-oriented, we value technical excellence and innovation and we believe our technology has a potential to dramatically change the way web applications are being built.

MLstate opens several new permanent positions to meet this challenge:

• Senior Developers: Outstanding PhDs with at least 3 years of research experience in functional languages and/or formal verification and the ability to manage a small technical team.
• Developers: PhDs with strong FP skills. Applications from PhD students defending their thesis soon are also welcome.

Jobs are based in Paris and include a competitive compensation package.

Please send a (link to your) CV to julien.sylvestre@mlstate.com

Hi,

For my master thesis I'm designing a new programming language for a specific domain related to data processing.

One of the neat features I'd like to include in the language would be the concept of memory, in that each variable would remember its past values and the interval it held them. This can simplify lot's of queries as time itself is central in this domain.

Anyway, being just a graduate student, I know this idea must not be new. However, the most similar topic I was able to dig were temporal databases and temporal query languages. I wonder if there is anything else. Also, I wonder if it is possible for the compiler to analyze the program and find out how much memory it really needs to keep. Comments?

Thanks,

Luís Pureza

Dear Lambda Readers,

I'm to write a short paper on my experience in systems programming with Standard ML (should it be interesting for others). To make a difference it would be nice to have a refereed paper and to have it available for free. JFP and Software Practice & Experience retains the copyright. Do you know any other journal that allows free downloading?

Given the recent discussion in the Subtyping+overloading thread I wanted to ask a question which has been bugging me (for ages).

I assume we all known HM style type inference.

As I understand it, HM has been extended with quantifiers to allow multiple instantiations of the same type, or hiding of known types. I.e., the following good old example only type checks if 'id' has type 'forall a. a -> a':

let id = \x . x in
 (id true, id 1)

Great, problem solved, one would think.

My problem with the current definition of the quantifiers is the following. A bold statement: the types (1) 'forall a . a' and (2) 'forall a b . a -> b' should not exist! I find it strange for (1) that a term can be written which unifies with any given type, similar in case (2), where a result is produced which can get any type.

Let me define the predicate 'great!' as types I personally like.

A type 'forall a . a -> a' is 'great!' since you know that the first 'a' will be bound by an argument, and a term can then be generated which holds the same type. A type '(forall a . a) -> (exists b . b)' is also 'great!' since it takes a known type, and produces a value out of a hidden type.

I am wondering if the current quantifiers were too much inspired by HM [or type theory], and are a false solution to the multiple instantiation problem. So I am looking for non-standard approaches which tackle this.

ABSTRACT

The Formalization of the OOP Paradigm: INHERITANCE OF ABSTRACT AUTOMATA
is devoted to discussion of the inheritance
relation on sets of Mealy automata. It continues study

Formalization of the OOP Paradigm

in which:

- the concept of abstract data type (or, what is the same, of a class)
is treated as an abstract automaton;

- relations of inheritance and polymorphism are introduced on sets of the Moore automata.

Proposed formalization of OOP notions significally differs from the
formalization of Luca Cardelli (see, for example, "A Semantics of Multiple Inheritance",
1988, Information and Computation 76, 138-164, 1988; http://lucacardelli.name/; ).