LtU Forum

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?

Binary relations

A while ago I read about an alternative to SQL called something like 'Binary Query Language', which models data in (to me) the more intuitive way, thinking of sets and different types of relations (in the mathematical sense) between those sets, rather than using tables, foreign keys, joins etc like the relational model. It lets you do queries based around these relations using functions and multifunctions in a quite neat almost mathematical way.

Does anyone know what (if anything) became of these ideas? the only reference to BQL I can seem to trawl up through google is on this site, which offers an interesting explanation, some examples and a basic implementation in C++.

What I'm thinking at the moment is how useful would it be to write some kind of abstraction that translates these kind of queries into plain SQL on the fly, having generated a suitable SQL type database schema from the 'binary relations' type model.

I guess there are a lot of Object-Relational database things around at the moment designed for persisting object-oriented classes, but I don't think that's quite the same thing?

The Language List

The Language List

Collected Information On About 2500 Computer Languages, Past and Present.

Languages Poster

The History of Programming Languages

OCaml doesn't exist, and Smalltalk seems to have ceased before Java 1 was released - but we can see every point release for Python, PHP, Java, and Ruby (is an animal book a requirement for being on the poster?) and bizarrely Self (Has Self ever been used for real?).


Lush is a dialect of Lisp designed for scripting numerically intensive applications, particularly machine learning. Less verbose than Common Lisp, it seems better suited to quick scripting tasks, yet it compiles to C and integrates easily with existing C libraries.

From the Lush website:
Lush can be used advantageously for projects where one would otherwise use a combination of an interpreted language like Matlab, Python, Perl, S+, or even (gasp!) BASIC, and a compiled language like C. Lush brings the best of both worlds by wrapping three languages into one: (1) a weakly-typed, garbage-collected, dynamically scoped, interpreted language with a simple Lisp-like syntax, (2) a strongly-typed, lexically-scoped compiled language that uses the same Lisp-like syntax, and (3) the C language, which can be freely mixed with Lush code within a single program, even within a single function. It sounds complicated, but it is not. In fact, Lush is designed to be very simple to learn and easy to use.
XML feed