I'd be perfectly happy with a LaTeX-based solution, although I
understand the appeal of something more "within Clojure".

As a first approximation, literate programming needs to make it easy
to enter English text with code snippets that run.  Haskell does this
by assuming that in a file ending in .lhs (as opposed to .hs), by
default, a line is plain English text unless specifically marked as
code (instead of the other way around).

This is a good start, but Knuth's conception of literate programming
usually supports breaking code into very small hyperlinked chunks,
cross-indexing up the wazoo, and language-aware formatting and
indexing.

And honestly, I find none of this is much use without an
editor/compiler/debugger that understands this format.  So in my mind,
that would be the real challenge.  Rather than just make tools that
tangle/weave Clojure/LaTeX, I need to be able to easily edit and then
compile that to the REPL in Emacs/Enclojure/etc.  [Note to self:  Go
look at that orgmode link after writing this email]

In the rare cases where I need to write something literate without
explicit tool support, I use funnelweb.

To me, the downside of literate programming is that it makes it much
harder to refactor.  I have a vague idea that the holy grail of
literate programming would be to have two editing windows side by
side: one shows you where you are in the tangled code and one shows
you where you are in the weaved book.  You can put the focus on the
code-centric view or the literate-centric view, and as you move the
cursor in one window, the view in the other window jumps around.  So
it would be equally easy to edit in either view.

I've heard that Leo is the existing tool that comes closest to this
idea, although the one time I tried it, I felt like it was only giving
me the ability to look at my code in super-small chunks, and I
couldn't figure out how to get the "big picture" view where I see
everything on one page.

In any case, any of these tools, even the most basic, if integrated
with the rest of the Clojure edit/compile/eval/debug process in some
editor (I've been primarily using Emacs but am gradually starting to
prefer Enclojure), would be something I would likely use.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to