[wilig]

In most general of terms a programming language would be ideal for a problem domain if the domains problems could be expressed directly in the language. You would sit down with the domain experts and have a conversation, that conversation could be converted directly to code. In fact if the language was expressive enough the experts could express the problems directly to the computer. No current language, that I'm aware of, achieves this goal. However Clojure by nature of it being a Lisp, allows you to easily add to the language to bring it closer to the domain it will be used in.

It's certainly no silver bullet, and does add to the learning curve of new programmers, but if used properly can be a great tool for writing concise and correct code.

[bad_user]

My problem is that the code linked in the article looks ugly as hell. Even the micro-language created.

Compare this ...

    (filter (and (< :table1/a 5) (= :table1/b "x")) (collect :table1))

To this ...

    from row in table1
    where row.a < 5 and row.b == "x"

Also, compare this ...

    (collect :projects :invoices [:projects/id :projects/name 
           (as :inv_id :invoices/id) :invoices/date])

To this ...

    from proj in projects
    from inv in invoices
    select { proj.id, proj.name, inv_id => inv.id, inv.date }

For me the ideal programming language would be one readable by humans.

[jimbokun]

Maybe we can get it a little more Clojure-ish:

    (dosql [a :table1/a b :table1/b]
      (filter (and (< a 5) (= b "x"))))

Makes the filter part more readable (to a Lisper), and introduces variable scope in a more idiomatic manner. The macro needs to take care of the :table1/a expansion and substitution within its scope. dosql might already be taken but not important for my point, I think.

Maybe you still don't like this, but I think it reads a little better for someone used to Clojure.

[shaunxcode]

But can the sql be made to work w/ a non-sql storage engine? The lisp code facilitates this abstraction while raw sql is just that.

[bad_user]

That's not sql ... that's Linq from .NET. You can query with it whatever you want: in-memory data-structures, DB, Xml, LDAP.

Here's a MongoDB provider that has basic Linq support: http://github.com/samus/mongodb-csharp

Of course, the actual syntax of LINQ is baked in the compiler's rules, and you can't invent new syntax in the way LISP lets you to.

But why is that have to be the case? There's nothing stopping a compiler from being extensible, other than hard-work. I played with Boo for a month ... it comes very close to that. Perl6 also lets you do it, but it remains to be seen how good it is.

[shaunxcode]

touche, I should have studied your examples longer as the second one it is clearly not straight sql. I have always been a bit jealous of linq and I agree there should be a language which allows the compiler to be extended. Smalltalk allows this to some degree particularly the research done by SCG: http://scg.unibe.ch/research/helvetia/examples

[scott_s]

But are you complaining about Lisp syntax in general, or this DSL implemented using Lisp macros in particular?

[bad_user]

Both I think.

I'd like a language that lets me define syntax that's readable by kids with basic english/math skills.

From the languages I've tried, Boo came closest to that, but the error messages it throws are awful, and development seems to have stagnated. Maybe Perl6 will be that language, who knows?

Haskell also seems to have a macro-system, but I wouldn't call Haskell a language readable by kids.

[scott_s]

Two points: if your complaint is about Lisp in general, then it's not really relevant to the post. Some people can read Lisp syntax just fine. So, for them, the DSL is readable.

Second point is that since the beginners know nothing, they don't have preconceived notions of what programs should look like. Having just taught an intro to programming course, I am very aware that even the semantics of something like "i = 2" can be misunderstood by beginners. One advantage of the Lisp syntax for beginners is that it's extremely simple and consistent.

[chipsy]

Chuck Moore has said almost exactly this about Forth. I think this is a property shared between all the low-syntax, high-power languages, including Forth, Lisp, Smalltalk, Lua, etc. But the downside is that there is an inevitable tooling issue where you can achieve concise constructions that read well, but the language and development environment don't "really know" what's going on in the problem domain's microlanguage and can't enforce the concepts or help to debug in the ways a specialized language implementation can. And so as your needs get bigger and you want to make a polished, easy-to-use package, you inevitably drift from libraries, to macros and meta-programming, to data files, and then towards the full parser/compiler/interpreter gamut.