|
Hi szbnwer,
I really appreciate you made some questions!,
but I know that answers can diverge from the points of view
of most people and are dependent of my own experiences,
so, for all that don´t feel comfortable with my POV, please stop
reading now ;-)
>so ive thought that you wanna solve something here with a
different
>mindset than what fits the best here, but ive got it, that u
wanna
>extend ur platform. but im not 100% sure about this,
Smalltalk was defined in the 80's (1983) in a series of books that
would be good reading to know the concepts that produced
the emergence of computing support for (virtual) Object
Technology
(the books do NOT help to understand what happened after the
'80s,
nor the effects of Object ORIENTED alternatives).
There has been decades from those days and during all the time
people with different interests used smalltalk to learn, and
more conventional bussiness (e.g. writing applications).
In the 80's smalltalk required a custom execution machinery
to boot and host the "active" contents. The execution environment
was defined as a VM, that is an opaque component that can´t
change semantics while running. It defined a small API
required to run objects that change anywhere at anytime.
Today, (from 2008) a lot has changed, but NOT to converging
to a standard (the convergence happened in the 90's)
because each "smalltalk instance" is owned by a person (or
small group of people) to drive particular needs... promoting
diversity and emergent semantics that appeared from '80s
(e.g. it was a nice example in the '90s of diverse contents
an object based prolog & cobol frameworks injected in
smalltalk
system, to share the VM but have multiple compilers in the
system, while running; from that years we can have multiple
compilers to generate methods from languages/syntaxes that are
dependent of the user that is adding/changing behavior to/of
the system)
The S8 Smalltalk is a modern smalltalk, in this decade we do
not need a custom VM to run Smalltalk.
In the last years it has been published some VMs where we
can run our smalltalk systems.
In S8 Smalltalk, we have a simple compiler that build methods
from standard smalltalk syntax to produce native source (e.g.
_javascript_, now lua) to be compiled&bound dynamically
in the system.
So, my work now is to write support to host our systems
running on top of Lua VM.
> maybe u wanna make a similar tool here as well, but i
> believe this is not the case... this is cuz ive got no much
idea
> how u will connect a smalltalk app with lua, but most likely
> possible anyhow, just my mental base for st is kinda
> weak, ive only read about it...
We do not communicate systems, we run on top of modern
OO machinery.
A Smalltalk system is a different beast than "an application".
An application/program has been designed with an intention
in mind, it can update and is subject to a planned change.
An object system exists (with a lot of contents and HISTORY)
from the first time you put your fingers on it.
The object system can change contents and semantics while
persons interacts with the system (the product is experience,
not programs).
The porpouse of an open system is to support a sustainable
activity, called cycles of experience.
The construction/learning activity is always driven by interest
of person(s) that can share (copies of) their systems to other
people at any time...
Implementing this kind of systems on top of modern OO virtual
machines is not too much difficult; it is something that anyone
can do if she has done the same two ot three times following
someone else doing the same procedures.
The "beauty" and "features" one can implement depends on
the power and dynamics of the hosting execution environment.
In case of Lua, I have not had yet, hard limitations on my work.
>btw how st works? i mean is it open source and you save
> the text from a live session; or apps written in it having an
> image that can be modified during using them but can be
> read with a base engine; or what else?
It depends on what you need.
Most of the times is good to have source code as a part
of the methods you generate dynamically; so if you can
save the methods... the source goes with them.
In other systems, the methods only have a reference to
be given to another object to get the source... etc
In other sytems the source is irrelevant, because can be
obtained from methods by reverse engeneering.
And I must say that a method is only one kind of resource
to execute when a message is received; but can be other
objects in the system that can do the task imposed by
the understanding of a message.
>its an interesting stuff, when ive met with it ive found only
>gnu talk (i am totally a linux only guy) and that seemed to be
like
>one of abandonware or just a finalized product, so ive read a
bit
>about it on forums and ive found stuffs like its very slow and
had no
>popularity and whatever, so i didnt move farer with it...
If you need to work on something than change while you
are learning (any domain), you need a Smalltalk.
Smalltalk let you write a system while you use the system;
you are part of the system, during the time that activity
is realized.
Most of the times the activity happens during decades
and people learn how to use systems to face "alien"
domains.
Smalltalk is the medium to get experience in a domain.
So, the best part is you.
And the speed is your speed becoming an expert ;-)
If you want to write applications "from the outside"
you will not find something valuable in smalltalk.
(e.g. writing in a text editor, using cards,
or drawing graphics... it is the same, you
end writing an anApp of set of programs
the traditional input-program-output paradigm)
In open systems, anything can be changed at any time
so it is not defined by its contents, nor what it is
"doing" at a point in time.
It is not defined by it's source.
It includes what has happened to the system.
Time is included in the system, so the best way to define
a modern smalltalk is to call it an activity (that happen
in minds, not in the computer).
It is related with informatics and not with computing.
The virtual objects you need to get satisfaction while you
do your work each day depends on which smalltalk
resources you peek from others (people, not source
repositories, including their time, as the time I give
you here writing this lines) and how much energy
you put in YOUR smalltalk.
Once you change one method in a smalltallk system,
it becomes your system (your sole instance).
After days/months/years of work you can give some time,
sources, tools to others to start doing their experience
from that resources/objects.
>have u seen luna? https://www.luna-lang.org/ its a bit
> similar to my aims just like your stuff, so it can
> be interesting for you...
Thank you for the links.
I am simply making my objects run somewhere else.
Need a small set of semantics to do that.
If it is valuable for others, I will give them a fresh
copy and small time to spend together to learn how
to start changing what is given. That's all.
>...
>- it is 100% open source, a bash script is used for collecting
>lua/luajit and some modules, then installing some sys deps
like git
>...
[sorry to cut some paragraphs, the original is following my
response]
Appreciate the details on your works! thank you.
It sounds that it produced satisfaction, the most valuable
product of informatics.
Most of the features you described where always
present in smalltalk systems; and what was not present
is because was not needed (or not present at that times,
so no pressure to be implemented).
>- i wanna make better modularization in it, and im on the way
to
>modify my installer to a setup manager that can make and
manage
>various setups like compile options, lua engines, installed
stuffs and
>versions.
Modularization is a subproduct of framework development.
It is only matter of time.
In an evolving system, organic relations produce the emergence
of frameworks...
The first interaction with an unknown domain produce prototypical
understanding (e.g. a set of drawings and messages relating
ghosts).
Using the prototypes produce classes, as part of first modeling
experiences.
The classes mature through the learning of the domain and are
arranged in an hierarchy...
The real value of the classes are inverselly proportional to the
degree of abstraction.
The composing of objects to build machines, makes frameworks
emerge with time.
You can´t avoid to have a modular system if you work with
the monster during enough time.
So, IMHO, dont care about modularizing a system if you have not
spent too much time/energy using the system in the domain of
application.
>- i wanna get coworking.
I want to. But personal experience do not help others to love
our produced objects/tools/code...
It takes too much time/energy to adpot something if the receiver
do not have similar experiences.
It is innocent to reduce times or say that it will be cheap/free.
>- i wanna make a better ide with very fancy tools to bring
down the
>art of programming to the mortals :D
>... and a lot more, ive got at least 4-5k lines of notes for
planning
>stuffs with more or less details, these are just the present
and for
>the near future
>so i can truly feel your words! :D
I know, doing with others is good; but it do not require to be
1000's of people...
Enough satisfaction comes from doing activities "in family".
hope you will appreciate the words written in my
default S8 image, after the (MIT) license terms
at
http://u8.smalltalking.net/u8/profile/aleReimondo/s8/s8.image.js
cheers,
Ale
Il giorno dom 2 set 2018 alle ore 15:55 Alejandro Reimondo
<aleReimondo@smalltalking.net> ha scritto:
[...]
nice words, i liked to read them! :)
so ive thought that you wanna solve something here with a different
mindset than what fits the best here, but ive got it, that u wanna
extend ur platform. but im not 100% sure about this, maybe u wanna
make a similar tool here as well, but i believe this is not the
case... this is cuz ive got no much idea how u will connect a
smalltalk app with lua, but most likely possible anyhow, just my
mental base for st is kinda weak, ive only read about it...
maybe __call metamethod on tables can be something that u wish for :)
https://stackoverflow.com/questions/6048118/how-does-the-call-metamethod-in-lua-5-1-actually-work
off:
btw how st works? i mean is it open source and you save the text from
a live session; or apps written in it having an image that can be
modified during using them but can be read with a base engine; or what
else? its an interesting stuff, when ive met with it ive found only
gnu talk (i am totally a linux only guy) and that seemed to be like
one of abandonware or just a finalized product, so ive read a bit
about it on forums and ive found stuffs like its very slow and had no
popularity and whatever, so i didnt move farer with it...
have u seen luna? https://www.luna-lang.org/ its a bit similar to my
aims just like your stuff, so it can be interesting for you...
templeos is just as well something very interesting :D http://www.templeos.org
the original next-step was just as well a piece of art (i have to say
this even if i hate apple :D )
these all came from true visions, but theyve kinda lost their power
during their realization, or mayb im using the wrong words now, but i
can still feel these are poisoned gems...
my stuff is already kinda complex, its still not public and gotta be
linux only (but i keep an eye on baremetal possibilities as well). its
better to keep it safe before it really can born, cuz there are sharks
out there and ive got much plans for making a better world, but others
with different aims can poison all the strengths of it and can reverse
its powers and turn it against humanity... even then if i look like as
an ordinary madman i dare 2 strongly believe this! :D
some of its features that can be interesting for you (btw some of
these are still more or less under development):
- it is 100% open source, a bash script is used for collecting
lua/luajit and some modules, then installing some sys deps like git
gcc and whatever needed for building them; and the rest is the app
that is written in pure lua and there is an another bash supervisor
for different ways of init and for the ability of restart it.
- it is portable, everything happens in its base directory; on the
same arch but a different machine it runs out of the box without
install. (at least on a fresh installation of debian and its
derivatives)
- it have (semi-)live coding. semi, cuz it requires ctrl+r against
nasty side effects like making an infinite loop.
- its written from itself, so i can modify on the fly whatever i just
want to do so, and if its satisfying then i make new stuffs permanent.
- the language and the gui (tekui:
http://tekui.neoscientists.org/screenshots.html ) let me do whatever i
just want during live coding.
- i can run c and bash from it just as well.
- it have no data loss, and its kinda hard to crash it. its
self-testing its core to not let save with errors but it keeps the
modifications even if i dont resolve any mess that ive made there. it
shows errors with the related source lines +- a few extra lines.
- it "remembers" most of its past development. no young "childhood" is
included, but it have the last 100 modifications and much milestones
as well.
- i can run modified instances from itself.
- im currently about to make its whole state saved like its opening
just at the point ive closed it previously.
- i wanna include a libcurl binding (i think the 1 from luapower will
be that, but im not sure), turbo server
(https://github.com/kernelsauce/turbo) and luakit (via webkit remote
debug; https://github.com/luakit/luakit) for anything related to
networking.
- i wanna make better modularization in it, and im on the way to
modify my installer to a setup manager that can make and manage
various setups like compile options, lua engines, installed stuffs and
versions.
- i wanna get coworking.
- i wanna make a better ide with very fancy tools to bring down the
art of programming to the mortals :D
... and a lot more, ive got at least 4-5k lines of notes for planning
stuffs with more or less details, these are just the present and for
the near future :)
so i can truly feel your words! :D
|
