Procedural Programming + :eyes: + :pinching_hand: ...
# thinking-together
m
Procedural Programming + šŸ‘€ + šŸ¤ = Block Based Programming Functional Programming + šŸ‘€ + šŸ¤ = Nodes And Wires Object-Oriented Programming + šŸ‘€ + šŸ¤ = ā“ I'm looking for a term that describes a class of visual environments, where behavior is organized into stateful objects, subject to direct manipulation by the user. Examples of those environments might be The Alternate Reality Kit, Automat or Scrappy. I don't think I've ever stumbled upon a term for such a class. Or maybe I'm just not well versed in visual programming nomenclature. Do you know how they're called? Or how would you call them yourself?
k
Just OO? Java OO + visual + tactile = Smalltalk OO?
j
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.
i
@Kartik Agaram IMO Smalltalk isn't visual or tangible. Etoys is what you get if you make smalltalk minimally visual and tangible.
n
i
Yeah, Morphic and Lively Kernel are good references. I still think they're not quite visual / tangible, but I'm inexperienced with them.
m
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 http://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.
o
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.
k
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.
b
The Morphic authors had a neat goals paper https://worrydream.com/refs/Maloney_1995_-_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?
g
Node and wire is data flow. FP is not data flow.