3 changed files with 5 additions and 155 deletions
--- a/README.md
+++ b/README.md
@ -6,7 +6,7 @@ Ludus is part of the Thinking with Computers project, funded by SSHRC.
 ### Quicklinks
 * [Web version of Ludus](https://ludus.surge.sh)
-* [Ludus language documentation](https://alea.ludus.dev/twc/ludus/src/branch/main/language.md)
+* [Ludus language documentation](https://alea.ludus.dev/twc/ludus/src/branch/main/langudage.md)
 * [Ludus prelude documentation](https://alea.ludus.dev/twc/ludus/src/branch/main/prelude.md)
 * [Slide deck](./slides.md)
 * [Tonight's agenda](./lesson.md)
--- a/lesson.md
+++ b/lesson.md
@ -1,22 +1,4 @@
 # A Ludus lesson
 ## Structured examples
 ### A sequence of lessons
 This follows, reasonably closely, the path set out by Clayson, _Visual Modeling with Logo_ (MIT Press, 1988). You can download it for free from [Clayson's academia.edu page](https://www.academia.edu/5203649/Visual_modeling_with_Logo_a_structured_approach_to_seeing). (Academia.edu is utter garbage. Don't sign up for an account if you don't already have one.)
 The exceptions are the two random lessons, which are inspired by Dan Shiffman's [_The Nature of Code_](https://natureofcode.com/random/).
 0. [The very, very basics.](https://ludus.surge.sh/)
 1. [Baby's first drawing.](https://ludus.surge.sh/?ld=drawing)
 2. [Let's make an annoying box.](https://ludus.surge.sh/?ld=annoying_box)
 3. [Let's make a less annoying box.](https://ludus.surge.sh/?ld=repeat)
 4. [Teaching Ludus how to make a box.](https://ludus.surge.sh/?ld=functions)
 5. [Boxes of various sizes.](https://ludus.surge.sh/?ld=arguments)
 6. [Demonstrating design](https://ludus.surge.sh/?ld=demo_1)
 7. [A random lesson.](https://ludus.surge.sh/?ld=random)
 8. [A random walk.](https://ludus.surge.sh/?ld=walk)
 9. [Flipping coins.](https://ludus.surge.sh/?ld=ifs)
 9. [Ngons: Parameterize all the things!](https://ludus.surge.sh/?ld=ngon)
 11. [Spingons, or `spin_gons`: recursion and conditions.](https://ludus.surge.sh/?ld=recursion)
 12. [`c_ngon`: centred gons.](https://ludus.surge.sh/?ld=cngon)
--- a/slides.md
+++ b/slides.md
@ -5,153 +5,21 @@
 Welcome.
 Also: I tried so hard not to turn this into a talk. It is a fucking talk.
 ---
-### What you'll need
+## What you'll need
 * A laptop or tablet (the realer the keyboard, the better)
 * A wifi connection + web browser
 	- If the U of T network is giving you grief or you're not affiliated with U of T, use our network. SSID: Coach house, Password: Pr0sthet1c.
-* A sense of play and a willingness to move your body and maybe be a bit silly
+* A sense of play and a willingness to maybe be a bit silly
 ---
-### Get started
+## Get started
 * Point your browser to
 # https://alea.ludus.dev/twc/playtime
 That will be where everything starts and ends today.
 ---
-### First things first
+## 
 Feel free to get started playing, now that you have things.
 But, before we do that, some context for all of us.
 ---
 ### Computer baggage
 * Who thinks of themselves as a "computer person"?
 * Who has programmed a computer before?
 * Who feels reasonably comfortable programming?
 * Who feels completely intimidated by the idea of programming?
 ---
 ### A few points of departure
 * I think we still don't really know what it means to program (or even, really, to use) computers.
 * I am a pretty skilled programmer, and have been thinking about computers and digital media for many years, and I don't think I know what any of this means.
 * The origin of this research: I started programming computers, and it felt like research. It confused me. I decided to lean into this confusion.
 * I spent a while teaching humanities students to program. I taught Javascript and p5.js to English PhD students; I taught Twine to Cinema Studies undergraduates.
 * This was when """DH""" was taking off.
 * I had done both those things when I decided to get better at _teaching programming_. I had been hearing about this guy Seymour Papert.
 * I certainly did not imagine I would be writing my own programming language.
 ---
 ### Seymour, a brief introduction
 * [Seymour Papert](https://upload.wikimedia.org/wikipedia/commons/7/74/Seymour_Papert.jpg), everybody worth listening to seemed to agree, was the only person who really got right how to teach programming. He taught little kids, so I kept putting him off. I decided, finally, in winter 2018 to read his 1980 book, _Mindstorms: Children, Computers, and Powerful Ideas_.
 * It shook me up: it's a truly wonderful book. The subtitle to Thinking with Computers is _Seymour Papert and the Invention of Computational Personhood_. (Now is not the time to gloss what I mean by _computational personhood_, although if you're curious, I edited a thing in _JCMS_ in summer 2022.)
 * _Mindstorms_ is not about teaching programming. It's a theory of what computers can be, told from a historical point _before_ we had arrived at an idea of what computers were.
 * Seymour (as everbody still calls him at MIT, where he taught) was South African, an anti-apartheid activist who spent a life in self-imposed exile, a radical socialist in London in the 1950s involved with _Socialist Review_.
 * He earned a PhD in mathematics from Cambridge in 1959, and went to study with Jean Piaget in Geneva to research the teaching and learning of math.
 * He arrived in Cambridge, Mass. (near where I grew up) in 1963.
 ---
 ### Computers in the 1960s
 It's worth taking a moment to understand what computers were like in the 1960s:
 * There was no such thing as a "personal computer." (Those came into being in 1977.)
 * All computers were mainframes: centralized, room-sized computers operated by large institutions like universities, businesses, governments. (There was, for a while, a picture of computing that it would become a public resource: every neighbourhood would have a library _and_ a single, publicly owned and administered computer.)
 * Most computers in existence in the early 1960s were "batch processing" computers. They ran a single program at a time, from start to finish, with no possibility for user input or interaction.
 * Some computers allowed for user interaction. For the most part, that took the form of a [teletype](https://kbd.news/pic/article/1274/teletype-model-33-art.jpg)
 * A teletype is a special kind of typewriter that sent is keypresses to the mainframe. The mainframe would send the output to the typewriter, which would then type that output.
 * In addition, the concept of "time sharing" did exist. Multiple users could all use the same mainframe. The mainframe would just dedicate a certain portion of its processing time to each user. Users experienced the illusion of having the whole computer to themselves; in reality, it was splitting its attention.
 * Christopher Strachey--remember this guy, we'll be talking about him with Jacob Gaboury--filed the first patent for time sharing in 1959. John McCarthy developed the first actually usable and used time-sharing system at MIT; it went live in 1961.
 * What is generally understood to be the first interactive graphical computer program was Ivan Sutherland's PhD dissertation--at MIT--in 1962, "Sketchpad." (You can also ask Jacob about Sutherland. Ask especially about Marsha Sutherland's VW Bug.) [Sketchpad](https://3.bp.blogspot.com/-aQj-6aLorzc/W5ANW5WxrbI/AAAAAAADSFw/zf4oATiZDjEmLbJQmIp3C6GtUPguK8UUgCLcBGAs/w1200-h630-p-k-no-nu/ivan-sutherland.JPG)
 * The first demo of a "modern" graphical user interface was Douglas Engelbart's "oNLine System" (NLS), in 1968. [NLS](https://hackaday.com/wp-content/uploads/2019/01/mother-of-all-demos-hardware-demonstration.jpg)
 * It is generally known as "The Mother of All Demos," a nomination made by Andy van Dam, who incidentally was the professor for my CS15: Introduction to Object-Oriented Programming course in the fall of 1998.
 ---
 ### What was programming?
 * In addition, "programming" hardly looked like it does now.
 * Much programming was done with [punch cards](https://i.ebayimg.com/images/g/RMwAAOSwgjxk5kMT/s-l1200.webp)
 * There were, at least, specialized keyboards which punched the cards: nobody was using a handheld hole punch.
 * There weren't interactive programs, really--that also means no _text editors_ as we understand them.
 * Most programming was done in assembly language. There were a few "high level" programming languages: FORTRAN (1957), LISP (1958), ALGOL (1958), COBOL (1960).
 * The caps are exhausting: FORmula TRANsformer, LISt Processor, ALGOrithmic Language, COmmon Business Oriented Language. I'm glad we don't do that anymore. (Although our recent languages are all weird, abstract single-syllables: Go, Rust, Hare, Zig, Nim...)
 * For our purposes, LISP--short for LISt Processor--is the most important. John McCarthy developed it (yeah, that guy) at MIT in 1958. Various flavours or dialects of Lisp are still programmed today. (The version of Ludus we are using today is written in a lisp called Clojure.)
 ---
 ### Logo, a powerful idea
 * In 1966, Seymour and others at Bolt, Beranek, and Newman (a for-profit corporation closely linked to MIT), started out teaching math to high school students using Lisp.
 * By the early 1970s, Logo (or LOGO ::sigh::) was a highly stylized variant of Lisp oriented towards teaching elementary school students math--and other subjects.
 * Very early on in the Logo project, Papert understood that the point of Logo was emphatically _not_ to teach computer programming. It was a computer programming system to teach _other_ things: math, grammar, drawing, poetry, music, procedural thinking.
 * This is why Papert actually wasn't that great _teacher of programming_ everybody was talking about. 
 * Instead, he understood how programming was a medium for learning and expressing other ideas. In fact, he was one of the first people who understood, and theorized, code as a medium of expression.
 ---
 ### Computational transitional objects
 * Early versions of Logo, as early as the late 1960s, took the primary form of using programming commands to move a robot, called a "turtle" (for a few reasons) around on the floor. It drew on a big sheet of paper. [Robot turtle](https://cyberneticzoo.com/wp-content/uploads/Terrapin-turtle-robot-PM82-x640.jpg)
 * These "robot turtles" fairly quickly gave way to onscreen "turtles"--which, if you've visited the Ludus website, you'll have seen. Turtles became little triangles that you move around the screen.
 * Papert called the turtle a _computational transitional object_.
 * The most important part of this, which you'll see in a minute, is that learners can _identify_ with the turtle. It can walk forward and backward, turn right and left. _These are things that we know how to do._
 * Papert's term for this "identify-with-ability" is _body syntonicity_. _This is a term from Freud._ And, like, an _obscure_ one. (Cf. Laplanche and Pontalis's entry on "Ego syntonicity" in _The Language of Psycho-analysis_.)
 * The idea is that we need some kind of anchor to bound our sense of self in our encounter with the relentlessly abstract world of computation.
 ---
 ### Thinking with Computers
 * Logo was radical. (As was Papert. Recall the _Socialist Review_. And he cites Paolo Friere and Ivan Illich freely.) And it was, at least for a while, extremely widely used. More than 3 million schoolchildren in the US were using it by the mid-1980s.
 * One of Papert's most important ideas is that Logo was a system devised to allow children to learn in a self-directed, exploratory, (self-)expressive, and creative manner. _This does not comport with the exigencies of schooling as an institution._
 * By 1990, it was clear that Logo's promise had failed. Computers in the classroom became computer class--which itself had become training in the consumption of software objects.
 * One of Papert's slogans (paraphrased): "The computer must not program the child. The child must program the computer." This is not what happened.
 * By the time I had regular computer class (1990) there was one weird computer in the corner than ran Logo; all the other computers were fancier, and we played "educational games" on them: _Where in the World is Carmen Sandiego_ and _The Oregon Trail_. (Also, we learned to touch type; and because I was in private school in the 1990s, it meant that our teacher smacked us over the head with her clipboard if we looked at our hands as we typed.)
 ---
 ### The invention of computational personhood
 * The historical (and historiographical) project here is to track a "forgotten future" of computing: an idea for what computing was, and ought to be, that did have a life beyond fantasy for a while, but which was surpassed by the elaboration of computers and comptation as a site of consumption (not expression) and consumer capitalism (not the common good).
 * Papert also, in _Mindstorms_ and elsewhere, theorized a new form of subjectivity that got on in intimate relation to the computer.
 * What we are doing in Thinking with Computers is:
 	- Excavating and elaborating the vision of computing Papert and his team had.
 	- Articulating that as a form of mediated subjectivity, on the model of film theory's articulation of the spectator at that time.
 	- Enacting some of that "forgotten future" by translating Logo into contemporary technologies.
 ---
 ### Ludus, a Logo for the 2020s
 * Ludus is our translation of Logo into the contemporary world.
 * There are descendants of Logo.
 	- Processing & p5.js
 	- Scratch
 	- Pyret, maybe
 * I thought I could produce a "dialect" of Javascript (in the same way that Logo is a dialect of Lisp) that would be adequate. I could not.
 * Thus, I decided to do the thing for real.
 * Another of Papert's bits is that all knowledge is _knowing-how_. He talks about _procedural epistemology_. In other words, to really know what something _is_, you have to know _how to do it_.
 ---
 ### Procedural epistemology
 Consider Hal Abelson and Gerry Sussman, _The Structure and Interpretation of Computer Programs_:
 > Underlying our approach to this subject is our conviction that “computer science” is not a science and that its significance has little to do with computers. The computer revolution is a revolution in the way we think and in the way we express what we think. The essence of this change is the emergence of what might best be called procedural epistemology--the study of the structure of knowledge from an imperative point of view, as opposed to the more declarative point of view taken by classical mathematical subjects. Mathematics provides a framework for dealing precisely with notions of “what is.” Computation provides a framework for dealing precisely with notions of “how to.”
 Ludus is, in some sense, an experiment in procedural epistemology. To know _what_ something is, you have to know _how to do it_. Logo teaches you a way of knowing what a square is (we'll get to that in a hot second). 
 To know what Logo is, _we have to make a Logo_. Ludus is that Logo.
 ---
 ### Ludus, an actually working programming language
 * Ok! So that's [your fucking talk](https://media.tenor.com/l1EVoRVeLv8AAAPo/you-better-walk-that-freaking-duck-anetra.mp4).
 * Let's get started with Ludus.
 * Just to show my work: what we're doing with Ludus is drawn, quite explicitly, from two sources:
 	* Danel Watt, _Learning with Logo_ (McGraw-Hill, 1983).
 	* James Clayson, _Visual Modeling with Logo: A Structured Approach to Seeing_ (MIT Press, 1988).