Lambda the Ultimate

Kim Rose and Ian Piumarta have put together a hardbound, soft cloth, foil stamped book in honor of their friend and colleage, Alan Kay.

See: http://vpri.org/pov/

Click on the blue book for the free PDF version. You can also purchase a traditional copy.

The Glasgow Haskell Compiler and LLVM

I believe this has been discussed earlier, but I just stumbled upon this blog entry, which concisely describes the bits and pieces of the GHC LLVM backend. It is good to read that it will be worked further on that (GSoC & MSR internship).

eCD Market has openings for full-time FPers in Chicago who also have experience in or want to learn highly available distributed systems architecture.

We are a supply/demand aggregation company. We use Erlang, cloud hosting, highly available services, distributed database technology, market data visualization, and order placement/fulfillment workflow interfaces.

Send resume to enewhuis [At] ecdmarket {dot} com.

I'm looking for a name for, and work that's been done with, a certain model of computation. I'm guessing it would come up in untyped denotational semantics. The basic idea is to take computations to be their behavior on symbolic parameters.

Define n-computation as infinite data (in pseudo-syntax):

data Comp n:Nat = Diverge | Parameter (0..n) | Computation (Comp (n+1)) | Apply (0..n) (Comp n)

Here 0..n is the type of an integer in that range. The four data constructors' meaning is, when supplied a parameter:

• Diverge - Diverge
• Parameter m - Return the mth formal parameter seen "thus far" (see below)
• Computation f - Return the computation f
• Apply m f - Apply the mth formal parameter to computation f

Basically you treat a computation as a little machine that accepts a formal parameter, and computes as much as it can until it either can return a result or needs to apply one of its formal parameters as a function. The natural numbers index the formal parameters in the order that they were applied. Computations have an "evaluation strategy" baked into them, so there is a natural order. You start with a 0-computation, and you might get back a 1-computation. This is conceptually a function closed over the first parameter, but all such bookkeeping is left to the environment. For example:

id x = x
idComp = Parameter 0

const x y = x
constComp = Computation (Parameter 0)

apply f x = f x
applyComp = Computation (Apply 0 (Parameter 1))

A closed term in the untyped lambda calculus would have an associated 0-computation. There are uncountably many 0-computations, though, so it's not anything like a correspondence (and thus, despite the name I've chosen, most 0-computations are uncomputable).

That's not as clear as I'd like, but hopefully it will do. Anyone have a name for these things?

There is funding and support for doing real-world programming with parallel Haskell here.

At first the terminology sounded a little crack-pot to me, but I'm less of that opinion after trying to follow-up on AgileWiki and "rolonic" theory. Of late the lead, Bill, has put out some videos explaining things, and I found What Makes AgileWiki Different? to be interesting - there's a dose of theory (rolonic, as they've termed it) which underlies it all, and the spirit is to make languages and development better, hence I thought it not totally inappropriate to mention it on LtU.

Simple scenario: I'd like to implement a "copy-string" or "substring" style routine 1) in a language where strings are typically functional; 2) without leaving all such routines to the RTL in another language; 3) without depending on some other inefficient (for these purposes) other RTL functional primitive like "strcat"; or 4) without always relying on using lists as intermediaries for every such low level routine ala "list->string (string->list s)" which again likely relies on non-functional RTL level routines anyway.

Same would go for various array initialization routines, supporting constructors for (otherwise functional) Smalltalk style variable sized data structures, and on and on.

So I seek papers, sample languages and wisdom on potentially clean language mechanisms and their semantics for allowing side effects, say during string/vector initialization as above or in some other possible scenarios (memoization? dunno), without totally letting the non-functional cat out of the bag, as it were.

My interest in this issue is pragmatic (implementing an efficient stdlib/rtl while minimizing code written in a different "lower level" language that would not likely share important properties of the target language) as well as intellectual.

Thanks much!

Scott!

I was toying with an object system in Haskell and I encountered (created?) the following function:

f :: Contains r r' => (r' -> (a,r')) -> (r -> (a,r))

where any value of r contains a value of r': the function is the best answer I have found so far to the problem of "casting" a value of r to its supertype r', doing some work on it that gives a value of type a and a new value of r' and then replacing the resulting r' into the original value of type r. To me this reminds some sort of binding, but I was wondering if anyone here more expert than me could suggest a better interpretation of this operation.

I'm interested in hearing what people who study programming languages think of the emerging field of "critical code studies" in the humanities.

Here are a couple of descriptions from a recent CFP and an essay by Mark Marino:

Critical Code Studies names the practice of explicating the extra-functional significance of source code. Rather than one specific approach or theories, CCS names a growing set of methodologies that help unpack the symbols that make up software.

Critical Code Studies (CCS) is an approach that applies critical hermeneutics to the interpretation of computer code, program architecture, and documentation within a socio-historical context. CCS holds that lines of code are not value-neutral and can be analyzed using the theoretical approaches applied to other semiotic systems...

CCS is largely distinct from the more ethnographic work in "software studies" by people like Christopher Kelty, whose book Two Bits has been discussed on LtU. Marino held a CCS working group session this spring, and there's a CCS workshop at ACM Hypertext this year. Some important texts for the field are Katherine Hayle's "Traumas of Code" and Rita Raley's "Code.surface || Code.depth".

I'm personally skeptical—not necessarily about the general idea, but about the current direction of the field—for a few reasons:

1. A lot of CCS work is written in dialects of crit-theory jargon that I don't claim to speak fluently (and I'm a humanities grad student), but the parts I do understand often seem deeply confused or misguided. Here's a quotation from a post by Marino on the CCS blog, for example:
   

   Yet, somehow, I can't help but wonder if slower is not sometimes better? (Humanities folk can afford to ask such questions.) Could there not be algorithms that do a better job by including more processing cycles? Such a naive question, I know.

   You don't have to dig very far in the links above to find many other examples like this.

2. The focus is very strongly on imperative programming. Haskell and Scheme score zero mentions on the CCS website, and Lisp appears once (in a bibliography). In my experience this is representative of other work in the field. An imperative-only approach doesn't seem like a very interesting or thoughtful way to tackle a "semiotics of code".
3. As far as I can tell, not one of the three-dozenish scholars listed as associated with the CCS blog or the recent working group has a degree in CS or math (most are currently in new media or English departments). Maybe this is by design, given the goals stated above, but I'd still like to see more of an indication that this "growing set of methodologies" is of interest to people outside the humanities (if in fact it is).

Is there a place for "a semiotics for interpreting computer code" in the humanities? Do you PLT folks need help "unpacking the symbols that make up software"?

Is there a way to automatically compute the complexity of a piece of code?