Good article. Interestingly enough, there is a language that will run something strikingly similar to your first example ("read http://www.kimbly.com", specifically) — REBOL which is focused on the internet "problem domain." Unfortunately, it's a closed language.

The map is not the territory, although it sounds like you want the map and the territory to be interchangible. That is definitely Blue Sky stuff here (and to think I first came across TUNES *six* years ago and wrote them off as a bunch of hand waving lunatics---interesting to see them still waving those hands around). Personally, I would much rather have F=(G*m1*m2)/r*r than drop the computer out the window.

Now, to go on to your example of the URL and trying to work with it directly. You are right, a URL is a concept but there is a declarative descritpion (written in such a way that a programming language could understand) of a URL in RFC-2396 (BNF format if your curious). But that's only half the battle. You go on to say that you want to declare the relationships of the parts of a URL to, say, HTTP (HTTP protocol is redundant in much the same was as PIN number) but that it is hard to do. Yes, I agree to that. What, exactly does

get http://www.kimbly.com/

mean? What does it return? And where does it return it to? (as written, I would expect $_ to contain a reference to something, but I'm not real keen on Perl myself) And more importantly, the action "get" doesn't map cleanly to every form of URL:

get mailto:sean@conman.org

What does that mean? I certainly hope it doesn't mean you get my email (although, given the level of spam, perhaps that isn't such a bad idea after all). The actions allowed via HTTP are: OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE and CONNECT, each with their own semantics (POST is different that PUT), but of those actions, only POST can be said to apply to mailto: and even then it's more of a pun than anything.

And how to map these upon ftp:? Or even file://localhost/etc/passwd?

Perhaps a different example then.

I personally would love to make Flash animations. I've tried the Macromedia Flash animation program but found I couldn't figure out how to work it. It's not like I don't understand animation---as a kid I wanted to be a comic artist and a film maker so I'm not unfamiliar with the concepts (8mm film runs at 16 fps, 16mm and 35mm run at 24 fps. Professional animations run at 12 fps and typically use some form of cell based animation where there characters are painted onto transparencies, although an animator like Ralph Bashki (personally I can't stand his work) has also used rotoscoped techniques; I could go on about this ... ). I would expect a program to work with cells, frames and clips. And perhaps tracks for sound. A frame is made up of multiple cells. Clips are sequences of frames with an associated track for sound (so I guess at a minimum, a clip requires two frames, and a frame requires at least one cell).

Hmm ... lots of declarative stuff there, but I'm still no closer to an animation program than I was before.

So how is this Blue Sky stuff supposed to work again?

There's no reason you can't write (less line noise):
url = getUrl("http://www.kimbly.com")

If you language allows it then you could use this syntax:
url = getUrl "http://www.kimbly.com"

... but's that's just syntactic sugar.

