Re: Functions as first-class objects

["szbnwer@..." <szbnwer@...>]

Il giorno mar 4 set 2018 alle ore 14:22 Alejandro Reimondo
<aleReimondo@smalltalking.net> ha scritto:
[...]

hi there, and sorry for late! :)

1st of all thx for all the info and ur time so far! :)

st is a very very interesting domain for me, as you can see im about
to make something similar in many senses, however i still feel that
lua is more suitable for what i wanna get:
- the "source" you gave is not really like a source but its more
likely something like a serialization, that is only "source" in quotes
for me cuz its not really human readable, i need to run it first to
get an idea what i actually have, while my stuff is 100% handwritten
code. except what i am working on ~currently, some serialized data
that have no functions, userdata and threads, but everything else is
in a kinda pretty form. comments can be strings, everything can be
restored via functions for app state, so theres no need to serialize
functions, but even those can be made from strings in case of need and
they can be put in a table as the function is a weak key and the
string is the value... so i think for trust its the 1st thing to have
is human readable source before anything would ever be executed... btw
i came to lua from python and i think something like docsstrings (or
whatever those were called) can be easily used for st to make even
more stuffs there selfdocumented that ive got in comments currently,
that is already a valuable thing, but still not the initial trust for
any1.
- the speed and heavy lifting. luajit is faster than a cheetah, but
ive read that st is a bit slow, and as its currently on js, its still
not faster... with js the main problem is that it is too much involved
with the browser tech and must serve all the bull* of every webdev
even with much backward compatibility so its kinda being a bloatware
(what else could be if lua can do anything and its smaller :D ) so i
think using st would be a loss of speed anyhow, but ive read recently
around that it can make use of binaries, so bottlenecks can be made
wider but the less low level is the better for bigger popularity...
cuz i can only abstract the codes not the funds and c have its funds
that must be learned anyhow 2 use it...

the rest of my interest is ease of learn and use, some general
interest in the language, basic libs available for general stuffs in
case of need, compatibility with lower level stuffs in case of need
and if i wanna move nearer to hw for whatever, flexibility, active but
not running development, small base to be able to really own the whole
source for whatever need ... these domains mostly seems to be fine
with st as well. however lua is pretty much everywhere, and every 2nd
dev is a webdev and js is so much similar to lua that js folks can
learn it like in a minute... but st requires a very different mindset
than other general languages i believe, but mayb im wrong...

a live sys is not the domain of st, you can achieve it with anything
if youve got the source, the key is to put the app under its own
control... and any app is developed by the actual need continuously,
and even those can have reusable codebses, but thats a matter
consideration generally but i think this is even true for st just not
that strongly... st seems to me like 1 always putting his/her codes in
a lib-like shape, thats good anyhow! :) "your st" is just a matter of
fork in opensource and you must learn your tools always ... however my
app have also fluid bases, so a need comes and then i can modify
anything on the fly in a live experience...

the greatest selling point of st in my eyes is that its even more
flexible than anything else as you can redefine really anything,
however i think that have its grammar as a fix point (even if you
could you most likely dont have reason to do that) and i feel the same
that lua dont have anything that is too deep to modify and there could
be a real need for it...

ive got a few new questions...
- if i wanna experiencing with st (im in lack of time, but sooner or
later id like to see a bit more :) ) which implementation have the
strongest funds for linux? or wich is the easiest to set up and play
with it with nice experiences? ive considered mainly pharo, cuz thats
used for raptorjit (~rj), a nice luajit fork (
https://github.com/raptorjit/raptorjit ) its domain is an analysis
tool for the internals of rj, its called studio, i think ull find
it... as im inerested in that project i wanna mess around studio just
as well as its kinda more or less an organic part of rj. otoh it have
a nice interface... and for sure im interested in ur stuffs just as
well, but i couldnt do anything on ur playground...
- can you give me example code that i can run there for introspecting
its ecosystem? like an access to a root element, a dump and whatever
is needed to look around a bit in its toolset... theres no need for
much effort, i just wanna get a taste and be a tourist there :D and
anything you think that could be interesting to see or useful during
my journey... i know its syntax mostly, but that is the level of
wikipedia...
- when you wanna share your sys then you can simply cut a branch from
the tree of its ecosystem that is serving for a specific domain or you
copy the whole and modify it in any way you would like to?
- different st implementations meaning a different domain like you
cant bring ur codebase to an another field or you can, or you can only
by converting?

anyhow i can see that we are doing our business cuz the very same
experience, and this is really the best way of coding that i can
imagine :)

and thx for all ur time and efforts, i really appreciate them! just as
well for the interesting conversation! :)