Date: Tue, 28 Mar 2017 11:40:03 -0700
From: Paula Te
Subject: Re: Logic Circuit Jam

I pulled out batteries, pipe cleaners, etc in an attempt to figure out something that would work with physical objects. But the question popped up - are the wires and batteries "real" in that there's real charge going through, or are they just symbols for things that will be interpreted by Realtalk? I think we'd want to be able to turn any physical object easily into a symbol that Realtalk understands, maybe by placing a framecode around it, like La Tabla's animation program simply captures any physical object that's in a frame. 

Inline image 1Inline image 2

Wires also feel good to manipulate as physical objects in the real world, but maybe there are better affordances to drawing out the wires on a whiteboard or with a marker. 

Inline image 3

I also brought out tater tot as a physical object that could move around on the table and follow lines. Tater is slow, but it would be interesting to use a bot as a token to represent moving charge. 

Inline image 4Inline image 5Inline image 7


For programming, I did a similar thing to Alex's etoy's demo, except using "touching" instead of "seeing," where I used stickers as symbols or colors that things could  touch. I then wrote out the code on cards (though the if's and then's could have been pre-printed) and then photocopied them with the "rule" card on top (blue framecode), The rules could go in a binder or something on the table, and cards on that table would have those rules applied. I photocopied the rules to re-ify them and so I could reuse components from previous rules to write the new rules. 


Inline image 6

Things that I noticed from the jam are:

  • adjacency: alignment and closeness were key in determining the behavior of the cards. Makes a lot of sense. Seems like a definite part of the "building blocks" of being able to conversationally program.
  • duplicating: If I want many ANDs, I photocopy them. Or cut a card in half and write AND twice. How do we quickly have many copies of an object, to facilitate conversational programming? Perhaps we have stacks of different colored cards, and we can use those colors to signify different rules. 
  • abundance of tokens: Alex went with the assumption that there were an abundance of black and white go tokens. I thought this was interesting. Certainly, paper is a building block of our system. What else do we have an abundance of? Framecodes? Or will the abundance of things evolve as we have recognizers for them? There will probably be a "go stone recognizer" program that gets reused frequently in many subsequent programs. 
  • how to use projection in a prototype: For some reason when I was jamming I didn't really have a good way of thinking through how things would be projected. In other people's jams I also noticed that having a way of using projection in the jams would make for a better experience. This makes me want a kind of basic photoshop for projection, for use to create things like when Toby and I quickly mocked up this idea http://media.dynamic.land/objects/c4584d3b61da87e5fbbe1d4cbc18d94cce5e474e/download?extension=1 .
  • cards vs color as primitives: In many of the jam ideas, the cards are the primitives that would be adjacent to other rules, have input/output, etc. This is unlike the etoys example where color is a primitive. The distinguishing feature is that if color is a primitive, we get to change behavior of things within cards as well. Inline image 8
  • on-ness: Maybe particular to programming logic circuits, but knowing when something is ON is necessary, and was depicted in many different ways in the jam yesterday. I really liked Alex's and Bret's comment about using projection to signify "on," something is on if it is lit, and that is something that the system understands.
  • words: I think we all used words to program the rules. Josh made use of color and shapes, and Alex made use of the go tokens. All these methods are plausible, but it is interesting to think about the interplay of non-words and words to program.



Paula



On Mon, Mar 27, 2017 at 9:36 PM, Bret Victor wrote:
Also wanted to mention -- one of the most exciting parts of the jam for me was watching all the demos and thinking "people could do it any of these ways, and they would all work".  With a sufficiently good set of pre-built recognizers and sufficiently good ways of defining rules, someone could come in and build a working logic circuit kit in Toby-style or Paula-style or Josh-style or Bret-style.  They're all different, and they're all fine.

When designing a typical programming system, there's often a feeling of a strong "grain" -- there's some "right" way of writing a program that feels most natural in the language, and you're designing the language to try to maximize the elegance/parsimoniousness of a program written the "right" way.  At the jam today, I enjoyed the feeling that our system wouldn't be strongly grained at all.  The real world has so many degrees of freedom, there are so many ways of doing anything in the real world.  Realtalk should be useful however anyone wants to use it, instead of imposing its own style on anyone.

(fwiw, it's true that I used to worship Larry Wall, but that was a long time ago and I'm embarrassed by that.) 

(fwiw also, Python has never sat well with me.)

Of course, there's the question of interoperability -- if I put my logic gates on a table with Toby's gates, can they play together?  Could they be made to play together?

(At least they can sit on the same table together, which is already better than logic gates from two different computer applications.)