On Thu, 1 Sep 2016 19:37:43 -0400, luke wallace <lukewallace1...@gmail.com> 
> Let's try to use wishful thinking in order to reinvent how to make lisp
> more accessible and useful to complete newbies.

Thanks for sharing your thoughts!  I'd prefer this discussion be public, if 
so that everyone can share in the results.

> The editor would do all the box drawing for
> you, and be saved as lisp in source files (the editor would just display it
> in readable format once opened).

As I understand it, you want to have a bidirectional translation within the
editor, so that what is *saved* is traditional Lisp code, but what is *viewed*
is some more readable format.

Interestingly enough, bidirectional translation is already *partly* possible 
the readable notations right now. We already have programs that translate each 
Presuming you choose the top level (sweet-expressions), you could convert to 
edit, then translate back on save.  It's not ideal though (see below).

However, there are several issues with bidirectional translation (translations 
on read and save):
1. You *really* have to trust the bi-directional translation tools.
    Even the slightest defect can cause problems, because "what you run" isn't 
"what you see".
2. You have to be careful on handling comments.
    The current sweetening routine drops comments outside the top level.
    This lossiness is not ideal, but for its intended purpose it's okay... but 
for bidirectional
    work it's not a good thing.
3. You either lose the formatting on both ends, or you spend a *lot* of time 
trying to
    "fix up" formatting.  If someone formats it in a certain way in the 
traditional Lisp code,
    it's tricky to retain that, and the other way as well.
4. If you work with other people who use different formatting, you can end up
    with a lot of pseudo-changes, which would greatly interfere with version 
control systems
    (it'd look like you changed a lot of lines, when it was just reformatted).
    This is easy to solve: Pick a specific formatter and its options, and 
*always* run that
    before saving.

It's certainly *possible* to do bidirectional translations.  But it's a lot of 
Most GUI programming tools, for example, store a representation of the GUI 
and only do 1-way translations from the GUI to the underlying representation.
You're certainly welcome to try some things out - I'm a little skeptical that 
it's worth
the work, but the proof is always in the doing.

--- David A. Wheeler

Readable-discuss mailing list

Reply via email to