On 10/1/23 21:33, Sean Conner wrote:
The major problem here is allowing Lua to use STX and ETX to mark
long
strings, but getting existing systems to make it easy to type STX and
ETX.
I would be hard pressed to get my preferred text editor to include those
characters into a file, expecially ETX (which is Ctrl-C, which a lot, *a
lot* of programs, interpret as an interrupt character.
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.
In other words you are forced to spend your money on paying increased
electricity and used online download size bills just only because of
the craziness of the mainstream approach. Why using my Linux Mint 21.2
Xfce system should I spend more money for my electricity and download
size bill just only because there are also Microsoft Windows or Apple
systems out there??? 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.
On 10/1/23 17:51, Lars Müller wrote:
2. allow function calls by specifying the function name only
(without
using braces and without the need of passing a parameter)
2. Would break existing code and introduce many syntactic ambiguities.
Consider the simple p = print. Is this an assignment p = print() or an
assignment p = print?
In my general concept of an oOo system using a text editor for invoking
executable actions instead of a shell usage of an assignment isn't part
of the concept. And because p=print() and p=print is already handled in
Lua, there is no need to worry about ambiguities. It's ok as it is ...
As Lars stated, this would break existing code:
function f() return 42 end
x = f ; print(x)
function: 0x8cc2020
x = f() ; print(x)
42
As you stated above:
Lua would require some minor changes only, which if I am not mistaken
won't break any past code and should be relatively easy to
implement, in
order to support natural language texts as valid script code.
This breaks existing Lua code.
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.
3. extend [_a-zA-z0-9] characters allowed in symbol names with
ASCII
value 0x1F (Unit Separator) and `-` which will be treated like
[0-9] not
allowed as first symbol name characters
3. Again a nonprintable control character. Adding hyphen would
introduce
ambiguities, breaking existing code again: Is a-b the name a-b or the
subtraction a - b?
`a-b` is clearly a name.
In your opinion. In mine, "a-b" is clearly two variables being
subtracted. And in most languages, this is the case. There is only one
language I know of (there could be others) where this would be a valid
label, and that's Forth.
To achieve subtraction you would need to
separate the operator from the variable names `a - b`. Like a*b
could be
also made a name .. In the general concept of oOo system a*b will be a
name of a function which performs multiplication of the value stored in
a variable with name `a` with the value stored in the variable with
name
`b`.
Why not logically AND the value of a with the value of b? Or
match the
pattern stored in a AND match the pattern stored in b (as in LPEG)?
It's your choice how you would like to have it. oOo is about
customizing. Is about creation of own way of expressing functionality.
For your own purposes which need not to be commonly accepted or
understood. It's all about making the system understand the language
you use in YOUR inner thoughts and concepts for which there may be no
word or symbol known out there. You create it for your use case ...
and enjoy it like a person who trained the own dog to do tricks on by
self-determined signals. Why not put the effort of adapting the system
to what you like instead of using what the system comes with? If you
don't like the shape of `oOo` ... use xXx if it looks better in your
eyes. In my eyes xXx hurts, stops, eliminates, instead of creating a
nice round impression.
The idea is to refrain from usage of internal variable names in
usual sense, replacing them with a mechanism of getting the values from
appropriate named files. And as files allow any characters in them ...
there is actually no reason to restrict variable and function names to
[_a-zA-z0-9], but .. to achieve simplicity and avoid the need to cope
with utf-8 encoding and Unicode I tend to prefer the idea to stick with
one-byte ASCII and an own kind of encoding with appropriate true type
font for use in a text editor to write scripts.
Good luck in getting it adapted. People who don't speak English will
probably want to use their own language.
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.
Let me give an example of the main idea I want to create as a proof of
concept using Lua.
Let's prepare first some functions for later use:
function let_x_be(val) x = tonumber(val) end
function let_y_be(val) y = tonumber(val) end
function let_z_be_sum_of_x_and_y () z = x + y end
With this functions defined, Lua already allows to write following
code:
let_x_be '0xff' _=',' let_y_be '15' _='and' let_z_be_sum_of_x_and_y''
The result of the code above is:
x
255
y
15
z
270
And what's wrong with?
let_x_be = 255
let_y_be = 15
let_x_be_sum_of_x_and_y = let_x_be + let_y_be
That's a hell of a lot easier to type that your example. And if you
need to
explain why, you can always use comments. Or Literate Programming,
which
encourages one to extensively document the program without regard to
how the
code needs to be structured.
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`
where what actual happens is addition of two numbers. My gut feeling
tells me that
`addTwoNumbers` is what actual happens ... is the actual action. 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.
The actual problem I see is to explain to someone who is deeply into
the
existing programming mechanisms and paradigms what the final goal and
concept of oOo is, because it goes beyond usual understanding of what a
programming language is for.
The core idea is to use the keyboard to write a text in a text
editor and
invoke all the systems functionality from there using a custom language
created out of the available functionalities (mixing usage of
executable
files written in various programming languages).
Sounds like you are recreated shell scripts. Or Apple Script.
Also, how
would one use your system to write a new text editor that supported
these
ideas? Just curious.
The oOo system isn't actual a system you need to learn and to use.
This is what is maybe so hard to understand in first place. The oOo
system is a set of tools which should make it easy for you to create
your own system you can enjoy using because it is exactly as you have
created it yourself.
The oOo systems goal is to provide guidelines and a new way of
understanding what data processing actually is. Enabling the person
who has grasped what it is about to create an own specific custom
system able to "understand" the intention of the creator expressed in
a custom for this purpose created own language which could be for
example a language very near to the natural spoken English one as this
is the universal world language people agreed to use for communication
to others and probably also mostly to use while thinking.
HERE some main thoughts I was able to get written down out of the
"idea" which is the origin of it all:
The Tower of Babel:
The story of the philosophy behind the oOo art of shaping
thought processes and the related approach of creating a set of
conventions for the purpose of own custom individual design of a
human-computer interface begins at the Tower of Babel where God
confused the languages of humanity so that they could no longer
communicate with each other (Genesis 11:7).
individualMetaLang:
To understand what the concept of individualMetaLang is
about you need to know that there is something else "within" ("within"
in quotation marks because there is no known physical 3D
universe/world/body location you can track it down to reside there)
you which is more the actual you than by you percepted awareness of
yourself. The actual you is capable of watching your thoughts
injecting new ones into the present thought stream which then can
change own emotional state and as effect of that change the course of
own behavior. It is maybe fundamentally wrong to consider 'this
something else' to use a language, but it seems helpful to explain
what oOo is about using the concept/idea of an
individualMetaLang Meta-Language which requires translation to
individualMindLang Mind Language enabling awareness what the own
thoughts are about. For practical purposes the consideration of
interaction with the outer world and a electronic devices like
computers it will be sufficient to start the chain of origins of an
intention which needs to be communicated at the level of
individualMindLang , the level many people believe to be the actual
themselves and the origin of conscious decisions governing their
behavior. Find out what you believe to be the actual you asking
yourself the question: "Do I believe what I think?"
individualMindLang:
From the point of view of oOo a human being is interacting
with its environment using various different "build-in" and partially
redundant systems with one of them being the mind using thoughts in a
process called thinking with the main goal of generating useful
intelligent responses to continuously ongoing changes within the human
body and the far and near surrounding of it (the only thing staying
the same all the time being the only still part of the Universe is the
actual you at the level of individualMetaLang ).
The human mind uses chains of thoughts in the process of
interpretation of incoming sensory information about the ongoing
changes. These chains of thoughts can be considered to be a kind of
inner language specific to each single individual. Let's give this
language (which is a set of different ideas/ concepts/symbols/terms
and conventions of using them in a thought process) a name:
individualMindLang where Lang is an abbreviation of the word
Language and Mind indicates the context of a brain and thinking.
NatLang:
Let's assign to the set of tools a human uses in order to
share intentions, needs, observations, memories or information about
the own ongoing thought processes with other human beings a name
NatLang meaning Natural Language.
cnNatLang, deNatLang, enNatLang, ... :
The humanity developed since Babel many different languages.
oOo uses to distinguish between them the suffix used in Internet to
identify a country of origin of a domain name. So for example the
context of English language is described in oOo using "en"
and/or "us", the context of German lanuage using "de", the context
of Chinese language using "cn", ... . To achieve brevity in cases of
obvious context oOo skips mentioning the "Nat" part: cnLang,
deLang, enLang or goes one step further skipping "Lang" too: cn, de,
en, ...
PrgLang:
There are plenty of different programming languages created
for the purpose of programming a electronic devices (like computer,
notebook, cellphone, ...) . To express the context of programming an
electronic device using a text based file oOo uses the term PrgLang .
shPrgLang, luaPrgLang, pyPrgLang, ... :
oOo identifies programming languages using the default
file name extension used for naming of script files written in these
programming languages. shPrgLang means for example a shell script
file which commands are described by the POSIX standard, luaPrgLang
means a script file written in the Lua programming language, pyPrgLang
means Python as the target interpreter for the script.
In practice each existing programming language provides
functions/methods/modules which need an own specific way of usage by
passing to them information formulated in a way the
functions/methods/modules can process, i.e. using a specific
sub-language of the programming language. This fact contributes to the
"Tower of Babel" effect and may require further clarification. For
example pyPrgLangRegex indicates a regular expression pattern
supported by the Python build-in re module, where in order to
distinguish it from a regular expression pattern supported by the
external Python regex module the term pyPrgLangRegexModule is used.
Different versions of same programming language may support
different features using for this purpose a modified langage
contributing this way to the "Tower of Babel" effect. The consequence
of this is a need for further clarification of the context. In other
words, the general category of being for example a pyPrgLang
script may require further details like py2.7prgLang, py3.10prgLang, etc.
bashPrgLang, dashPrgLang, findPrgLang, grepPrgLang, lsPrgLang, ... :
The way how the parameter of an executable used on a command
line need to be specified to be properly interpreted by the executable
is considered by oOo to be a language specific to this executable.
To clearly identify in oOo the executable which is the context of
the "parameter-language", terms as for example grepPrgLang are used
in which the prefix is the base name of the executable file used on
the shell command line.
Once you have got the main idea of what I am actually after, then
you will
much better understand how to help to achieve it providing the
appropriate
language means making it possible. In my eyes Lua is the best language
available for this purpose if slightly modified to support more
freedom of
choice while writing code.
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.
In combination with a text editor which can be scripted using Lua the
impact of what becomes then possible and how powerful it can be could
have an enormous impact on the world of computing and software.
Claudio
