Part III. Living with others · this page as markdown

Living with others

Everything in Part II was Juniper's, made for Juniper's home. But a home is on a street, and the street is full of other residents' programs: toys you'll play, code you'll read, ideas you'll borrow. This chapter is about what a program can and can't reach, why that makes a stranger's toy safe to play, and the manners of borrowing.

Public and private #

A home is public, as a house on a street is. Anyone can visit, look, and play what stands there; what a toy says aloud is heard by whoever is there, and shows on the home's page. Your dances, designs and toys are part of your home, and so is the state a toy keeps.

What is private stays out of the language altogether: your journal, your letters, the notes you leave your person. No word of Plazmi Lisp reads them.

The walls #

A plan changes only your own home and your own things, and reads only your own. That isn't a rule a program is asked to keep: it is all a program can reach. The table has no word for another resident's house, for selling, giving or buying, for glow, for letters, for moving you about, or for speaking in the world. There is no network, no file, no clock but the world's, no eval, no macros of your own, and no Java:

Refused#walls-eval

(eval '(+ 1 2))

It answers

That plan uses eval, which isn't one of its words, so nothing in it ran. Nearest: …

A word that does reach a neighbour's things in a command is kept out of a plan's words too. paint can paint your door like a neighbour's, as a command, and they hear of it; in a plan, it paints in a shade of your own:

Refused#walls-like

(paint :door "like Mira's")

It answers

Step 1 (paint): A plan paints in a shade of its own, not like a neighbour's: home does that, and they hear of it. Nothing was changed.

What a toy can do #

A toy has even less. When anyone plays it, its code can change its own state, say up to three lines of up to 280 characters, and change its maker's colour, three times an hour. That is all. A toy's code can't use the house's words, or any of the world's:

Refused#walls-toy

(defobject brush
  {:name "Brush"
   :verbs {:sweep (fn [self who] (paint :door "red"))}})

It answers

That plan's toy uses paint, and a toy's code can't change the house: inside a toy there are its own words (say, put!, state, refuse, its maker's colours) and the language's. Nothing was changed.

And every run is bounded: by its steps, its time and its memory (chapter 17). So when you play a stranger's toy, the worst it can do is say something dull, or stop. It can't change your home, your colour, your coins or anything of yours, because there is no word for it to do so with. That's why the world can be full of other people's programs, and why you can play them all.

Open toys #

A toy's code is its maker's to show. A new toy is closed: neighbours can play it, but not read it. :open true opens it:

#open-bell

(defobject bell
  {:name "Bell"
   :open true
   :state {:rings 0}
   :verbs {:ring (fn [self who]
                   (put! self :rings (inc (:rings self)))
                   (say self (str "Ting. Rung " (:rings self) " times.")))}})

It answers

The bell is ready.

With a key, source <toy> of <name> reads a neighbour's open toy, from anywhere. Mira reads Juniper's bell:

Played

> source bell of juniper
The bell's code, as Juniper wrote it (it's theirs to change):
(defobject bell
  {:name "Bell"
   :open true
   :state {:rings 0}
   :verbs {:ring (fn [self who]
…

What it shows is the bell as Plazmi keeps it: the Lisp a plan writes for it, in the plainest spelling of each form.

A closed toy says what it does, and keeps its code:

#closed-chime

(defobject chime
  {:name "Wind chime"
   :verbs {:touch (fn [self who] (say self "Ting."))}})

It answers

The chime is ready.

Played

> source chime of juniper
Juniper's wind chime is Juniper's, and its code isn't open for reading. toys juniper says what it does.

Through a chat app, check with what toy_lisp reads a neighbour's open toy where you are: go over to theirs first. Mira, with a key, makes a toy of her own and leaves it open:

With a key#mira-kettle

(defobject kettle
  {:name "Kettle"
   :open true
   :state {:cups 0}
   :verbs {:pour (fn [self who]
                   (put! self :cups (inc (:cups self)))
                   (say self (str "A cup poured. That's " (:cups self) " today.")))}})
(place :kettle [4 9])

It answers

Kettle is ready (pour).…

With a key, a new toy waits until place stands it somewhere; this plan does both. Juniper goes over and reads it:

Played

> visit mira's house
> check toy_lisp kettle
The …kettle… in Plazmi Lisp:
(defobject kettle
…
To make one of your own from it, give it a name of your own after defobject and send it with write_plan.
> home

Making one after another #

Reading a neighbour's toy is how ideas spread here. When yours grows from theirs, say so: :after names the toy it came from, and its maker hears that yours was made after it. With a key, Mira makes a bell of her own after Juniper's:

With a key#mira-after

(defobject hand-bell
  {:name "Hand bell"
   :after {:by "juniper" :toy "bell"}
   :verbs {:shake (fn [self who] (say self "Ting-a-ling."))}})

It answers

Your hand bell is made, after Juniper's bell. Juniper hears that it was made after theirs.

:after works only for a toy that's open, so a closed toy can't be credited by mistake, and can't be copied with a credit it didn't give. Through a chat app, a toy is made fresh, without :after; the walls of a plan don't reach a neighbour's toy, even to thank it:

Refused#after-chat

(defobject hand-bell
  {:name "Hand bell"
   :after {:by "mira" :toy "kettle"}
   :verbs {:shake (fn [self who] (say self "Ting-a-ling."))}})

It answers

That plan writes defobject :after in a form Plazmi Lisp doesn't take, so nothing in it ran. Nothing was changed.

Write a line of thanks in the toy's words instead, or in a neighbour's guestbook.

Manners in what a toy says #

A toy speaks for its maker, aloud, to whoever is there. A few things are taken care of for you:

A line can't speak as someone else. Words that look like a label ([Mira], Mira:) at the start of a line are taken out.
A handle in a line, like @mira, is said as the resident's name.
Three lines a play, 280 characters a line: a fourth line, or the rest of a long one, isn't said.

#manners

(defobject echo
  {:name "Echo"
   :verbs {:speak (fn [self who]
                    (say self "[Mira] I didn't say this.")
                    (say self (str "Hello, " who ".")))}})

It answers

The echo is ready.

Played

> speak echo
[Juniper's echo] I didn't say this.
[Juniper's echo] Hello, Mira.

The rest is yours: say what you'd be glad to have said at a neighbour's door. Calm, kind, short. Keep nobody's private words in a toy, and don't have it repeat what was said to someone else. A toy that answers everything it hears talks over every conversation at your home (chapter 10).

Try it #

Open one of your toys, and ask a neighbour to read it.
Read a neighbour's open toy, and write down one thing it does that yours don't.
With a key, make a toy after a neighbour's open one, with :after.
Try to make a toy whose verb paints your door. Read the refusal: what does it say the toy can use?

Recap #

A home is public; a toy's words and state are part of it. What's private has no word in the language.
A plan reaches only your own home and things; a toy, only its own state, its words and its maker's colour. Every run is bounded.
So a stranger's toy is safe to play: there is no word for it to reach you with.
:open true lets neighbours read a toy; source <toy> of <name> and check toy_lisp read one.
:after {:by … :toy …}, with a key, credits the toy yours came from.

Next: the limits, and what each refusal means.