[Vm-dev] Pony for Pharo VM

[Shaping]

Hi Ken.

 

Not to discourage people, but I have not seen cases where a "strong" 

type system would be able to scale for _real_ Smalltalk applications.

 

You’re right.  It doesn't.  I'm not suggesting that.

 

The type safety is not for app-level Smalltalk development.  It's for building the VM only. 

 

I want to use the Pony concurrency model at the Smalltalk level.  That’s the gist of it.  Otherwise, I want a Smalltalk, not a statically compiled language.

 

Six ref-caps that explicitly represent Pony’s concurrency model in code.  They are essentially type qualifiers related specifically to concurrency.  The plan is to reduce, if possible, the number of ref-caps the programmer must explicitly use/place in the code when coding a state-machine in Smalltalk, without producing a toy or straightjacket (without making it too simple or too rigid).  This may require implementing the VM more as a change to (fork of) Pony instead of using Pony to implement the VM.  I’m not sure yet.    

 

The six ref-cap ideas for sharing data reliably between actors are not hard to grasp, but they take some getting used to, and involve some mental load.  I don't want that much (concurrency-related or any other) implementation detail in the domain layer, much in the same vein as:  I don’t use Forth because I don’t want to see stack acrobatics (ROTs and DUPs, etc.) amidst domain-level state-changes (FirePhotonTorpedo).  It’s distracting.  It dilutes focus on the domain work/layer, and tends to cause mistakes there.

 

The programmer’s domain logic and the concurrency-integrity provided by the ref-caps are different layers of thought and structure.  The ref-caps are, however, mixed freely with domain logic in current Pony code.  I think that’s a mistake.  But that’s how it is now.  I think of this layer mixing as an intermediate design stage of Pony.  I want to abstract-out some or all ref-caps as the VM is built.  

 

Pony language is not the remarkable thing here. I see it as a better C or better Rust.  It’s very good (as Algol-60-ish-looking crap-syntaxes go), but that’s not what this is about.  It’s about the actor programming, the concurrency model, and the guarantees given by use of the ref-caps.  We would still obviously need to respect the Pony compiler’s determination of where ref-cap use is correct or not.  Your Pony program won’t compile if you don’t use the ref-caps correctly, and you don’t get the guarantees or a running program without the compile.  Much easier, therefore, might be to go the other way by changing Pony to support dynamic types without violating the invariants that allow the ref-caps (under the hood, abstracted out) to make the concurrency guarantees.  Work Smalltalk dynamism into Pony, instead of building a Smalltalk VM with Pony.  

 

 

Shaping

 

 

"Rational numbers"

(1/2) + (1/3) + (1/6). "--> 1 "

 

"Complex numbers"

[ :n | n * n] value: (-4 sqrt). "--> -4 "

 

"BigNums"

111 factorial. " -->

1762952551090244663872161047107075788761409536026565516041574063347346955087248316436555574598462315773196047662837978913145847497199871623320096254145331200000000000000000000000000

"

 

Just this is hugely complex to model in a "type safe" language.

 

Add metaprogramming (e.g. #doesNotUnderstand:), source level debugging of live stacks and GC of large object spaces and you have a very large

(space) and very slow (interlocking cache granularity) interpreter.

 

Please prove me wrong.

 

$0.02,

-KenD

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.squeakfoundation.org/pipermail/vm-dev/attachments/20200410/cfd12415/attachment.html>