LtU Forum

Having trouble with 'purity'

I am having trouble wrapping my mind around the semantics of a pure functional programming language. In writing my current programming language I chose to treat the variable assignment expression:

x = 5

as the creation of a function named x.

x = 5 is semantically equivalent to:

x = fn () -> 5

Is this sort of 'variable assignment' considered to be an example of pure in the FP sense?

NOTE: if x (in the above example) were to be redefined, a new closure would be created with the associated value.

Sorry to ask such a trivial question, but I am having trouble finding semantic discussions concerning simple functional programming idioms.

Best regards,

M.J. Stahl


Mila takes a minimalistic approach to language design: As much as possible is delegated to libraries, the rest is a small set of language constructs. Hashtables, lists, objects and namespaces are all the same thing, for example. Other features: All parameters are named and have default values, variables are strongly typed, and there's a nice syntax to write objects with indentation.

I am the author of the language and all feedback is very welcome.

Introducing o:XML

What is o:XML?

It's a dynamically typed, general-purpose object-oriented programming language. It's got threads, exception handling, regular expressions, namespaces, and all the other things you would expect from a modern language. And it's expressed entirely in XML.


And so we return to the question: Why o:XML? My preferred answer would be: Using the same format for code as we use for data allows us to think slightly differently about the code. The application is not only a runtime executable, magically incantated by the source code -- it is structured data, information, a document!


Database Theory and Type systems/Programming Languages.

So, just recently I read The Third Manifesto, and since I'm interested in programming languages, dissatisfied with SQL, and thinking about databases I figured I would post some of my questions here.

I don't know that much about modern type systems, but in the book, their discussion of type systems seems a little archaic compared to the sorts of things people bring up here. If there is anyone more knowledgable than I, I would appreciate some insight into how their stuff fits in the grand scheme of things.

Also, I recall in Concepts, Techniques, and Models of Computer Programming they discuss transactions and constraint based programming and do some connections with databases, but it mostly just left me wanting more. Has anyone successfully added the "Relational Model" to a programming language and integrated into the type system in a nice, and theoretically justified way?

I'm sorry if my questions aren't quite coherent. I don't know enough to ask it, but it seems like there are strong connections to their work with other areas of programming language research, but that perhaps the two camps have not gotten together and seen to integrate the two areas.

Oh yeah, I've read enough of DB Debunkings to realize that C.J. Date and company can be a bit ornery, but I just want to see how these two things intersect. I'm definitely not part of the camp trying to clamour for "Object Oriented/Relational/whatever" database, just someone trying to understand the theoretical aspects of databases in the context of programming languages.

PyCLIPS - expert systems shell in Python

PyCLIPS embeds the CLIPS "expert systems shell" in Python.

It appears to be a set of Python wrappers for the CLIPS C modules themselves, rather than a complete reimplementation in Python. In fact, the CLIPS engine runs in its own memory space and allocates its own objects. However, the integration with the engine is extensive enough to be of interest here, because some of the challenges it poses are similar to those involved in embedding one language in another (e.g. finding a good fit between Python syntax and the protocol used to communicate with the engine).

More details can be found in the manual, downloadable from the project's sourceforge site.

Info needed

I need references discussing the place of pl education in the CS curriculum.

Also: Which top universities (e.g., MIT, Yale, Stanford, Harvard, etc.) require (or don't) a PL course in their undergrad curriculum?


Epigram - incremental interactive typechecking

You can download Epigram itself and follow the tutorial. It's worth trying.

The part that most impressed me is the interactivity. I really like this halfway point between a structure editor and a free text editor.

I think this approach would be great for designing parsers as well, where you have the content to be parsed in a separate buffer, and you interactively build the parser and see which bits gets parsed.

Also, dependently typed languages are very nifty.

Papers' repositories

Was not able to find a section that would mention arXiv, CiteSeer and other repositories. Wouldn't it be nice to have one besides Research Papers, which is great, but covers specific papers and not "libraries".
The reason for using searches in the specific repository instead of Google is that some queries like "path tree graph free generated category product" result in much more enterprise related topics than category related when run under generic searcher (Google).

Embedding Prolog in Haskell

Luke once pointed to Peter Norvig's embedding of Prolog in Lisp as an example of the power of the language, and asked whether (or if) it could be done in Haskell. I said I would think about it, but never got around to working out the details.

Well, it turns out it's been done, and the essential bits are quite simple and intuitive, though macros would help to hide some of the abstract syntax-looking stuff (not apparent from the paper's append example).

J. M. Spivey and S. Seres. Embedding Prolog in Haskell. In Proceedings of Haskell '99 (E. Meijer, ed.), Technical Report UU-CS-1999-28, Department of Computer Science, University of Utrecht.

lua book available online.

XML feed