Minimality

Hi Cedreek,

(Part of this I mentioned on Discord as well, but not all readers will be on
Discord)

I'm working with a tiny Smalltalk image (currently around 150Kb) which
contains basic classes (very similar to PharoCandle, but with the regular
Smalltalk names without PC-prefix, see
https://github.com/carolahp/PharoCandleSrc). It additionally supports
WebSockets when used in combination with SqueakJS, but I'm working on a
regular WebSocket-version for OpenSmalltalk-VM as well.

The image has an ObjectEncoder/Decoder pair allowing the image to 'receive'
encoded classes and methods from a regular Smalltalk image (bytcode only,
since no compiler is present in the tine image). The tiny image can install
these classes and use them. The current 'protocol' is to send messages to
this tiny image and have the image send events back to the regular image.
The tiny image (client) is responsible for making a connection with the
regular image (server). But this protocol can be adjusted with newly
installed classes of course ;-).

My idea (dream?) is to create small cloud images for personal use, so you
can run many on limited computing units. These images will not have file- or
FFI-support and need to retrieve data through WebSocket/HTTP/... or other
web communication technology. It is part of a project I'm working on to
learn programming in Smalltalk to kids. They can spin up an image in the
cloud (or on their Raspberry Pi at home) and load their code from a remote
repository. The development environment will run in the cloud and be usable
with a web browser. In the web browser runs a tiny image which can execu...o
wait, I explained that part already ;-). So in the web browser this same
tiny image is running (on SqueakJS). This time, it loads code to be able to
manipulate the DOM. This tiny image is sort of the Javascript replacement.
So everything is Smalltalk! :-)

Still a long way to go though. I hope to be able to demonstrate a little of
this in a not so distant future. I will share my code as well. Everything
will be open source.

Feel free to reach out if anyone wants to participate. ;-)

Regards,
Erik




--
Sent from: http://forum.world.st/Pharo-Smalltalk-Users-f1310670.html

Hi Erik,


> (Part of this I mentioned on Discord as well, but not all readers will be on
> Discord)

Yes I’ve just seen it and I remembered seeing your posts

Cool this is the stuff I need to play with. How can I try ?



>
> My idea (dream?) is to create small cloud images for personal use, so you
> can run many on limited computing units.

Frankly this is my same goal, except I see them as « Information system node » of a distributed information system architecture ie. Computing units of information objects (often related to scripts btw).

So this is really really great what you achieved :)


> These images will not have file- or
> FFI-support

Ok. Indeed this would complicate for nothing. No FFI support but would some simple interaction wanted (I/o stream, small unix system call ?).


> and need to retrieve data through WebSocket/HTTP/... or other
> web communication technology. It is part of a project I'm working on to
> learn programming in Smalltalk to kids.

Cool


> They can spin up an image in the
> cloud (or on their Raspberry Pi at home) and load their code from a remote
> repository.

For me it would be spin a new information system and eventually link it with shared others (can be a remote repo).

I’m really interested and love to help in some ways. So as far as you have info/tuto or other thinks, please tell me. Just be running it would be the first step.

Any pointers/repositories ?

Cheers,
Cédrik

Hi Cédrick,

Remember the Pharo vision back in 2005.

Pharo Zen
Our values and convictions are condensed in this simple list.
Easy to understand, easy to learn from, easy to change.
Objects all the way down.
Examples to learn from.
Fully dynamic and malleable.
Beauty in the code, beauty in the comments.
Simplicity is the ultimate elegance.
Better a set of small polymorphic classes than a large ugly one.
Classes structure our vocabulary.
Messages are our vocabulary.
Polymorphism is our esperanto.
Abstraction and composition are our friends.
Tests are important but can be changed.
Explicit is better than implicit.
Magic only at the right place.
One step at a time.
There is no unimportant fix.
Learning from mistakes.
Perfection can kill movement.
Quality is a emerging property.
Simple processes to support progress.
Communication is key.
A system with robust abstractions that a single person can understand.


Le 13/04/2020 à 14:30, Cédrick Béler a écrit : --
Dr. Geo
http://drgeo.eu

Which is always available in any Pharo image as Help > Pharo Zen

As a matter of fact it is interesting to compare the number of classes
in the last releases of the descendants of Smalltalk 80:

  * Cuis5 (480 classes),
  * Squeak 5.2 (2713 classes)
  * Pharo8 (*9084 *classes)

I don't think the last Pharo vision statement:

    /A system with robust abstractions that a single person can understand./

is in anyway realistic.

Now, will Pharo9 reach the sky with *10'000* classes? Very likely if you
observe the graph below:

Hilaire

Le 13/04/2020 à 14:30, Cédrick Béler a écrit :
> Just a reflexion that I’d like to share here.
> When Hilaire talks about complexity. I have to agree too, even if I
> like the progress under the hood, and explored spaces like GToolkit.
>
--
Dr. Geo
http://drgeo.eu