(BTW, where do I find the text formatting rules for Moveable Type? I assume it's a bit wiki-ish.)

"Application programmers shouldn't have to do modeling."

Yes, they should. That's exactly what they should be doing. What I think you mean, though, is that application programmers shouldn't have to do modeling outside of their problem domain.

I was also a bit disturbed by this comment in the original discussion: "I think we should strive to make modeling unnecessary."

You can't make modeling unnecessary. Modeling is what writing software is all about; you can't avoid it. Modeling is the act of identifying what parts of your problem domain are relevant (because not all of them are) and capturing those in software. All we can do to improve this is to minimise the amount of unnecessary, incidental, modelling we often have to do.

"Application programmers never work with their problems directly... At no point do they ever actually refer to the problem domain itself."

In programming languages, types capture semantic information from the problem domain. Types also define what operations/behaviours are allowed. Compilers can use type information to tell you when you are doing something illegal/nonsensical. When you are using types, you are referring to the problem domain (or rather, the parts of it you want to model).

It's all very well to say "I want to express everything declaratively" but eventually your code has to be executed, on some machine, and so somehow, somewhere, actions must be performed. You must have some kind of underlying execution model that the programmer knows about. In the URL example, at some point software must perform the actions of the HTTP protocol to fetch the resource.

"... syntax instead maps to problem domain concepts, which then map to programming-domain concepts ..."

From the sounds of this, all you need are domain-specific languages, and easy ways to create them. Which we already have.

Sean, you just described a semantic model for your hypothetical animation program. That's great. Now you need two more things: a mapping from syntax to semantics, and a mapping from semantics to implementation. (The mapping from implementation to machine code is currently handled pretty well by compilers.) Programmers and Computer Scientists currently don't really have a concept of mapping syntax to semantics to implementation. Instead we go straight from syntax to implementation.

I think that by explaining the semantic model of your animation program, you are closer to having a runnable program than you were before. Now the compiler has some idea of "what you're talking about". You're doing the same kind of thing when you sketch out classes on CRC cards, or when you assign types to various pieces of your program (as Alistair points out). Just because you haven't started coding doesn't mean that this design phase wasn't necessary.

Your closing question simply emphasizes that semantic models don't automatically imply an implementation. And I think that this is exactly why it's important to focus on semantic models as distinct from programming language implementation -- otherwise we're skipping a step. You may think that step is worthless, but I disagree. I think that coding without a semantic model is what "real men" do -- like writing programs directly in machine code.

Alistair, thanks for clarifying what I said about application programmers not doing modeling outside of their application domain. That's what I meant. I was using "modeling" to mean "fitting the application to the structures provided by the implementation language". Also, I agree with your point about how types capture semantic information. Currently they're just about the only technique we have for doing so.

However, I don't think that DSLs are the answer to my prayers. A given DSL will have a particular syntax, and a particular semantic model, and a fixed set of implementation techniques. I want to separate all of these things, so that they can be chosen separately. But most importantly, I want the semantic model to be additive (i.e. composable with other semantic models). Every DSL I know of is based on a parser that creates a particular data structure representing the semantics of that DSL. This data structure is usually not extensible, and is frequently not even accessible. It is also usually highly tuned to implementation concerns (e.g. bytecode). What I want is to make this data structure be the actual output of the DSL, rather than merely an intermediate representation that is used as input for subsequent execution.

In a way, you can think of this as merely a different way of looking at macros and DSLs. And as with everything in programming, it's been done before. The goal is to make a language that encourages this style, and makes it useful.

Tangent: if we assume that types are the closest thing we currently have to a semantic model, then this leads to the question: are there DSLs for types?

And by the way, the formatting rules for Movable Type are straight HTML.

I want the semantic model to be additive (i.e. composable with other semantic models).

What does this mean? And what do you mean that a given DSL will have a particular semantic model? I would have thought that the semantic model for a DSL would be determined by the domain being modeled i.e. it would be the semantic model from the domain (unless my idea - admittedly vague - of what "semantic model" means is wrong). Which would mean that you couldn't choose it, which would mean that there's no value in separating it (if that's possible).

are there DSLs for types?

Yes. They are the syntax/language you use to specify type information to compilers. In Haskell it's separated from the code syntax, whereas in Java it's integrated with the code syntax (look at the type signature for a function - it's specified in the function itself). Although... you could say that Java interface syntax is a DSL for types, because that's what Java's interfaces are - types.

When I saw your "get http://www.kimbly.com/" I
immediately thought of some perl stuff
(In case you haven't guessed, I'm mostly
a perl guy). For example, look at something
like:
get http://www.kimbly.com/
Now, the program has to figure out what you mean,
just like a person who read the program would.
In perl, if you say 9 + "2.3" perl figures out
from the context that you want to treat the string as a number, and it does it's best to
interpret that string as a number. So, your
program might look at 'get' and decide it is
a postfix method or operator, then it could
look at http://www.kimbly.com/ and decide that
it is a url. Now, "decide this string is a
url" would probably be a pretty expensive
process relative to what most languages do
today, but this is basically what you are
asking for. Now, since the program has
decided that this string is a url 'object'
and there is the context of the unsatisfied
operation 'get', the progam executes the
get method of the url. Finally, there is no
LHS type context, so the program may throw
the result away, but a better response might
be to store the result in the default context,
which is called $_ in perl. Later, when you
write

get http://www.kimbly.com/
print

The program will understand that you want to
call the print method of the object that
resulted from the get method of the url
(could be an html page, or something else)

The more you generalize these sorts of
operations, the more expensive it is for the
machine, and the harder it is to figure out
when it doesn't do what you want, but this
is the cost of this DoWhatIMean approach.

-Kris