Re: outline-minor-mode and org-mode capabilities for programming languages

[Jean Louis <bugs@gnu.support>]

* Christopher Dimech <dimech@gmx.com> [2021-05-10 04:49]:
> Whilst I agree that programming language modes do their thing well, and org-mode
> does its things well, the idea of headings and folding could be made to work much
> better for programming languages.  Additionally, there could be org-minor-mode
> that is specific for programming languages.  The people at org-mode would know
> best about the capabilities and functionalities that would entail.  We could also
> take some information out on their implementation.

You said org-minor-mode yet you maybe wish to say what features you
think could Org mode provide to Emacs Lisp mode? It is unclear.

Like should I mark functions with TODO/DONE?

Should I be able to open up agenda to know which function is to be
executed at which time?

Should there be properties?

Should I tag functions?

Am I able to hyperlink one function to other?

While this may sound apparently funny, I do think that type of editing
would be useful. 

One way to implement it could be to use the database backed chunked
editing where every function receives its database node and has its
attributes which are quickly cycled with TAB. It could show the same
what is shown in outline mode. As I am developing system that augments
thought processing I could simply define an Emacs Lisp programming
node, and enter in such node any chunks I wish. 

Then each specific function, thus database node, could be verified on
the fly if it is correct. A huge program could be written that way and
one could see which function is node is written correctly which one
not. It could create a file on the fly for final distribution. One
could reach any functions by its semantics, tags, properties, describe
them fully and thus augment human perception.

All the thousands of Emacs packages could be imported in that way
which would allow re-using of the code in a new fantastic manner,
searchable by semantics and indexes. No more worries on which function
was taken from which package, program could tell how it was modified
and would create the Commentar or log, and thus solve licensing issues
automatically.

Creating new specialized packages would be a breeze, just choose those
functions needed by its semantics and new narrowed package could be
created with its headers, licensing issues, modifications, as nothing
of that human need to think of. 

User is creating function for what? List related stuff? Just choose
the function by its semantic, completion or other menu system, even
review it, and it is inserted into buffer to create a new function. 

When attributes and description of the code is well done, and it can
be done fast, programmers would be able to tell in human language what
they need to do, and algorithm could tell how to do it, and which
available parts already exist. 

As we do not re-use enough. There are thousands of packages and we
don't have quite a good database to find what we need.

Example of lack of code re-use are various markup modes that in the
essence all do the same, like HTML has <strong></strong>, Markdown has
its **bold** and Org has *bold*, then there is list of other similar
markup that does essentially the same, code is re-written all over
again instead of defining the tags or markup as some kind of data, and
having it ready for user by some kind of universal mode that would
find major mode and type of text and automatically assign the
markup. 

And for each mode I have to use different key bindings, terrible. If I
wish to markup something as "strong" or "bold" face, I want to use in
every mode same key binding, not different.

Importing functions into a database would not impair running program
as a file or a distributing it, it could just help its structure
better. 

It would allow the true collaboration: on the multiple functions on
the same file several multiple users could work in parallel. On the
same function people could work by using crdt.el package, each
function and thus the node would have its automatic revision system,
not file based revision, rather function or node based revision.

It would be the Outline system, but Outline on a meta level.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/
https://rms-support-letter.github.io/