On Tue, Sep 2, 2014 at 1:35 PM, pi zero wn.pi.zero@gmail.com wrote:
(1) It's very easy to use.
[...]
(2) it naturally promotes incremental learning.
When it comes to your extremely complicated templates with embedded lisp, you're losing *both* of these. It's no longer very easy to use (although it seems you may consider cargo-cult programming to be "easy to use"), and your hypothetical "incremental learner" is more likely to be overwhelmed and give up rather than incrementally figure out where in some complicated mess filled with braces and parens the actual page content is located. We already have user studies (which I don't have the links for offhand) that show that people see the relatively simple infobox templates in articles and give up.
The advantage to having the complexity of Lua in modules is that the complexity specifically is hidden from new users. Once someone gets to the point where they're ready to make that step, they're probably motivated enough that looking through the manual (or even better would be if someone would write some good tutorials) isn't likely to be the barrier it would be to a complete newbie.
And, Lua is a high-overhead language. You can't just write super-simple expressions and have them work, and build other stuff up.
Sure you can; a little boilerplate is needed, but both that and the language itself are simple enough that someone could start from some basic examples and experiment easily enough. And we have a console on module edit pages that allows for direct experimentation with simple expressions.
Lisp, on the other hand, has extremely simple, unambiguous, low-overhead
syntax. (Even simple template calls have more syntactic overhead than lisp function calls.)
On the other hand, Lua's syntax and operation is similar to that of C, PHP, JavaScript, and so on, which are likely to be familiar to users with some sort of programming experience. While parser function syntax somewhat resembles Lisp, I'm not sure that similarity will help with understanding more than the surface.
I'm not also sure that Lisp's extremely simple syntax is necessarily an advantage. While extra syntactic structure requires extra learning, it also means that the written code is more structured which may be easier for humans to make sense of. Again, look at the trouble people report in understanding complicated templates.
Of course, my primary goal was interactive pages, for building wizards, and it was clear to me that Lua wasn't going to help me with those anyway.
I don't see how Lisp is helping that either. If you want interactive pages, JavaScript is the way to go. Or did you write your Lisp parser in JavaScript too?
Scribunto isn't an improvement to templates; it's trying to half-replace them with something else. My understanding of "improve templates" would exclude a half-replacement (or full replacement), even if the half/full-replacement were to "improve *on* templates".
Isn't your Lisp stuff also half-replacing templates with something else? Or are you overlooking that because Lisp syntax resembles that of templates?