-------- Forwarded Message --------
On 10/2/23 06:52, Sean Conner wrote:
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/
I have took a look at Forth. It's story began like these of oOo
with the Tower of Babel, but ... its seems to be the only common
thing. Forth appears to me not really useful for anything. It
forces me to provide the arguments obeying to its syntax before
the operators or functions in the script code and what I have seen
yet as programming examples looks so cryptic and ugly that it
makes from my perspective no sense to look deeper into it. I am
quite sure that Forth is not the way to go. At least for me. Maybe
someone else way would be to create the own oOo system using
Forth ... but it won't be my path to accomplishing the goal of
making the system understanding the language of my own thoughts.
What I was asking was where to look at source code of Lua to patch
it in order to make possible what I have asked for. What I have
got up to now is a list of reasons why what I want to achieve
shouldn't be done or why it would not work. It seems that there is
no one there reading this having enough deep insight into the
source code of Lua to understandably explain how could it be done
and provide a helpful and easy to understand useful answer. The
Lua source code, like the source code of most of the open source
projects lacks clear structured description of the main idea
behind the code and the details how the code elements are arranged
into the big picture and what they do in detail and what are they
for. I suppose that ChatGPT would generally be able to provide
some insight, but the free version I have access to does not
accept enough lines of code to get at the level of the big overall
picture.
Open Source with code which is much too hard to read and
understand to allow an easy way of making own custom adjustments
to it is as good as closed source code. It is very easy to
obfuscate code to a degree that only a small number of experts are
able to work on it (one of the best examples of this phenomenon is
the source code of the graphic engine of Emacs). Such open source
code is not really open source ...
From my perspective the oOo project can't fail due to programming
issues, because it is not really about programming. The by me
asked functionality would be just nice to have and provide the
means to demonstrate what oOo is all about instead of
communicating the guidelines only which need to be deeply
understood to get someone else started on the proposed path. Such
demonstration would not be what need to be used or copied ... just
only an inspiration showing one of the myriad paths how can it be
done to anyone ready to invest time teaching the system to
"understand" his own specific "innerMindLang" (a term describing a
set of thoughts your mind needs to describe the request what needs
to be done by the system and how).
The only reason why oOo can fail would be to fail to communicate
very clearly what it is about or to fail because there is no one
there with the gut feeling it must be another, simpler way of
approaching usage of a computer system. No one ready to follow the
path. For all these people trapped deeply in the "Matrix" of the
mainstream thinking about programming (I relate here to the Matrix
trilogy only because I have not seen the fourth part of the series
starting with the movie "Matrix") it would be hard to understand
what the approach is all about without a demonstration of at least
one example of how it can be done. And even with a well designed
and easy to copy demonstration it would require willingness to go
the path as it needs own efforts and readiness to take over the
responsibility of the proper functioning of the self-designed
system. The oOo approach can fail to be the right path for
everyone as sure not everyone is capable of putting own thoughts
on a consistent path making it all easier. Some people like the
dirty and complicated way because they deeply believe it must be
that way and simplicity won't work for them. Maybe is this also
the reason why Lua isn't the programming language number one on
the list of most popular programming languages and why Microsoft
Windows OS is still on the market instead of being only a part of
as good as forgotten history.
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---
I haven't yet seen any ... may you provide examples with links I
can look into to judge for myself about the actual aim?
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.
My search engine seems to fail to provide useful links to check it
out what you are speaking about ...
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.
Yes, thanks for your attention and the response. It's a pity it
does not provide the answers I am looking for, discussing the
reasons and the difficulties which are maybe not really there.
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.
Sorry, but I failed to understand the core of the difficulty and
not able to see where the criticism helps me to see what I haven't
seen before myself. There are plenty of text editors out there ...
myriads ... most of them just not really useful except for some
basic functionality. Many oversized keeping you busy with creating
overviews and helping you to manage the mess you are creating
instead of helping to clean it all out of your way.
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.
Defensive? Why defensive? I am glad you have asked ... so that I
have got the chance to provide an explanation.
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?
I could surely start from scratch ... but why should I when most
of the wheels I need for the ride are already invented?
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.
I just optically don't like the braces ... so simple ... and I
don't like to watch the equal sign - it's not round ... just
straight lines ... with four ends ... it's not a pattern pleasing
my eyes like a nice round contour of oOo do ... From this
perspective most of the words of the English language come along
with letters I would like to avoid to see. The extreme cases are:
T, t, x, X, #, V, v, W, w , I, ... They are "barriers" with sharp
ends of the straight lines ...
Yes, it's hard time if you don't like the usual way of writing a
text ... but ... with appropriate customization it would be
possible to refrain from using it .. providing fun and the eye
pleasing experience like looking at the mostly green but also
colorful world of plants on a meadow ... The power of the data
processing would then make it possible to convert the "round and
colorful the eye pleasing world of custom representation of own
thoughts" into a message in any spoken language to get the idea
out to others.
It's really crazy world ... people try to put texts anywhere ...
pollute even the forest with tables full of text explaining what
this or other tree is ... where the tree speaks for itself with
its shape - you need just to watch it with an eye ready to get the
details ... instead of reading some text.
oOo oo @o oOOo-o@@@o .o.OO ... plus beautiful rainbow colors
... This would be what I would like to see on the computer screen
instead of letters. The texts of most world languages are not
round ... are missing to be an eye pleasing experience ... A world
without "not" replaced by what it is, instead of saying what it is
not ... a "yes" based communication ... that's the actual vision
of the final stage of oOo ...
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).
From my perspective it is like creating a mechanism which is cause
of trouble in first place and then provide further tools helping
to avoid part of the trouble. This way you have always enough to
do ... just create some mess in first place ... then create tools
to clean up parts of the mess introducing some other mess you can
then provide tools to clean it up too ... and the actual job which
has to be done gets fully forgotten on that way buried below all
of the mess and the cleaning tools. It's the Microsoft way of
doing things ...
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.
Thank you much for your efforts and voluminous response.
Claudio
-spc
[1] https://github.com/spc476/mod_blog
