Good morning,
Whenever I learn a new programming language, I want to start by learning
about it's language model. The language model explains, among other
things, the order of evaluation, eagerness of evaluation, scope, and
binding approach. For example the Racket programming language has their
documentation here [1].
When I started learning `babel', I viewed it only as a means to and end,
the end being literate programming. Consequently, I just identified
goals and then either found a way to do it myself or had the kind and
generous `org-mode' users here explain the right way to do it. Please
don't take my laziness in learning as a mark of disrespect to `babel' or
to the community. The thing is that I failed to internalize literate
programming when I failed to view `babel' as a programming
language. Despite having read this [2] quite informative paper, I still
kind of missed the point. Now, I think that I get that I missed the
point, and here is how: when I read through [org-scraps], I still get
surprised and confused.
`org-scraps' is great. I understand 10% of it and have a lot to
learn. It never occurred to me that we may utilize the data structures
that define the document itself. That is so /lispy/. Looking at how one
may easily utilize souce code to assemble the very document in which it
is defined is really, really great. When I play with it though, I get it
wrong. My language model in my head is wrong, clearly.
My goal, then, is to develop a correct language model for `babel'.
My questions are:
• What is the best possible way to approach this goal?
• How have other `babelers' been documenting their pursuit of that goal?
Some thoughts on the goal:
• Thinking of a typical LISP language learning approach of evalutaion
and binding review and study
• `org-scraps' does this already, I just don't understand it
• Thinking of a flow chart of how things are processed between
• The document
• The meta-language in which `babel' itself runs via emacs-lisp
• The guest languages managed and data-brokered with `babel'
• Target audience would be `babel' users but not implementers
• Wouldn't need to dig into the source or `babel'
• Or is that the best approach?
• Measure of success would be to have people be productive without
using up the time and resources of the `babel' maintainers
• Perhaps users who want to understand the language model would need
to also learn [org-element] just as one would understand how to
parse/implement a LISP interpreter in LISP?
Looking for comments, questions, and concerns about this goal.
Kind regards,
gcr
[org-scraps]
https://raw.githubusercontent.com/eschulte/org-scraps/master/scraps.org
[org-element]
http://orgmode.org/w/?p=org-mode.git;a=blob;f=lisp/org-element.el;h=352482ef825fa495fd4e0daa7f6f236a442d2b01;hb=0be96db56e0ab973463376997fe1198a28d89e5b
Footnotes
─────────
[1] [http://docs.racket-lang.org/reference/model.html]
[2] [http://www.jstatsoft.org/v46/i03]
