On Tue, Sep 2, 2014 at 1:35 PM, pi zero <wn.pi.zero(a)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?
--
Brad Jorsch (Anomie)
Software Engineer
Wikimedia Foundation