One of the points raised during the panel discussed the idea of using AI-powered technology in an eco-friendly way. Is there such a thing like an eco-friendly computer or an eco-friendly smartphone in the same way there might be an eco-friendly generative AI tool? Is that even possible since the resources needed to built those artifacts are extracted from the planet?

Discussing the eco-friendliness of some technology in isolation is not very constructive in my opinion. It should be discussed in an application context: does it provide sufficient value to compensate for its negative impacts?

Just OO? Java OO + visual + tactile = Smalltalk OO?

For what it's worth, I've implemented logic programming in block languages, too. I have also seen some versions of XML implemented that way, and I have heard of but not tried systems for OOP implemented that way. Obviously implementing OOP in Blocks just gives you a different representation of the code, not a directly manipulatable representation of a run-time object. But blocks have less to do with the computing paradigm and more to do with nested text syntax. Something similar feels likely true of node and wire, but my intuition there is weak.

Kartik Agaram IMO Smalltalk isn't visual or tangible. Etoys is what you get if you make smalltalk minimally visual and tangible.

Naked Objects? en.wikipedia.org/wiki/Naked_objects

Yeah, Morphic and Lively Kernel are good references. I still think they're not quite visual / tangible, but I'm inexperienced with them.

Naked Objects & Object-Oriented UI seem to communicate the idea quite well! The difference between Naked Objects and OOUI is that the former articulates direct correspondence of the UI objects and app model objects (section 8.1 from downloads.nakedobjects.net/resources/Pawson%20thesis.pdf). This probably doesn't make any difference anyway as in reality all objects are illusions in our heads. It only changes where the object illusion ends.

Is everybody agreeing with nodes and wires as functional programming? I think it's (more precisely?) dataflow programming. Functional PL usually do a lot with, lambdas (functions), you "pass along functions". In node and wires, the pipes usually pass data.. or sometimes contraflow (blueprints). I can't name any nodes and wires PL, that even has functions as data.

Yeah you're right. It's functional in the sense that circuit design is combinatorial rather than sequential. Simple circuits tend to have no memory and outputs are functions of inputs. So not functional in the sense of first class functions. Functional in the sense of stateless by default.

The Morphic authors had a neat goals paper worrydream.com/refs/Maloney1995-_Directness_and_Liveness_in_Morphic.pdf

Directness and liveness in Morphic are supported by four implementation techniques:

● structural reification (supports directness),

● layout reification (supports directness and liveness),

● ubiquitous animation (supports liveness), and

● live editing (supports directness and liveness).

Boxer had debatable 🤏 but strong 👀 for stateful objects, naming it "Naive Realism": the user should not need to imagine any hidden state beyond what can be inspected on the screen.

[nit: "Block based" is not specific to procedural style.

• Snap! can do functional too. It has lambdas, some higher-order builtins (keep items from list ), custom blocks can even look like "C-shaped" custom control structures reveiving the nested body as a lambda; even call/cc continuations...
• OOP too: Sprites are stateful objects. There is builtin properties like position visibility size etc. but also variables can be made per-instance. Sprites can be cloned, with prototypical inheritance of properties. In Snap!, i know sprites can also be composed in a hierarchy, with position orientation and size being relative to parent - similar to Morphic's structural reification.
• OOP in message-passing sense: Scratch uses message passing for coordination between sprites, but it's limited. Snap! has more, plus "ask/tell to execute this code in your context" instead of named methods (Screw encapsulation 😜)

but none of this answers your Q]

I'd say Factorio fits your description well, what with both data and behaviors reified in the world?

But what's the paradigm? 🤔

A lot of "conveyers and pipeline oriented programming" -- which sounds like dataflow, and doesn't capture nuance of behaviors also being mutable, destructible etc.

And whats the paradigm of Baba Is You?

Node and wire is data flow. FP is not data flow.