Re: Making Lua unique through supporting natural language texts as valid script code

[Sean Conner <sean@...>]

  My, there is a lot to unpack here, and most of it not related to Lua.  All
I can say is that you should read _Thinking_Forth_:

	https://thinking-forth.sourceforge.net/

It covers a lot of what you are talking about with a computer language that
is probably more suited to this type of thing than Lua.  Also, over the past
40 years, I've come across plenty of projects that aim to do what you are
doing---computing has become corrupted and you are on a mission to fix the
problem.  Some of the ones that come immedately to mind are TUNES, Loper OS,
and BlueAbyss.  At least one of these dates back to the early 1990s.

It was thus said that the Great Claudio Grondi once stated:
> 
> On 10/1/23 21:33, Sean Conner wrote:
> >   Yes, a new editor or system can be created that allows the use of
> >non-printable characters, but now you have to convince people to use your
> >editor or system.  And the industry is littered with such projects, most
> >never finished.
> 
> In my eyes the attempt to try to make software working on any hardware 
> platform and with any operating system out there limits the freedom of 
> features and options and leads to code extremely inflated in size 
> because of coming with all the options you don't need on the platform 
> and OS you are using. It goes that far that code handling the cases 
> takes much more storage space than the actual code you need to provide a 
> feature. The object oriented approach pollutes because of the for the 
> actual function unnecessary usage of multi-level indirections the code 
> even more. The core functionality gets this way buried below the part 
> handling all of the possible cases and leads to increased download size 
> and storage space and as a consequence of this to increased amount of 
> energy required to handle it.

  Everybody agrees that Microsoft Word is bloated and has way too many
features, but the problem is---everybody uses a different subset of
features! Software I write for my own use, sure, I can tailor the feature
set to just what I use, but other people will have their own opinions.  I
know that back when my blogging software [1] was used by others, I had to
spend considerable time to support a feature I wanted than the other users
didn't want.  That took more code.

  Also, read "A Spellchecker Used to Be a Major Feat of Software
Engineering":

	https://prog21.dadgum.com/29.html

for another reason for the so-called "bloat" in software.  Also "Slow
Languages Battle Across Time":

	https://prog21.dadgum.com/52.html

> Why should I bother that your preferred editor can't handle the input of
> the full ASCII range? It's your beer what are you are using and you need
> to live with the consequences of your choice. If the core of the oOo idea
> is nothing for you, than it is just that way. It's not helpful to point
> out that you are not ready to spend some thoughts on it.

  I'm already spending thoughts on it.  And it should bother you because you
are the one proposing using non-printable characters in a meaningful way in
a programming language.  I'm just pointing out that it's difficult *on
current systems* to support such a thing, and thus, it's probably not going
to happen any time soon.  If you pay attention to the criticisms, you may
learn something---you may not like it, but so far, the criticism has been
spot on in my opinion.

> > Also, what does "oOo" mean?  "Out-of-order"?
> > "Object-Oriented-something?" It's not clear.
> 
> One of the goals of  oOo  is to care about the aesthetics of the code. 
> oOo ... is just round and not edgy with multiple line ends. Why not 
> accept a nice looking name without asking about an acronym or 
> abbreviation? Why not just enjoy the picture? `o` stands for what a 
> human needs for understanding, `oo` stands for the code required to 
> create executable files, `ooo` stands for all the executable files which 
> translate between different "languages". The revelation of the oOo 
> system is to see computing as nothing else as translation between 
> different languages ... to get the core of the idea is maybe not easy if 
> your way of thinking rejects the fact that what software actual really 
> does is to translate a number from one language to another. But it 
> appears to me that once accepted this kind of point of view will lead to 
> simplicity ... like the heliocentric point of view did in the past.

  No need to get defensive here, I was just asking what 'oOo' stood for,
since you didn't define it explicitly.  But you should get used to being
asked that if you keep on using the term.  

> The core idea of oOo is that the possibility to use own language is 
> perfectly in line with it. YOU create the language you want to use to 
> communicate your intents to the system instead of using a language 
> created by someone else you need first to learn in order to understand 
> the context out of which another person created it in this and not other 
> way.

  So ... what does this have to do with Lua?  You seem to be contradicting
yourself here---you want to use (and change) Lua, a language created by
someone else that you first need to learn, in order to ... create your own
language?

> What is wrong with
> `x = 255 y = 15 z = x+y`
> ?
> In my eyes it leads to freedom of using
> 
> `a = 255 b = 15 c = a+b`

  I still don't see a problem there.

> where what actual happens is addition of two numbers. My gut feeling 
> tells me that
> 
> `addTwoNumbers` is what actual happens ... is the actual action. 

  Yes, it's the actual action, but it doesn't explain the why.  You could
have just written:

	c = addTwoNumbers(a,b)

  But a comment as to why you are adding two numbers (if it isn't obvious)
would work.

> With some consequently used conventions the function addTwoNumbers will
> load a number value from the file named `x.in` and from the file named
> `y.in` writing the result to the file named `addTwoNumbers.out`. This
> makes what happens available for any language and any other executable to
> perform further actions on it.
> 
> In my eyes there need to be a function: `obtainValuesFromFormula` which 
> will load a string from a file named `Formula.in` containing the string 
> `a = 255 b = 15 c = a+b` and writing to the file named 
> `obtainValuesFromFormula.out` the string: `c = 270`. This way you can 
> use the approach with assignments if you like to use it and need for 
> this purpose an "intelligent" function which will be able to "know" what 
> to provide as result. With a file storing `c = 270` you can use the 
> string in any programming language of your choice for further processing.

  This concept already exists in two different (but related) forms---FFI
(foreign function interface) and RPC (remove proceedure call).  In the
former, it's a way to allow one computer language to call a function written
in another computer language where both functions reside in the same
program.  RPC allows one program to call a function that resides in a
separate program (either on the same system, or somewhere on the network). 
That there are two different concepts relate to the differences in execution
(there are engineering trade-offs between the two).

> > You need to clarify your ideas, and personally, I'm not sure if Lua is
> > the best choice for this---yes, the code can be modified but at that
> > point, it's no longer Lua.
> 
> The idea is that it can be beneficial for Lua to provide the 
> modifications without breaking what is already there and extending this 
> way how it can be used. Making it possible to write code which reads 
> like usual text and at the same time perform what is described may help 
> to make Lua the most popular programming language out there ... It 
> should feel like a conversation with ChatGPT ... able to generate 
> scripting code out of precise instructions given in spoken language and 
> make the code executable to achieve what was described as required.

  Well, ChatGPT can already generate code in any computer language right now
based upon an English (or other spoken language) description (whether it's
correct or not is a different matter).

  In any case, good luck in your endeavor.

  -spc

[1]	https://github.com/spc476/mod_blog