lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index] 


>- 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,

In in conventional computing paradigm, the source is the
 most important product of programmer efforts.
As the person is outside of the system (because the system will run
 somewhere else, in another time, "in the future")
 the system is not relevant and the only you have/need is "the
 specification" of it.
The specification is secure and has the beauty of a
 non-living/abstract artifact.
The source/specification defines a closed/ideal system.

If you change a line, it will define ANOTHER system; with no
 relation with the preceding system in terms of sustainability
 of the real system (the system that will be instantiated in
 the future when started).

In an open object system, the system runs when you are using it.
If the system "do nothing" it already exists (the porpouse it is sole sustainability through time). 
It is not something running to produce output for you (nor for any user)...
 you can collect some fruits... but the system is not there
 for an user, nor to "compute" something for a human been.

Each object can change as concecuence the action/impact of another
 person/object through sending/receiving/understanding messages
 (the understanding directs the change).
Each object has a language defined by what messages are
 understood by the object.
The language for each object can change... in an instant
In this kind of (open) systems the language change.
The main difference between an object and a component
 (an artifact of object oriented architectures) is:
-component: is something with an API that defines the way to communicate with it. -object: is something (when you send a message it will impact and the concecuences  can change from the time you send the message the first time and a second time). 

Object systems are not secure, but sustainable.
Some systems has been changing/evolving for decades.

The system can contain more than one compilers (or other tools to
 instantiate behavior), and other tools to survive while
 potentially "all" can change.

The source is not relevant; and there are situations where you understand
 what is happening seen it happen (by the observation of emergent
 behavior).
In the first stages of learning smalltalk systems containing specific
 domain models, it is frequent/reccomended to use visual
 representations (GUI) of the objects to understand the
 system; and from the most interesting points of the system
 you start reading source (when you have the intention to
 change something).

Object systems are "moving"/working while you learn; and you
 learn from active media; not only from reading texts or drawings.
Browsing, inspecting and evaluating expressions is the way to
 understand how/what/why it is working... while it is working.
It you break something it can happen that the system survive your actions or not. 
In case of still working, repairing the system is an effective way to learn.

> i need to run it first to get an idea what i actually have,

Yes, you use computer to see while learning; not only texts
 to imagine what will happen when it will run.
When you read a text, you do not have more than
 what is in your mind/imagination.
The problem with imagination is it can't be shared in a concrete
 support (must be abstracted, loosing information value)

> 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.
Today, you can have more than words stored in a file (text in a page of a book). 

>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...

In object systems we do not use to comment behavior (we do not
 comment what is done to implement a contract).
We comment messages.

The comment states the meaning of the message.
What happen when a message impacts an object depend of the object.
Each object that understand a message should have the same comment for that message. The set of messages an object can understand define the "language" of the object. 

>- 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

You are talking about computation speed...
I use to talk about speed of understanding, learning and
 maintaining/growing systems... during decades.
I am not in a hurry.

>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...

Yes, we use all forms of execution in all execution environments.
That is the most boring/lowlevel part of smalltalk :-P

Execution machinery let us run our systems; we run binary, JIT VMs, etc...
 from the '80s, we run our systems in different environments.

Execution machinery is interesting, but the major product is global warming.
What happens in the mind of the people using smalltalk systems
 produces satisfaction.
Under this(my) point of view it is not need to increase the speed
 of production :-P

>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.

The difficulty learning is most of the times related to using
 only texts (and drawings) to imagine a reality that the reader
 has not experienced.
The use of computers to present virtual realities in an active way
 is a new medium to get experiences from unknown domains.
Most people still uses reading and imagination in the mind...
 it is ok, but from the creation of smalltalk environments (mid '80s)
 we have new support for learning.

>but st requires a very different mindset
>than other general languages i believe, but mayb im wrong...

Most of the smalltalkers do not have my point of view.
There is a diverse spectra that covers from people understanding
 smalltalk as a (dynamic) programming language
 to a robust set of frameworks, to a robust toolset for
 writing programs, etc...

If you ask "what is smalltalk?" to a "self-called" smalltalker it will
 be a diverse kind of responses to the question
 (some will point you to a book and someoneElse/author's experiences).

The responses will be like:
-smalltalk is a dynamic Object Oriented Language (OOL)
-smalltalk is a robust set of frameworks designed from the '80s
-smalltalk is a class based system still evolving (extended to prototypes and other mechanisms of delegation in the '90s) -smalltalk is a robust toolset for browsing, designing and debugging robust applications -smalltalk is a image that contains a full set of virtual objects, that runs when started in a computer -smalltalk is the content of a snapshot, result of running a smalltalk in the past 
-smalltalk is an activity, it is what some smalltalkers is doing in
 a domain of application (of the object environment); it produces
 experience and runs in the mind of people

So, it depends of the person you ask, if it is required a
 different mindset to be understood.
But more important than the response is what YOU can do with
 the response; and how you can use the response to your own pourposes.


>a live sys is not the domain of st,

Yes, it is. It happens in the mind.

> you can achieve it with anything if youve got the source,
> the key is to put the app under its own control...

Sorry but an app has nothing to do with life.
An app running in a computer can't be alive
(all live systems are produced by live systems, by definition)

The code of a system has no compromise with the system
 (has not relation with its sustainability).

>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)

I am not trying to sell smalltalk, only talking about open systems
 (what I have done during +three decades with smalltalk).
The powerfull/flexible part is the person using the system.
If who is using the system is a person that is fixed in any way,
 you see formal, beautifull, reduced and secure systems.
In case of been used in different application contexts you see
 well designed/evolving frameworks, etc...
In case of been used for exploration of informatics, in an open world
 you see smalltalks that uses other VMs, and with wide interfaces
 to alien execution environments.

> 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...

The fexibility and experience of people using Lua in
 the next decades will show us how it helps to evolve
 from computing to informatics.
IMHO, as Lua is defined today as a language,
 it is not offered as a support for informatics.
It is fixed in the languages picture.

>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...

I would suggest to invest your time for learning st using Squeak or Pharo.
With time you will see that there are more choices; and which
 make you feel more confortable to learn and find your way.

>- 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...

Download Squeak (or Pharo) and read the contents inside the system
 (start the system and find documentation inside the system)
I said "find documentation"... learn how to find something you want
 in an object system (not in a set of files).

I've seen that at start of your response of this email has words in Italian.
I live in Buenos Aires, Argentina. Have some good friends in Italy;
 so if you are near Milan I would suggest to met someone working
 with Smalltalk.
Looking someone else working with smalltalk is a boost in learning;
 and will let you discuss on the directions you need help.

>- 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?

When you download a smalltalk it is a file of someone else.
When you start it and modify something it becomes YOUR smalltalk :-)
When you "save the image", you make a snapshot; and can continue
 with your smalltalk next time you start "your smalltalk image".

When working in groups, the convergence of multiple systems
 is done with integration cycles; investing energy in the
 convergence of different experiences.

>- 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?

You branch(copy your system) to another domain of application...
 going to that destiny with your objects... and start working, changing
 and sharing it with people in the site of exploration.

Or you enter a domain/workgroup and start learning the system
 that is already there... with time you inject some objects/frameworks
 in the workgroup adapting to match the domain.
The energy needed to enter a domain depends more on the communication
 capabilities of the workgroup and the skills/experts in the group
 than in the toolset.

>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

Yes, an open system acts as a gravitator where people experiences
 converges and modify the media to cristalize domain frameworks
 with time.

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

cheers,
Ale


El 05/09/2018 a las 21:59, szbnwer@gmail.com escribió:

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! :)