[LANGUAGE idea] Add more levels up to systems language; add memory layout diagrams

[feefladder]

Language idea incl level

First off: Hedy is great! I know it's not the target audience of Hedy, but it would be nice to have some recommendations/tutorials on how to continue. Also, Hedy builds towards Python, but the same concept could be very well used to easily change to other languages that are closer to machine language. The thing is: people learn to script, but they don't necessarily learn how a computer works, compilation, memory layout, etc. I think some concepts here are very important for general scripting. Below is a

In terms of closeness, I would make this (very opinionated) list:

• Hedy: natural language -> scripting language: At the end of completing Hedy, learners can build a Python script that runs in Python.
• Hedy++: Builds towards a systems language from Python by introducing concepts such as memory layout etc. What I'm thinking of is this mockup I've made in Rust, that could be added to Hedy once more complex data structures come into play:

f: Field
  |\-π         // let pi = f.c_pi()
  |<-| f: [π]
  |  |
  |  |\-Σ(2,π) // let k = 2*pi
  |<-----| f: [π,2π]
  |  |   |     |  \-Newly added
  |  |   |     |\<--/ references π
  |  |   |     \-Can never be removed as long as 2π exists
  |  |   |       We don't know how many '2π's exist
  |  |   |       bc π, 2π can be arbitrarily copied (Bitwise)
  |  |   |
  |  |   |   /---Static field exists forever.
-------------\   Using it is safe
  |  |  /     \--Below this line: Disposable field: !unsafe!
----------2π dies. 
  |  |    We are very very sure that 2π is not copied anywhere
  |  /
  | /
-------- π dies.
  |      We are very very sure that π is really dead

This is of course an pure text representation, but having a funky data layout is also there in e.g. RStudio. What would be cool, would be to change this data layout to a memory layout and then animate what a function (or code) does to that data. Consider the following program:

animals = ['cat', 'deer', 'cow']
for animal in animals:
    print(animal)

Now, debugging looks like: animals: [cat, deer, cow]; animal: cat This could be made fancier when passing arguments by value like:

       |animals: [cat, deer, cow]
|------| animal: [cat]
|output|
|------|

       |animals: [cat, deer, cow]
|------| animal:      [deer]
|output|
|------|


       |animals: [cat, deer, cow]
|------| animal:            [cow]
|output|
|------|

Or keep it in the same place, but put an animation (the arrows are animated):

       |animals: [cat, deer, cow]
                   ↓
|------| animal: [cat]
|output|
|------|

       |animals: [cat, deer, cow]
|------| animal: [deer]<-/
|output|
|------|


       |animals: [cat, deer, cow]
|------| animal: [cow]<------/
|output|
|------|

Then passing by (immutable) reference would look like:

       |animals: [cat, deer, cow]
|------| animal----/
|output|
|------|

       |animals: [cat, deer, cow]
|------| animal---------/
|output|
|------|


       |animals: [cat, deer, cow]
|------| animal---------------/
|output|
|------|

Then the full memory layout (in Rust, at least) would be:

            STACK|animals--------\---------------------/
|------|          animal----------|-\                  |
|output|                          |  |                 |
|------|                  HEAP|***[cat, dear, cow, ....]*******|

            STACK|animals--------\---------------------/
|------|          animal----------|-------\            |
|output|                          |       |            |
|------|                  HEAP|***[cat, dear, cow, ....]*******|

            STACK|animals--------\---------------------/
|------|          animal----------|-----------\        |
|output|                          |           |        |
|------|                  HEAP|***[cat, dear, cow, ....]*******|

Now strings are always heap-allocated, so that's not really a good example, but imagine they're not and are copied to animal, then (arrows are animated):

            STACK|animals--------\---------------------/
|------|          animal:[cat]<---|-\                  |
|output|                          |  |                 |
|------|                  HEAP|***[cat, dear, cow, ....]*******|

            STACK|animals--------\---------------------/
|------|          animal:[deer]<--|-------\            |
|output|                          |       |            |
|------|                  HEAP|***[cat, dear, cow, ....]*******|

            STACK|animals--------\---------------------/
|------|          animal:[cow]<---|-----------\        |
|output|                          |           |        |
|------|                  HEAP|***[cat, dear, cow, ....]*******|

Of course, this may be too in-depth for kids, but high-school students would enjoy it, or at least it'd be a nice debugging tool for devs even.
Additional context
I'm a Python/C++/Javascript programmer learning Rust. I've recently come across Hedy while already thinking of making memory layouts easier to grasp. I'm a huge fan of typeable diagrams and think all diagrams should be on a monospace font grid so there is a one-to-one GUI-text mapping. Ideally, this would also imply a one-to-one program<->diagram mapping, but that is much more difficult.

[Felienne]

Thanks for the cool ideas @feefladder! This fits in a bit with some other discussions like #4040 and #4569. While I love this direction at the moment we don't have the bandwidth to support other "Hedy's" with the core team. But if you would want to explore or prototype it, we would be excited and happy to share some brain cycles!

[feefladder]

Whoops, actually I had two ideas here:

1. add more programming languages <- out of scope/bandwidth for Hedy currently
2. fancify the debugging layout. <- this can still be done, would be nice if it looks similar to 'advanced'

Actually, for 1. I think there are actually already great tools out there. Maybe a page at the end with links could be nice? For Rust, there is rustlings, which is similar, but requires a CLI and IDE setup. or Rust by example, which works in-browser.
For Python, there is FreeCodeCamp

I also don't have that much bandwidth atm, so wouldn't be able to prototype anytime soon, sorry...