I forgot the graph:

Now, will Pharo9 reach the sky with 10'000 classes? Very likely if you observe the graph below:

-- 
Dr. Geo
http://drgeo.eu

This sounds a lot like Craig Latta's "Spoon".
Probably worth talking to him about it.

On Tue, 14 Apr 2020 at 07:48, Erik Stel <[hidden email]> wrote:

A vision is not a state-of-the-art description. If we would target a minimal system we still can have a bloated one. And the number of classes in the system is not a metric of understandability.
Otherwise providing more tools for people to look onto code and understand would be a contradiction to this.

Norbert

I think we’re in a kind of in-between path:

I'm not sure what "descendants of Smalltalk-80" means.
Surely it should include VisualWorks (2994 classes)
and GNU Smalltalk (248 classes in the kernel)
and Dolphin Smalltalk (2164).
My Smalltalk is recognisably a descendant of Smalltalk-80,
and the test build has 985 classes

I'm not sure what the number of classes means either.
The number of classes in a classic Smalltalk-80 image is
well-defined, but with repository access like Iceberg, it
is feasible to have a lot of stuff outside the core.
The figure for GNU Smalltalk is deceptive because
the UI kit, XML support, I18N support, Sockets, and a
lot of other stuff are outside its kernel.  VW comes with
a bunch of "parcels": XML, XPath, XSL, oodles of
tools including UI painter, data base interface, &c out of
the image (so not counted above) but available with a few
mouse clicks.  Pharo and Squeak can install a grreat
deal of stuff from their repositories.  Dolphin comes with
another 900-odd easily installable contributed classes.

Given the number of different things we want to interface to
these days, including but in no way limited to TCP, UDP, SCTP,
FTP(S), HTTP(S), (X)HTML,XML,assorted XML addons, YAML,
TOML, JSON, BERP, ASN.1, SQL, assorted No-SQL systems,
too many audio formats, too many image formats, too many
video formats, too many compression schemes, too many
versions of Markdown (and close relatives), a character set
standard that grows rapidly and requires a book of 1030
pages to describe it -- that's exclusive of code charts -- and
all the other delirious warty melons one needs to interface to
these days, and I don't believe we *can* have a minimal class
library.  I mean, it takes me 28 classes just to deal with core
XML, and I insist that every class be worth its pay.

The best we can hope for is something in the Spoon mould,
where you have in the low hundreds of classes, some of which
(arithmetic, collections, streams, perhaps geometric objects)
can be understood in full by programmers, some of which
(compiler, network, file system) have *interfaces* that programmers
can understand but whose implementation they seldom bother
about, then an middle layer of packages providing things like
audio, images, video, compression, encryption, Markdown,
whatever, that are normally held locally and possibly auto-loaded,
then an outer layer of repositories.

Smalltalk is simple enough, it's just that things we need to talk to
are insanely complex.  (Hands up everyone who has actually read
the whole of the Unicode standard.  Oh well done.  Now put your
hand down if you have *understood* the whole of it.  Nobody with
a hand up?  Well I never.)
understand

On Thu, 16 Apr 2020 at 22:46, Hilaire <[hidden email]> wrote:

Le 16/04/2020 à 14:23, Richard O'Keefe a écrit :
> I'm not sure what "descendants of Smalltalk-80" means.

Obviously, I mean the Apple' Smalltalk-80 Squeak takes its origin from.
I should have write that.

> Smalltalk is simple enough, it's just that things we need to talk to
> are insanely complex.  (Hands up everyone who has actually read

But Pharo is over this point. Its complexity is not because of
additional packages but from its internal way of doing things, I can't
tell you exactly why, I am just observing this situation when trying to
understand how things work from the inside. See for example my idiotic
struggle a couple of days ago.

For example, Morph was not cleanup as done in Cuis but since ten years
there were attempts to develop additional frameworks (athens, bloc,
brick, other?) with unclear results.

--
Dr. Geo
http://drgeo.eu

Richard,


Richard O'Keefe wrote
> This sounds a lot like Craig Latta's "Spoon".
> Probably worth talking to him about it.

In the past I had some interest in Spoon, but it seems inactive now in
favour of Caffeine and Naiad (the module system for Spoon). Spoon is not
open source btw. Spoon & Naiad is/was about live coding with versions of
classes and methods which is different from my needs. At that time Spoon had
its own VM I think. Recently I had some contact with Craig regarding
SqueakJS for my work and last Fall I presented some of my ideas at a meetup
where he was too. He did not reach out there and admittedly I did not ask.

My ideas are definitely not new and where possible I try to make use of
existing ideas, designs or products. Something about trying to stand on the
shoulder of giants comes up as a title ;-).

Thx for the pointer though.



--
Sent from: http://forum.world.st/Pharo-Smalltalk-Users-f1310670.html