LtU Forum

The Language Wars are Dead; Long Live the Language Wars!

The [New] Great Computer Language Shootout

This has probably already made the rounds of everyone's favorite language-specific mailing lists, but I hadn't seen it show up on LtU. One of the Debian developers has taken it upon himself to re-implement the infamous "shootout", which hasn't been updated since 2001. Most included languages have had compiler/runtime/interpreter upgrades since the original, so there is definitely some new data lurking around in all those familiar old microbenchmarks.

ECMAScript for XML (E4X) Specification

ECMA has approved the ECMAScript for XML (E4X) Specification, which defines the syntax and semantics of a set of programming language extensions adding native XML support to ECMAScript:

E4X adds native XML datatypes to the ECMAScript language, extends the semantics of familiar ECMAScript operators for manipulating XML objects and adds a small set of new operators for common XML operations, such as searching and filtering. It also adds support for XML literals, namespaces, qualified names and other mechanisms to facilitate XML processing.

E4X goes back to a request by BEA in March 2003.

Nets: Petri vs Lafont

I am currently playing with an idea of a PL based on Petri nets (place/transition nets) augmented with Prolog-like unification.
It just occurred to me that though PNs may be cognitively good for many developers (they express static topology of the system explicitly), Interaction nets may be more suitable for expressing some dynamic features.
I was trying to find any papers on relationship between Petri nets and Interaction nets, but found only indirect link through linear logic.
Is anyone aware of theoretical possibilities to (bi)simulate PNs with INs?
Or any other result about their comparative expressiveness?


Hans Nowak has a post about Poplog. I've never heard of it and I don't really get what it is, but I figured some here might be interested so I thought I'd mention it.

Elementary Category Theory

Recently I started learning CT, and I'm trying to express the property "set A is contained within set B" (in the Set Category) using CT language only, but I'm quite stuck.

This bothers me for some time now, so I was wondering if someone here has any leads?

Thanks in advance!

gmane hosting?

Hey, for those of us who abhor web browsers and love newsreaders, could you guys feed to At the simplest level all it would require is sending an email to a designated address every time a new article is posted, but there are much more interesting possibilities beyond that.


Fabian Pascal on XQuery

I think Pascal's style of argumentation is a model of how not to do it ("it" in this case being the remedy of ignorance and the construction of informed consensus - or the setting of terms for informed debate), but be that as it may - he makes a few good points here:

If you liked SQL, you'll love XQuery

Among the good points that he makes are these:

  • If XML's point is to be language-independent, why an XML-specific language?
  • If XML's point is to be database-independent, why reinvent the data management wheel (and, we shall argue, a "square wheel" at that?)
  • If XML is for syntactic interchange, can it be used for semantic data management?

Pascal's contention is that XQuery's language design cannot achieve its goals because of the designers' neglect of fundamentals (by which he means the Word of Codd). What are the foundations of XQuery? Is Pascal's preference for Codd's relational model over models based on graph theory as dogmatic as it sounds?

Is "type" a fundamental intrinsic property of values?

I've recently been doing some experiments with Tcl (which is untyped, or mono-typed; everything is a string), in particular working on a package (called TOOT) which allows types to be created (in a vaguely OO fashion) and then associated with values. The method for associating a type with a value is to create a new value consisting of a tuple (type,value) where this is represented in Tcl as a list of two elements: the first being a command name representing a type, and the second being the original value.

It struck me that the key concept here is that all values stored in a computer have no intrinsic type. That is, you can never actually store a number in a computer, only a representation of a number, for example. When you associate a type with a representation, you create an interpretation. Performing some operation on a value implies interpreting that value in some way, but different operations can apply different interpretations (the "type" is an extrinsic property of the value).

The package I am developing allows creating functions which encapsulate some interpretation of a value, much like classes in an OO language. This type-function can then be curried with a particular value to create a default interpretation of that value, which can then be passed around. Other operations can then either use this default interpretation, or ignore it and apply some other interpretation to the underlying representation.

This seems to be a quite different view to that embodied in most mainstream languages that I've come across, where values have a fundamental, intrinsic type. This isn't my area at all, so I thought I'd ask here for expert opinion. Is this a valid viewpoint? Is it an important distinction (between intrinsic and extrinsic typing)? Pointers to relevant theory, etc would also be greatly appreciated, and I hope this is on-topic.

Microsoft Phoenix

Microsoft Phoenix
Phoenix is a software optimization and analysis framework that will be the basis for all future Microsoft compiler technologies.

Some stupid questions on denotational semantics

I am not sure whether it is appropriate to ask for advice in this forum. If it isn't, please feel free to ignore/delete this message.

I have some questions regarding denotational semantics. I know operational semantics very well, but I did not yet understand some basic things about the denotational approach.

1. Every textbook says that "compositionality" is a very important property of d.s. I understand what this means. However, I have nowhere read *why* this is such an important property and what the consequences of being compositional are.

2. The examples of d.s. that are in most textbooks are so simple that they look trivially equivalent to a corresponding operational semantics. However, I read that d.s. is a more "abstract", "high-level" approach to describing the semantics. What would be an example where this property is evident in comparison to op. sem. ? Also, what are in general the advantages/disadvantages compared to op.sem.?

3. I have heard people say that writing an interpreter for a language in Haskell is roughly equivalent to writing a denotational semantics for it. Could somebody enlighten me why (or why not) this is the case?

XML feed