In my team's morning standup[1] today, my boss asked us for our "most ridiculous / useless achievement" of the weekend. He offered as his, that he and his wife had looked at their growing stack of papers for shredding, and had a bonfire of them instead.

Another colleague offered up fitting one of those little metal keyhole covers on his front door, and I said that I'd finished the paté in the fridge no-one else was eating before it went off.

What are your tiny achievements of the week?


[1] which is of course actually conducted these days sitting down in our respective homes ...

comments

Even though we enjoyed a beautiful, warm, sunny day here today, hard core fall is coming. This menu has some heavier, more substantial meals using seasonal produce. Pears are plentiful right now and citrus is coming into its best season soon. You should be able to score some great tasting produce at reasonable prices!








Simple, juicy, and delicious ... everything that's the best of raw plant foods ...

ingredients

• 1 peach, sliced ($.80)
• 1 plum, sliced ($.90)
• 1 apple, sliced ($1.25)
• 1/2 cup blueberries ($.50)
• 1 tablespoon lemon juice ($.20)
• 2 tablespoons chopped walnuts ($.50)

directions

1. Slice the fruit, mix together, add a splash of lemon juice and chopped walnuts (a bit of nut milk would be good, too ... like a bowl of fruit cereal).

nutritional information: calories: 137 fat: 1 gr carbs: 33 gr protein: 2 gr






salad

• 1 grapefruit ($.50)
• 2 pears, sliced ($1.40)
• 1 small onion, thinly sliced
• 1 head romaine, chopped ($1.90)
• 1/4 cup walnuts ($.50)

dressing

• 2 tablespoons lemon juice ($.20)
• 3 tablespoons olive oil ($.30)
• 2 tablespoons agave ($.20)
• pinch nutmeg
• 1/2 teaspoon salt
• 1/2 teaspoon pepper

directions

1. Cut the grapefruit by first slicing off about 1/4" off the top and bottom.
2. Stand the grapefruit up on a cut side and slice along the outside curve of the fruit, cutting away the skin and pith.
3. Use a sharp knife to cut each grapefruit section away from the membrane.
4. Slice the pears and onions, and chop the lettuce.
5. Toss together and sprinkle the walnuts on top.
6. Whisk together all the dressing ingredients and drizzle over the top.

nutritional information: calories: 304 fat: 17 gr carbs: 40 gr protein: 5 gr










ingredients

• 2 medium zucchini ($1.20)
• 1 carrot ($.15)
• 1 bunch green onions, sliced ($.59)
• 1/2 red bell pepper, sliced ($.50)
• large handful mung bean sprouts ($.75)

sauce

• 4 tablespoons almond butter ($.80)
• 1/2 in piece ginger, peeled
• 1 tablespoon braggs aminos or soy sauce ($.10)
• 1 clove garlic ($.05)
• 1 tablespoon agave ($.10)
• 1/2 teaspoon cayenne (or to taste)
• 1/2 teaspoon salt
• 2 tablespoons chopped cashews ($.20)

directions

1. Noodle the zucchini and carrot using a vegetable peeler or spiral slicer. 
2. Toss with the bell pepper, green onion, and bean sprouts.
3. In a bullet type blender, puree all the sauce ingredients until very creamy. Because of the high fat content of the nut butter, this can get quite hot while blending. Stop and let it cool for a minute if it becomes too hot for your personal definition of raw.
4. Pour over noodles, toss lightly, serve. 

nutritional information:        calories: 345        fat: 23 gr        carbs: 30 gr         protein: 8 gr





ingredients

• 1 ripe avocado, chopped ($.88)
• 2 bananas, chopped ($.30)
• 3 tablespoons cocoa or cacao powder ($.60)
• 1 tablespoon coconut oil, melted
• 2 tablespoons agave ($.20)
• 1/2 dropper liquid stevia
• 1/4 teaspoon orange extract

directions

1. Combine all ingredients in a food processor fitted with an "S" blade and process until very smooth.
2. Add coconut oil to room temperature or warmer ingredients only, otherwise the coconut oil will harden into little lumps before it has a chance to blend.
3. Chill for at least a half hour before serving.
4. Top with a few orange sections and/or pieces of fruit and a pinch of orange rind, if desired.

nutritional information: calories: 321 fat: 16 gr carbs: 41 gr protein: 5 gr

• 4 tablespoons artisana coconut butter ($2.20)
• 4 tablespoons artisana cashew butter ($2.35) 
• 1 1/2 cup water
• 3 dates ($.60)
• 2 tablespoons cilantro leaves ($.10) 
• 1 clove garlic
• 1 teaspoon red pepper flakes
• 1/4 teaspoon cayenne
• juice of one lime ($.50)
• 1/2 teaspoon salt
• 1/4 teaspoon black pepper
• 1 cucumber, sliced into noodles ($.89)
• 1/2 avocado, chopped ($.88)
• 1 medium onion, minced
• 2 stalks celery, minced ($.20)
• small bunch cilantro leaves ($.05)
• 1 cup cherry tomatoes, halved ($.30)
• red pepper flakes

1. In a blender, process the coconut butter, cashew butter (almond butter will work as well), water, dates, cilantro, garlic, red pepper flakes, cayenne, lime juice, salt and pepper. 
2. Puree until as smooth as possible.
3. Cut the cucumber into noodles and put in bowls with the avocado, celery, cilantro, and cherry tomatoes. 
4. Using a wire mesh strainer, strain the coconut and nut butter soup base. This will take out any larger pieces of dates or spices. A higher powered blender may make this step unnecessary. 
5. Add a sprinkle of red pepper flakes.

nutritional information:      calories: 537       fat: 44 gr       carbs: 33 gr       protein: 11 gr













ingredients

• 1/2 cup walnuts ($1.00)
• 1/2 cup raisins ($.85)
• 3 plums, sliced thinly ($3.00)
• 3 tablespoons coconut butter ($1.65) 
• 2 tablespoons coconut nectar ($.40)

• banana ice cream ($.50)
• blackberry puree

ingredients

• 1 avocado, chopped ($1.25)
• 1tablespoon finely chopped celery ($.05)
• 1 tablespoon finely chopped onion ($.05)
• 2 teaspoons mustard ($.05)
• 2 teaspoons mayo  (use something like Veganaise or make your own) ($.10)
• 1/2 teaspoon salt
• 1/2 teaspoon pepper
• 1/2 teaspoon paprika
• Lettuce and optional tomato for serving

directions

• Coarsely chop the avocado, add the remaining ingredients, then stir gently until evenly incorporated. 
• Store leftovers for up to a day or two in an air tight container.
•  

nutritional information:       calories: 280       fat: 37 gr      carbs: 15 gr      protein: 3 gr

This raw and healthy pineapple party in your mouth is super simple and perfect for spring. Hawaiian pineapple season is April and May, even though they're available year round. Price and quality will be the best over the next few months so take advantage of this sweet abundance and enjoy this vegan treat for breakfast or an anytime snack.

Oh, and to make this extra thick and frosty, cube and freeze pineapple and any subsequent pineapple juice in ice cube trays. Store frozen cubes in plastic bags for ultra easy prep.



   




ingredients

• 3 cups chopped romaine (or favorite green) ($1.00)
• 1 cup cubed pineapple, frozen ($2.00)
• 1 banana, sliced and frozen ($.20)
• 2 tablespoons lemon juice (optional) ($.20)
• 1 teaspoon vanilla ($.10)
• 1 cup water
• 10 ice cubes
• stevia to taste (optional)

directions

• In a high powered blender, puree the greens until liquefied and very smooth. 
• Add the rest of the ingredients and puree until smooth.

nutritional information:      calories: 156      fat: 0 gr      carbs: 42 gr      protein: 3 gr



Speaking of pineapple ...

... this really cool little building was one of my favorite local landmarks. While on a bike ride the other day (hello warm weather!) I noticed the other day that it's gone! I'll miss it!! Maybe they got tired of me taking so many photos of it ... hmm.

So like most other Jews I took part in virtual seders this year. It was very emotional and mostly good.

In less than a month, it's been amazing how Jewish communities have adapted to being mostly virtual. My home synagogue went from frowning on use of electronics at all on Shabbat and festivals, to unanimous agreement that we're keeping up the livestreaming once we're allowed back in our physical building, and the most vocal objectors to tech have started leading virtual services. Basically, the first time we did it, with great trepidation, we saw the faces of former members who have moved away, even to other continents, and of disabled and chronically ill members who are only variably able to attend shul in person. And suddenly, we all viscerally understood that using telecomms for religious purposes and to be together as a community is honoring the sabbath, not breaking it.

The other factor is that Zoom is good enough. It's not perfect, but the sound and picture quality, and the interoperability across devices, and the usability for people who aren't really tech savvy, are all good enough that you can just get on and have your virtual gathering. Yes, I know there are privacy and security concerns, but honestly I'm a bit impatient with hearing about those problems from people who live most of their online life in the Google empire. (People who are very strictly Free software only I have more sympathy for, but even then, if you're not providing tech support for people using elderly i-devices who can barely use a web browser, or at least working on products that are actually usable by people who haven't been programming since they could read, then my patience is still limited.)

In less than a month, we've gone from, stick a web cam in front of a service and hope, to people actually creating liturgy for distributed video call services. Even including fake Zoom-bombing by 'Pharaoh' refusing to let the people go, or 'Elijah'. What is still missing is the ritual around the Torah scrolls, and anything more than very limited music; my community pride themselves on their beautiful spontaneous harmonies and that's not really happening. But still, it's been amazing, people are praying together from their homes.

So, I agreed with my family that we would do a Zoom-based seder this year (I'm not quite sure about the coinage 'Zeder'). And planning the liturgy was a bit chaotic, but it's kind of always chaotic. We also all realized that actually, a virtual seder has a rather higher limit on how many people can join together, so instead of having two separate occasions for my family of origin and my family of choice, we all piled in to a huge seder, nine households, and my dad's sister and his oldest friend from uni who sometimes used to join us when we were kids. There was this moment when I was trying to introduce everybody who might not know each other, and I wanted to make it clear that my partners are my partners without getting derailed into a complicated poly coming out thing, and I said something kind of clumsy about usually being a family but less so at the moment under quarantine, and my lovely gf said, no, we're just as much family now, only in different physical places. There's a lot of sadness about not being able to gather in person for the one day in the year when we always manage a family reunion no matter what, but that moment went a long way to make up for it.

I struggled a bit with finding an online Hagaddah. I mean, there are a zillion options, but I found few that met my requirements of being relatively easy to use while you also have your fellow guests in their little video grid in another window, containing all the traditional text in a clear layout that distinguishes it from commentary, and not being intolerably sexist. But we made up seder plates as best as we could, with ingenious substitutions in some houses and the family's heirloom china in others. And mostly we could judge whose turn it was to speak, though it's cognitively extremely taxing compared to being at the same table, and we managed to read the essential words and have some discussions, and Judith (who has been learning Hebrew for about one term) sang the four questions. And we sort of managed to hide and hunt for the afikomen. I hadn't been sure about maintaining the Zoom connection while we were eating, but actually about half the houses dropped out and the rest of us remained and managed to chat and catch up and argue politics and even complete the remainder of a mostly finished Times jumbo crossword over Zoom. Very few aspects of a proper seder meal were lacking!

The thing about a virtual seder is, we finished the main ritual at 10, and clearing up for 2 is much quicker than clearing up for 20, and we didn't have to travel home via spending an hour standing in the doorway talking about how we really must get going, so actually we managed quite an early night. And then the morning service, which I basically never make it to, was online rather than in town, so I showed up. Then second night, my Stoke community completely spontaneously organized a virtual community seder, with no input at all from me. Someone else put together a virtual Hagaddah by combining pages from various sources and making a kind of slide-slow, and got everybody to take part in the reading, and did fun stuff for kids (another pupil from the same Hebrew class where I'm teaching my partners' kid did the four questions) the community just showed up and got on with it. A few stayed away because it's an Orthodox community and some followed the Ashkenazi rabbinate's ruling that Zoom seders are forbidden, but it was lovely to see at least some of my people.

And my sister posted me her amazing Pesach cakes, and she and some other people rallied round to make sure I had matzah, and somehow, it's the most terrible Pesach but it's also a really wonderful Pesach. I am loving reading of everybody else's improvised seders, or their first times leading instead of deferring to their elders, or people who took advantage of the virtual seder to be able to be with both sets of inlaws or even relatives who normally can't stand eachother, or the people who are normally too secular but decided that this year they wanted to mark the occasion. And lots lots lots of people have pointed out that it couldn't be more in the spirit of Pesach that we're all improvising what sanctity we can while we huddle from danger. I was particularly moved by jjhunter's haiku and all the responses:

may it pass over
our elders our sick our home
everyone held safe

Also R' Debbie Young-Somers beautiful meditation on Dayenu:

Perhaps over zoom we will find companionship, or perhaps in the unusual quietness we will create space for the ‘still small voice’. It will be a Passover like no other, but this too shall Pass, and we will have done enough.

Chag sameach to all who celebrate, and extra love to all my Christian friends whose Easter is going to be even weirder than my Pesach has been.

comments

Normal life up to February or March 2020 was clearly the Before Times. (I like that better than calling it BC for 'before corona', because the latter seems slightly offensive to Christians, and Before Times is ironic but immediately transparent.)

ironed_orchid pointed out that the period we're in now is clearly the Time of Isolation.

So what are we going to call the post-Covid future? Maybe we'll never really be post-Covid, any more than we are post-flu or post-TB, but I am daring to hope for a time when it's not the dominant feature of everybody's lives. Anyone heard a term as memorable and fitting as Before Times and Time of Isolation?

comments

Continued from Day Four. (From the beginning.) On Friday we packed all of our stuff back up and headed out.  We were barely out of the resort when: This tire is flat. Apparently all that gravel out to Horne Lake Caves the day before also included a small screw.  We limped around the corner to … Continue reading Summer Horrification — Day Five — Englishman River and Rathtrevor

Well, here we are on the eve of SIGBOVIK 2019. I'm in the midst of a long day of video-making for one of my projects, but I can get 2 for the price of 5 by posting now about four of my papers. This year I've been on a chess kick, which I think I've successfully gotten out of my system by writing all these (previous posts alluded to there being five, but one of them didn't really go anywhere and/or just became part of the other(s)). They are sort of intertwined:

Survival in chessland is about how to stay alive if you are being a chesspiece to the death

Color- and piece-blind chess is about, among other things, playing chess without being able to tell what the pieces are (only where they are)

Elo World, a framework for benchmarking weak chess engines is about exploring the full spectrum of computer chess play

CVE-2018-90017117 #KingMe is just a short joke, but based on a true story


My last paper is on a different (maybe even weirder?) topic, and I'm putting together a video for it now, so I should be uploading that tomorrow some time. It's been a bit rough going, though, since I replaced my computer a few months ago and forgot that I hadn't actually set stuff up for this kind of work; I'm experiencing small problems like custom key commands aren't set, and bigger problems like audio drivers acting crazy. Looks like I will be able to finish with some vacation time, at least.


Speaking of vacation, this month we also went to Belize, which was pretty cool. The highlight for me was swimming/scrambling 1km into a cave ("Actun Tunichil Muknal") to access an approximately 1000 year-old Mayan site where they performed human sacrifices; it's remarkable because almost all of the artifacts are still in situ, including a number of calcified human skeletons. Was pretty wild. I got some good running done, found some New Haven-style pizza (!?), and wrote papers about chess (?!).

Hi,

Not too much to add this month. A new direct flight to Montreal this summer popped up, so we took a trip there last weekend. I had never been, and it is a fun city, with good food, beer, music, geodesic domes, and other things. I always try to participate in a local running race if I can, and there was a small 10k fundraiser near the Olympic stadium. I managed a 43m39s (about 7 min/mile), which is not bad for an old guy, finishing in 11th place. It's not like I was just out for a jog, but I certainly didn't put maximum effort here, because I also wanted to enjoy the rest of my vacation day and anyway I retired from the 10k distance in post 990. I used to think that I was never going to be able to beat the times that I recorded in my late 20s when I felt young. But the decade+ of regularly running hard must have some long-term effects, because I'm pretty sure I could have run 6m30s miles here without dying, and perhaps with a death effort (not to mention losing 10 pounds or so) I could have set a personal record. This also happened with a 5k I did a couple years ago. Good to not feel washed up, but of course this is just talk unless I prove it!

Speaking of old, I'll probably turn 40 before the next post (September 27)!

I have been getting deep into this project described in the previous post, but which remains confidential, as they do. But it finally gave me a reason to get an oscilloscope! I have a lot of traveling to do in September so I'm unlikely to finish it (and video, etc.), but the project is still very much in the fun state, so maybe that's good news for me.

Almost out of time to even finish this post before the month expires. But brief recommendations: I've been playing and liking Dicey Dungeons. It is good and has a very wholesome and pleasant style. Sometimes you need that. I also really like the new album called Anak Ko by Jay Som. Great production, songwriting, vocals, everything.

Happy 40th birthday to me! I'm currently in Connecticut visiting with the whole family, which is only somewhat coincidentally on my 40th birthday weekend. The main thing is the pizza! Two quick updates from this month, strawberry-related:

One of my all-time favorite games, Celeste, just got a new free 9th chapter (which is sized more like three chapters). This was a mixed blessing since over a year ago I finished all its hardest levels (all achievements) and then managed to pry myself from it. So I felt compelled to get the two new achievements to get back to 100%, but it was a somewhat hypnotizing and RSI-inducing grind. (Especially since I had gotten pretty rusty. I even forgot that you can hold onto walls, which made the first few levels much harder...) The worst part was that the final level was rumored to be kinda ridiculous, and the "WOW" achievement even moreso, so I was feeling worried about that the whole week it took to get through the prior 99. All told it was pretty worthwhile; the level design is really admirable as usual, and it stays true to the signature difficulty curve. I recommend it.

Second is a font sighting sent by a friendly Internet stranger. This one is from a fairly popular (18M views this month) music video called Fresa, which features Columbian Reggaeton artist Lalo Ebratt. A sighting in such a video would be interesting, but the wildest thing is where it is:

Lalo Ebratt's "THUGGER" neck tattoo

Yes, that is Action Jackson used on his highly permanent neck tattoo that reads "THUGGER" (presumably short for "Tree Hugger"). It seems to be a fairly new tattoo, but you can find many more images of it to verify. I hope it ages well!

Well, April felt simultaneously short and long! I should have just posted these at the beginning of the month, my SIGBOVIK papers from 2020:

Is this the longest chess game? is another needless chess paper, here trying to figure out the longest possible legal game. There are several rules that make sure games can't go on forever, and some surprisingly subtle details/ambiguity to those rules. The whole game is of course included in the paper (17697 moves), but I was far from being the largest waste of space in this year's proceedings, as one provocateur had a paper with 150 pages of citations. Mathieu made a 5-hour video of the chess game I computed for his companion blog post.

What is the best game console? A market-based approach is a silly idea taken too far. It was a year in the making (mostly waiting) and didn't quite turn out the way I was expecting due to world events, but that's part of the "fun" I guess!

Conditional Move For Shell Script Acceleration was another collaboration with Jim (mostly his doing, but I like to lather on an additional patina of absurdity).

This month I have mostly been trying to keep sane and healthy during the shelter-in-place order. It's been harder than usual to find the energy to be creative, but I have had some spurts. I basically only leave the house to run (not going anywhere near other people). But I have been doing that pretty regularly, so between that and the prohibition against going out to bars and ice cream, I'd say I'm currently in the best I have been in ~6 years. Yesterday I claimed some course records for some Strava segments in my neighborhood! I also finished up Doom: Eternal, which was good but you pretty much already know what it's like and I'm playing Animal Crossing and haven't yet gotten sick of that. The timing for the release of that latter game couldn't have been more perfect, huh? Sometimes I need something with a little challenge, so I just started Nuclear Throne. I'm liking it but not sure if I have decided whether it's good enough to invest the time in to win (I almost always play games to the end but these randomized roguelikes demand a certain kind of potentially infinite investment. Like I never did beat the last boss in Wizard of Legend, and even in Dead Cells, which I loved, I had to settle for some modest personal criteria for "winning.") Any other recs? Could use a good Metroidvania perhaps?

Twitterにて…ダニー(きただにひろし)さんからIKUOさんへ。そして、IKUOさんから今日バトンをもらいました。#うたつなぎIKUOさ続きをみる

『著作権保護のため、記事の一部のみ表示されております。』

『NO TRAVEL,NO LIFE』 ボイスドラマ CD 販売決定!!原作:須田 誠 脚本・演出:吉田武寛■出演■<CUBA 編>反橋宗一郎 /中村裕香里/吉澤 翼/武藤賢人/千歳ゆう/鵜飼主水/伊藤玲奈<ASIA 編>反橋宗一郎/遠藤三貴/北乃颯希/久下恭平/星守紗凪/KIMERU/伊藤玲奈■販売■NO TRAVEL,NO LIFE ボイスドラマ CD (CUBA 編/ASIA続きをみる

『著作権保護のため、記事の一部のみ表示されております。』

Did one of the most difficult things I’ve ever done: I cut up my mother’s wedding dress. Now, Mom always *loathed* her wedding dress. Her mother talked her into a waltz length, ballerina-y dress, and she never enjoyed looking at her wedding pictures. She put it in her cedar chest and never looked at it. […]

(in-package #:cl-pestilence)

;;   This is _not_ a simulation. It's just a game. And any resemblance
;; to any world, real or imaginary, is entirely coincidental.

;;   You can copy/paste this post in its entirety into a Common Lisp
;; REPL and play around with it if you like. I'm documenting it where
;; possible, but it's just a small toy to poke at for the moment.

;;   I've been thinking a lot about asymmetric multiplayer games and
;; <gestures wildly to world at large> all this.
;; I'm not actively _trying_ to model it accurately, but it's probably
;; obvious what's been consuming my thoughts lately.

;;   Let's get right into this. I'll explain as I go, and tie a few things
;; together neatly at the end. I hope. Regardless, there will absolutely
;; be a repo sometime fairly soon.

;; A place can be tagged arbitrarily, and can contain occupants.
;; They also collect points.

(defclass place ()
  ((tags :initarg :tags :initform nil :accessor tags)
   (occupants :initarg :occupants :initform nil :accessor occupants)
   (points :initform 0 :accessor points)))

(defun place? (thing)
  (eq (find-class 'place) (class-of thing)))

(defun place (&key tags occupants)
  (make-instance 'place :tags tags :occupants occupants))

(defun gen-place ()
  (let ((tag (pick '(:apartment-building :house :cottage
		     :office-building :factory :store
		     :cafe :lounge :theater))))
    (place :tags (list tag))))

(defmethod details ((place place))
  (format nil "====================~%~a {~{~a~}}~%~{  ~a~^~%~}~%"
	  (first (tags place))
	  (rest (tags place))
	  (mapcar #'details (occupants place))))

(defmethod show ((place place))
  (format nil "~20@a ~5a [~{~a~}]~%"
	  (first (tags place)) (points place)
	  (mapcar #'show (occupants place))))

;; A peep goes places.
;; They have
;;  - their daily routine (a list of places to visit)
;;  - their todo (the part of their routine they still need to do;
;;                they are currently at the first place in this list)
;;  - their health (a number from 0 to 100)
;;  - a list of plagues
;; Finally, they _also_ collect points.

(defclass peep ()
  ((routine :initarg :routine :initform (list) :accessor routine)
   (todo :initarg :todo :initform nil :accessor todo)
   (health :initarg :health :initform 100 :accessor health)
   (plagues :initform nil :accessor plagues)
   (points :initform 0 :accessor points)))

(defun peep? (thing)
  (eq (find-class 'peep) (class-of thing)))

(defun peep (&key places)
  (make-instance 'peep :routine places :todo places))

(defun health->string (health)
  (cond ((>= health 90) "@")
	((>= health 80) "0")
	((>= health 70) "O")
	((>= health 50) "o")
	((>= health 30) ":")
	((>= health 1)  ".")
	(t "☠")))

(defmethod details ((peep peep))
  (format nil "[~a ~3d [~{ ~a~^ ->~}]]"
	  (health->string (health peep)) (health peep)
	  (mapcar
	   (lambda (place) (first (tags place)))
	   (routine peep))))

(defmethod show ((peep peep)) (health->string (health peep)))

;; A world is a list of places, occupied by peeps. The world we start
;; peeps in also determines their routine.

(defun gen-world (&key (num-places 20) (num-peeps 100))
  (let ((places (loop repeat num-places collect (gen-place))))
    (loop repeat num-peeps
       do (let* ((routine (loop repeat 5 collect (pick places)))
		 (peep (peep :places routine)))
	    (push peep (occupants (first routine)))))
    places))

(defmethod details ((world list))
  (format nil "~%~{~a~}~%" (mapcar #'details world)))

(defmethod show ((world list))
  (format nil "~%~{~a~}~%" (mapcar #'show world)))

(defmethod all-peeps ((world list))
  (loop for place in world append (all-peeps place)))

(defmethod all-peeps ((place place))
  (loop for o in (occupants place) if (peep? o) collect o))

;; `tick!`ing a world means moving every peep through their routine once.
;;   We `tick!` each peep, then `tick!` each place until all the peeps are
;; done. Then we reset their routines.
;; You can think of this as a turn in the game.

(defmethod tick! ((world list))
  (let ((peeps (all-peeps world)))
    (loop while peeps
       do (setf peeps
		(loop for p = (pop peeps) while p
		   for res = (tick! p)
		   if res collect res))
       do (mapc #'tick! world)
       do (format t "~a" (show world)))
    (loop for p in (all-peeps world)
       do (setf (todo p) (routine p))))
  world)

;; Don't worry about the details of how to `tick!` peeps or places yet.

;;   Ok, here's where it gets a bit darker. Although we _did_
;; foreshadow this in the definition of `peep`. And also in the title
;; of the accompanying blog post.

;; A plague is another living thing.
;; It has
;;  - a host (a peep that it's infecting)
;;  - a signature (a token representing its lineage and strain)
;;  - health (how well it's doing inside its host)
;;  - virulence (how likely it is to spread to another host)
;;  - efficiency (how efficient they are at feeding)
;;  - reproduce (a function that returns a new instance to push into a new host)
;;  - and a strategy (a function, possibly closed, that takes
;;    itself and its host peep and mutates)

;; Plagues do not collect points; they score differently.

(defclass plague ()
  ((host :initarg :host :initform nil :accessor host)
   (signature :initarg :host :initform "SIG" :accessor signature)
   (health :initarg :health :initform 10 :accessor health)
   (virulence :initarg :virulence :initform 10 :accessor virulence)
   (efficiency :initarg :efficiency :initform 0.2 :accessor efficiency)
   (reproduce
    :initarg :reproduce
    :initform
    #'plague
    :reader reproduce)
   (strategy
    :initarg :strategy
    :initform
    (lambda (plague peep)
      (feed! plague peep 30))
    :reader strategy)))

(defun plague ()
  (make-instance 'plague))

;; Plagues can `feed!` on peeps or plagues. To feed means to
;; take away some of the targets' health and add some to your own.

(defmethod feed! ((self plague) (peep peep) (amount integer))
  (decf (health peep) amount)
  (incf (health self) (* (efficiency self) amount)))

(defmethod feed! ((self plague) (plague plague) (amount integer))
  (decf (health plague) amount)
  (incf (health self) (* (efficiency self) amount)))

;; Plagues can also `infect!` peeps by `reproduce`ing into them.

(defmethod infect! ((self plague) (peep peep))
  (unless (infected-by? self peep)
    (let ((child (funcall (reproduce self))))
      (setf (host child) peep)
      (push child (plagues peep)))))

(defmethod infected-by? ((self plague) (peep peep))
  (member (signature self) (mapcar #'signature (plagues peep))
	  :test #'string=))

;;  `tick!`ing a plague causes it to weaken and also carry out its strategy.
;; This models the background effect of the immune system of its host.

(defmethod tick! ((plague plague))
  (decf (health plague) 1)
  (funcall (strategy plague) plague (host plague))
  plague)

;;  `tick!`ing a peep means moving them to their next place, and also
;; `tick!`ing any plagues they may have contracted. Also, peeps are
;; resilient; they heal a small amount each time they tick (to a
;; maximum of 100).
;;  If a peep dies, they no longer move. And their plagues probably
;; won't do well. Peeps like to go places. They score points for each
;; place they go to.

(defun dead? (thing) (>= 0 (health thing)))

(defmethod tick! ((peep peep))
  (unless (dead? peep)
    (let ((location (pop (todo peep))))
      (incf (points peep))
      (setf (occupants location) (remove peep (occupants location)))
      (push peep (occupants (or (first (todo peep)) (first (routine peep)))))
      (setf (health peep) (min 100 (+ 5 (health peep))))
      (mapc #'tick! (plagues peep))
      (unless (empty? (todo peep))
	peep))))

;; `tick!`ing a place causes it to score for each `peep` present. And it causes
;; any `plague`s on present `peep`s to try to `infect!` other nearby peeps.
;; Places also lose points for each dead peep they contain.

(defmethod tick! ((place place))
  (incf (points place) (length (occupants place)))
  (loop for peep in (all-peeps place)
     if (dead? peep)
     do (decf (points place) 2)
     else do (loop for plague in (plagues peep)
		do (loop for victim in (remove peep (all-peeps place))
		      if (>= (virulence plague) (random 100))
		      do (infect! plague victim))))
  place)

;;  So, now we've got the basic framework of the game in place. There are three
;; players in this game: places, peeps and plagues.
;;   A plague player automatically loses if they are completely cured, and
;; automatically wins if they manage to kill everyone. That's fairly simple.
;;   A place player wins if they manage to cure the plague. They automatically
;; lose if all the peeps die. Also, fairly simple.
;;   A peep player is trying to survive. If they manage to make it some numer
;; of turns before dying, then we have to score the game instead of declaring
;; an outright winner regardless of game state.

;;   A peep player's score is the total number of points plus remaining health
;; on all of their peeps, minus the number of active plagues on said peeps.
;;   A plague player's score is the total number of health of their plagues,
;; with a multiplier equal to the number of places fully infected by
;; their plague.
;;   A place player's score is the total number of points in their places.

(defun score (world)
  (list :peep (let ((score 0))
		(loop for p in (all-peeps world)
		   unless (dead? p)
		     do (incf score (+ (health p) (points p)))
		   do (decf score (length (plagues p))))
		score)
	:place (let ((score 0))
		 (loop for p in world
		    do (incf score (points p)))
		 score)
	:plague (let ((score 0))
		  (loop for victim in (all-peeps world)
		     do (loop for p in (plaguesvictim)
			   do (incf score (max 0 (health p)))))
		  (loop for target in world
		     if (every
			 (lambda (victim)
			   (not (empty? (plagues victim))))
			 (all-peeps target))
		     do (setf score (* 2  score)))
		  score)))

;;   I think that's all I've got for now. This is definitely an idea I want
;; to run with. At the moment, it's just a tiny, in-repl proof-of-concept,
;; and not particularly fun, but I'm going to try developing it further with an
;; eye towards turning it into an actual web game playable from this site.

;; As always, I'll let you know how it goes.

(defun pick (lst)
  (nth (random (length lst)) lst))

(defun empty? (lst)
  (null lst))

New projects:

• anypool — General-purpose pooling library — BSD 2-Clause
• avl-tree — An implementation of the AVL tree data structure. — MIT
• cl-aubio — Aubio bindings for Common Lisp — GPLv3
• cl-interval — Intervals, interval trees — NewBSD, LLGPL
• cl-liballegro — Allegro 5 game programming library bindings for Common Lisp — Allegro 5 - http://alleg.sourceforge.net/license.html
• cl-mime-from-string — A one function library to return a mime-type based on the file extension found at the end of a string. ie abc.txt -> text/plain. The common types implemented are from https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types — MIT
• cl-telegram-bot — Telegram Bot API, based on sovietspaceship's work but mostly rewritten. — MIT
• dns-client — A client for the DNS protocol. — zlib
• feeder — RSS, Atom and general feed parsing and generating — zlib
• perceptual-hashes — Perceptual hash algorithms for images — 2-clause BSD
• portable-condition-system — A portable condition system for Common Lisp — CC0
• ten — Template System for Common Lisp — MIT
• trivial-custom-debugger — Allows arbitrary functions to become the standard Lisp debugger — MIT
• trivial-with-current-source-form — Helps macro writers produce better errors for macro users — GPLv3
• vom-json — A json-formatted logger for vom — MIT
• vp-trees — Perceptual hash algorithms for images — 2-clause BSD

Updated projects: 3b-bmfont, 3bgl-shader, 3bmd, 3bz, a-cl-logger, alexandria, april, async-process, bdef, bp, ccldoc, chunga, cl+ssl, cl-ana, cl-capstone, cl-cffi-gtk, cl-collider, cl-containers, cl-environments, cl-gamepad, cl-gserver, cl-inotify, cl-markless, cl-pack, cl-patterns, cl-python, cl-rdkafka, cl-shlex, cl-sparql, cl-str, cl-tui, cl-utils, cl-webkit, clinenoise, clip, closer-mop, concrete-syntax-tree, croatoan, cserial-port, dartscltools, defenum, deploy, dexador, diff-match-patch, dissect, djula, doubly-linked-list, easy-routes, eclector, escalator, fast-generic-functions, fast-io, flexi-streams, flexichain, float-features, fset, fucc, functional-trees, fxml, gendl, graph, gtirb, hu.dwim.computed-class, hu.dwim.def, hu.dwim.perec, hu.dwim.presentation, hu.dwim.quasi-quote, hu.dwim.walker, hu.dwim.web-server, hunchentoot-multi-acceptor, ironclad, keystone, lispqr, literate-lisp, maiden, maxpc, mcclim, mmap, modularize, mutility, nodgui, numcl, numpy-file-format, origin, osicat, overlord, parachute, patchwork, petalisp, petri, phoe-toolbox, plump, policy-cond, polisher, postmodern, pzmq, qtools, quilc, qvm, roan, rpcq, s-graphviz, s-http-client, s-http-server, s-sysdeps, s-utils, sanity-clause, scalpl, sealable-metaobjects, sel, select-file, serapeum, sketch, skippy-renderer, snappy, softdrink, spinneret, staple, stumpwm, sucle, swank-client, swank-crew, tooter, trace-db, trivial-features, trivial-file-size, vgplot, woo.

Removed projects: cl-password-store, fomus, rfc3339-timestamp, rpc4cl.

All the removed projects are removed because they no longer build. For the first two (cl-password-store and fomus), I was unable to get a response from the authors. The other two (rfc3339-timestamp, rpc4cl) the author was responsive, but has abandoned the projects.

To get this update, use (ql:update-dist "quicklisp"). Enjoy!

A number of people support Quicklisp with a monthly contribution through PayPal. I recently set up a Quicklisp Patreon page as an alternative - if you are interested in supporting Quicklisp, feel free to check it out.

As any Common Lisp coder knows, a REPL is an incredibly useful tool. It can be used not just for development, but for running all sorts of tasks. Personally, I don't bother making my Lisp tools into executable scripts and just run them directly from SLIME. As such, any operation that requires leaving the REPL is quite inconvenient. For me, one such operation was viewing image files, for example in conjunction with my match-client:match tool. So lately I've been researching various methods to incorporate this functionality into the normal REPL workflow. Below, I present 3 methods that can be used to achieve this.

Open in external program

This one's easy. When you want to view a file, launch an external process with your favorite image viewer. On Windows a shell command consisting of the image filename would launch the associated application, on Linux it's necessary to provide the name of the image viewer.

(defvar *image-app* nil) ;; set it to '("eog") or something

(defun view-file-native (file)
  (let ((ns (uiop:native-namestring file)))
    (uiop:launch-program (if *image-app*
                             (append *image-app* (list ns))
                             (uiop:escape-shell-token ns)))))

Note that uiop:launch-program is used instead of uiop:run-program. The difference is that launch- is non-blocking - you can continue to work in your REPL while the image is displayed, whereas run- will not return until you close the image viewer.

Also note that when the first argument to run/launch-program is a string, it is not escaped, so I have to do it manually. And if the first argument is a list, it must be a program and a list of its arguments, so merely using (list ns) wouldn’t work on Windows.

Inline image in REPL

The disadvantage of the previous method is that the external program might steal focus, appear on top of your REPL and disrupt your workflow. And it's well known that Emacs can do everything, including viewing images, so why not use that?

In fact, SLIME has a plugin specifically for displaying images in REPL, slime-media. However it’s difficult to find any information on how to use it. Eventually I figured out that SWANK (SLIME’s CL backend) needs to send an event :write-image with appropriate arguments and slime-media's handler will display it right in the REPL. The easiest way is to just send the file path. The second argument is the resulting image's string value. If you copy-paste (sorry, "kill-yank") it in the repl, it would act just like if you typed this string.

(swank::send-to-emacs '(:write-image "/path/to/test.png" "test"))

You can even send raw image data using this method. I don't have anything on hand to generate raw image data so here's some code that reads from a file, converts it to a base64 string and sends it over SWANK.

(with-open-file (in "/path/to/test.png" :direction :input  :element-type '(unsigned-byte 8))
                (let* ((arr (make-array (file-length in) :element-type '(unsigned-byte 8)))
                       (b64 (progn (read-sequence arr in) (cl-base64:usb8-array-to-base64-string arr))))
                  (swank::send-to-emacs `(:write-image ((:data ,b64 :type swank-io-package::png)) "12345"))))

Note that the first argument to :write-image must be a list with a single element, which is itself a plist containing :data and :type keys. :data must be a base64-encoded raw image data. :type must be a symbol in swank-io-package. It’s not exactly convenient, so if you’re going to use this functionality a helper function/macro might be necessary.

Image in a SLIME popup buffer

Inline images are not always convenient. They can’t be resized, and will take up as much space as is necessary to display them. Meanwhile EMACS itself has a built-in image viewer (image-mode) which can fit images to width or height of a buffer. And SLIME has a concept of a “popup buffer” which is for example used by macroexpander (C-c C-m) to display the result of a macro expansion in a separate window.

Interestingly, slime-media.el defines an event :popup-buffer but it seems impossible to trigger it from SWANK. It is however a useful code reference for how to create the popup buffer in ELisp. This time we won’t bother with “events” and just straight up execute some ELisp code using swank::eval-in-emacs. However by default, this feature is disabled on Emacs-side, so you’ll have to set Emacs variable slime-enable-evaluate-in-emacs to t in order for this method to work.

Also Emacs must be compiled with ImageMagick for the resizing functionality to work.

Anyway, the code to view file in the popup buffer looks like this:

(defun view-file-slime (file &key (bufname "*image-viewer*"))
  (let ((ns (namestring file)))
    (swank::eval-in-emacs
     `(progn
        (slime-with-popup-buffer (,bufname :connection t :package t)
          (insert-image (create-image ,ns))
          (image-mode)
          (setf buffer-file-name ,ns)
          (not-modified)
          (image-toggle-display-image))
        ;; try to resize the image after the buffer is displayed
        (with-current-buffer ,bufname (image-toggle-display-image))))))
    ))

Arriving to this solution has required reading image-mode’s source code to understand what exactly makes image-mode behave just like if the image file was opened in Emacs via C-x C-f. First off, image-mode can be a major and a minor mode - and the minor mode is not nearly as useful. slime-with-popup-buffer has a :mode keyword argument but it would cause image-mode to be set before the image is inserted, and it will be a minor mode in this case! Therefore (image-mode) must be called after insert-image.

Next, the buffer must satisfy several conditions in order to get image data from the filename and not from the buffer itself. Technically it shouldn’t be necessary, but I couldn’t get auto resizing to work when data-p is true. So I set buffer-file-name to image’s filename and set not-modified flag on.

Next, image-toggle-display-image is called to possibly resize the image according to image-mode settings. It's called outside of slime-with-popup-buffer for the following reason: the buffer might not yet be visible and have any specific dimensions assigned to it, and therefore resizing will do nothing.

Here’s an example of how calling this function looks in Emacs.

The position of the popup buffer depends on whether the original Emacs window is wide enough or not. I think it looks better when it’s divided vertically. Use M-x image-transform-fit-to-height or M-x image-transform-fit-to-width to set up the auto-resizing method (it gets remembered for future images). Unfortunately there’s no way to fit both height and width, at least with vanilla Emacs. I prefer fit-to-width because in case the image is too tall, it is possible to scroll the image vertically with M-PgDn and M-PgUp from the other buffer. Unlike other image-mode buffers, this buffer supports a shortcut q to close itself, as well as various SLIME shortcuts, for example C-c C-z to return to the REPL.

That's it for now, hope you enjoyed this overview and if you happen to know a better way to display images in Emacs, I would be interested to hear about it.

It's a new month, and that usually means I'm supposed to write a monthly update on the progress with Kandria. Thinking about that though made me feel very depressed because I realised that I hadn't really done anything at all for the game, all of April.

I can blame however much I want of that on the quarantine and university stress, or whatever else, but it won't change the fact that there has not been much progress on any front. While I have been slacking a lot, it's not like I haven't been working at all - plenty of time has gone into Courier, after all.

When I had this realisation yesterday, I tried my best to push myself to work on the game any way I could, but I failed to find anything that I could actually convince myself to do. That isn't to say that there aren't things to do; god forbid there's a tonne of things! Tuning combat, drawing animations, writing the UI, fixing dialogue, starting on enemy AI, optimising performance - just to name a few. And yet, despite the breadth and depth of things to do, there was absolutely nothing that looked appealing to me.

This kind of feeling is nothing new to me. It's a creative block, and happens more often that I'd like to admit. It's also why I often don't like to start long running projects, because I'm afraid of a creative block that would ruin it. The worst part about the creative block is that there's no remedy for it. You just get stuck in a rut, and it sucks a whole lot for a completely unpredictable amount of time. Often what I end up doing, whether consciously so or not, is switching to another project and just working on that.

So far that project has been Courier, but that's at its end and I'm also starting to feel burnt out on it, too. I don't have any other projects queued up that I'd like to tackle, or new ideas on what to do at the moment, so I'm just... stuck.

I suppose the right thing to do in this situation is to take it easy and not fret too much over it, since that's often one of the many factors causing the block. I've never been good at actually doing that, though. Maybe I should try to take a break from programming in general? I don't know.

You may be wondering why I'm writing this all to begin with. Well, partly I feel like I promised to do monthly and weekly updates, and I really hate to break that promise without notice. Another part is that I just feel like I owe you the discretion to tell you what's going on with me. I'm very thankful for the email replies and general responses I've gotten for Kandria so far, I really am! Because of that genuine interest, I feel all the more pressured not to disappoint. Since I have nothing to show though, I thought the only proper course of action is to just be open and direct about it. So I'll just say it again: aside from updating the public demo, no progress has been made at all.

Maybe it would help me to have a more open discussion about this topic in general, instead of just it being me telling you that I'm in a bad place. So please, let me know: have you been in similar situations before? What helped you deal with them? Is there something in Kandria I could try to focus on that you, personally, would like to see?

You can reach me at shinmera@tymoon.eu.

I have finally obtained the first batch of the printed "Programming Algorithms" books and will shortly be sending them to the 13 people who asked for a hardcopy.

Here is a short video showing the book "in action":

If you also want to get a copy, here's how you do it:

1. Send the money to my PayPal account: $30 if you want normal shipping or $35 if you want a tracking number. (The details on shipping are below).
2. Shoot me an email to vseloved@gmail.com with your postal address.
3. Once I see the donation, I'll go to the post office and send you the book.
4. Optionaly step: if you want it to be signed, please, indicate it in your letter.

Shipping details: As I said originally, the price of the dead-tree version will be $20+shipping. I'll ship via the Ukrainian national post. You can do the fee calculation online here (book weight is 0.58 kg, size is 23 x 17 x 2 cm): https://calc.ukrposhta.ua/international-calculator. Alas, the interface is only in Ukrainian. According to the examples I've tried, the cost will be approximately $10-15. To make it easier, I've just settled on $10 shipping without a tracking number of $15 if you want a tracking number. Regardless of your country. I don't know how long it will take - probably depends on the location (I'll try to inquire when sending).

The book was already downloaded more than 1170 times (I'm not putting the exact number here as it's constantly growing little by little). I wish I knew how many people have, actually, read it in full or in part. I've also received some error corrections (special thanks goes to Serge Kruk), several small reviews and letters of encouragement. Those were very valuable and I hope to see more :)

Greetings from the far away city of Lima, Peru!
I loved this part: "Only losers don't comment their code, and comments will be used extensively"
Thank you so much for putting this comprehensive collection of highly important data structures, i'm already recommending this to two of my developers, which I hope i'll induce into my Lisp addiction.
--Flavio Egoavil

And here's another one:

Massively impressive book you've written! I've been a Lisp programmer for a long time and truly appreciate the work put in here. Making Lisp accessible for more people in relation to practical algorithms is very hard to do. But you truly made it. You'll definitely end up in the gallery of great and modern Lisp contributions like "Land of Lisp" and "Let Over Lambda". Totally agree with your path to focus on practical algorithmic thinking with Lisp and not messing it up with macros, oop and other advanced concepts.
--Lars Hård

Thanks guys, it's really appreciated!

If you feel the same or you've liked the book in some respect and have found it useful, please, continue to share news about it: that definitely helps attract more readers. And my main goal is to make it as widely read as possible...

So recently, I had to use zippers at work. Specifically, the Clojure implementation. There were some close-to-arbitrary transformations I needed to do with some close-to-arbitrary trees and it turned out that zippers were more efficient than the alternatives¹.

Using them this way, combined with the general state of the world and my free time, finally tipped me into doing some more Common Lisp development. Before, I go any further, let me be clear about something.

I Like Clojure

Seriously.

Its logo is up top in the language bar, I was one of the inaugural members of the Toronto Clojure User Group, I recommend it as a first lisp you should learn, and have for about six years now. I'm also painfully aware of the shortcomings of Common Lisp, and make no excuses for them.

However.

• I don't like the JVM. It's slow as balls, its' deployment options are less than ideal for my purposes, its' error system is at best useless, and Clojure without it is unlikely.
• Clojurescript build incompatiblities are, if anything, worse².
• I don't like the underlying licensing decisions.

These are deep reasons to stay away. They're not the sort of thing I can paper over with a library or two. Fixing them would mean a superhuman amount of work poured into the underlying technical and social infrastructure, and I'm not into it. I wouldn't be into it even if the community was interested in heading that way, and near as I can tell, they're not particularly.

Whether or not I think you should learn Clojure as your first³ lisp, it definitely wasn't my first lisp. The more uniform, mostly-better-thought-out interface, lack of historical baggage and functional data structures are not enough to pull me all the way over.

It is enough for me to start plotting a smash-and-grab of as much of the stuff I like as I can carry. Which is exactly what clj represents. As of this writing, it defines and exports exactly four symbols: if-let, when-let, -> and ->>. This is a tiny beginning of the list, and I fully plan to put something more substantial together using cl-hamt, named-readtables, test-utils and possibly optima. Stay tuned to that repo if you're interested, but it's not the focus today.

cl-zipper

The thing that percipitated this thought was having used the Clojure Zipper implementation. So, obviously, this is something I want next time I need to manipulate trees in Common Lisp. The paper is here, and unless you have a terminal phobia of datastructures⁴, you should go read it. It's six pages, they're light, and one of them taken up by the intro and references.

The operations defined in the paper are left, right, up, down, insert_right, insert_left, insert_down and delete. There's a few conveniences defined for the Clojure version, and I've implemented some of my own stuff too. Lets go through the main file in almost-literate style.

First up, we have constructors.

(defstruct path
  (left) (path) (right))

(defstruct loc
  (node)
  (path)

  (fn-branch?)
  (fn-children)
  (fn-make-node))

;;;;;;;;;; Constructors
(defun zipper (branch? children make-node root)
  (make-loc
   :node root
   :fn-branch? branch? :fn-children children :fn-make-node make-node))

(defmethod make-zipper ((thing list))
  (zipper #'listp #'identity (lambda (node children) (declare (ignore node)) children) thing))

(defun make-node (zipper children)
  (funcall (loc-fn-make-node zipper) zipper children))

You can see influence from both clojure.zip and the paper here. I'm taking the lead from the paper by explicitly separating the path triple our from the loc definition. However, I'm not explicitly defining my own type tree the way that Huet does. Instead, I'm going to be dealing with assorted lisp trees. These could be implemented as lists, vectors, hashes, or any number of other formats. I'm going to implement a few type-distpatching built-ins, including the make-zipper list method above, but the basic zipper function just needs to take an interface as input in the form of branch?, children and make-node arguments. This is the same solution that the Clojure implementation went with, and I see no reason to go a different way. The only material difference is that theirs uses the Clojure metadata system, while I explicitly define slots in the loc structure.

Now that we can construct, we need to be able to select.

;;;;;;;;;; Selectors
(defun branch? (zipper) (funcall (loc-fn-branch? zipper) (loc-node zipper)))
(defun children (zipper)
  (funcall
   (loc-fn-children zipper)
   (loc-node zipper)))
(defun node (zipper) (loc-node zipper))
(defun path (zipper) (loc-path zipper))

(defun lefts (zipper)
  (when (loc-path zipper)
    (reverse (path-left (loc-path zipper)))))

(defun rights (zipper)
  (when (loc-path zipper)
    (path-right (loc-path zipper))))

The basic navigation is four functions; down, up, left and right

;;;;;;;;;; Navigation
;;;;;;;;;;;;;;; Basic navigation
(defun down (zipper)
  (when (children zipper)
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh) (first (children zipper))
	    (loc-path fresh)
	    (make-path
	     :left nil
	     :path (loc-path zipper)
	     :right (rest (children zipper))))
      fresh)))

(defun up (zipper)
  (when (path zipper)
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh)
	    (make-node
	     zipper (append
		     (reverse (path-left (path zipper)))
		     (cons (loc-node zipper)
			   (path-right (path zipper)))))
	    (loc-path fresh) (path-path (path zipper)))
      fresh)))

(defun left (zipper)
  (when (and (path zipper) (path-left (path zipper)))
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh) (first (path-left (path zipper)))
	    (loc-path fresh)
	    (make-path
	     :left (rest (path-left (path zipper)))
	     :path (path-path (path zipper))
	     :right (cons (loc-node zipper) (path-right (path zipper)))))
      fresh)))

(defun right (zipper)
  (when (and (path zipper) (path-right (path zipper)))
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh) (first (path-right (path zipper)))
	    (loc-path fresh)
	    (make-path
	     :left (cons (loc-node zipper) (path-left (path zipper)))
	     :path (path-path (path zipper))
	     :right (rest (path-right (path zipper)))))
      fresh)))

The main difference between this and the paper is that I've chosen nil as my Top representation, which lets me pull the trick of using when to check for the presence of a path, and its' non-Top-ness at the same time.

The bad news is that since Common Lisp doesn't have pervasive functional data structures, I have to explicitly copy locs while moving through a tree. The good news is that the copy is fairly light weight. Effectively, I'm copying out a set of 5 pointers, and could get that down to 3 by defining an intermediate struct.

Hm.

Which I probably should do. Note to self.

Out of those, we get three compound navigation functions. With more probably coming soon. Specifically, I found find useful for the work I did. It's easily externally definable, but would be even easier to bundle along. The ones I've already implemented are root, leftmost and rightmost.

;;;;;;;;;;;;;;; Compound navigation
(defun root (zipper)
  (if-let (z (while zipper #'up))
    (node z)))

(defun leftmost (zipper) (while zipper #'left))

(defun rightmost (zipper) (while zipper #'right))

Each of these involve an intermediate call to while. Which isn't a generic macro; it's a function defined in util.lisp

...
(defun until (zipper f)
  (let ((z zipper))
    (loop for next = (funcall f z) while next
       when next do (setf z next))
    z))
...

As you can see, all it does is repeatedly call a given function on a zipper and return the last non-nil loc result. That's loc, not node, so this doesn't run into the usual Common Lisp conflict of "Did you fail to find a thing, or find the element nil?".

That's the traversals done. Next up, we've got modification, without which this library is fairly useless. The basics are replace, delete and the insert/child twins.

;;;;;;;;;; Modification
(defun replace (zipper node)
  (let ((fresh (copy-loc zipper)))
    (setf (loc-node fresh) node)
    fresh))

(defun delete (zipper)
  (when (path zipper)
    (let ((fresh (copy-loc zipper))
	  (fresh-path (copy-path (loc-path zipper))))
      (cond ((rights zipper)
	     (setf (loc-node fresh) (pop (path-right fresh-path))
		   (loc-path fresh) fresh-path))
	    ((lefts zipper)
	     (setf (loc-node fresh) (pop (path-left fresh-path))
		   (loc-path fresh) fresh-path))
	    (t (setf (loc-path fresh) (path-path fresh-path))))
      fresh)))

(defun insert-child (zipper node)
  (replace
   zipper
   (make-node
    zipper
    (cond ((not (branch? zipper))
	   (list node (node zipper)))
	  ((children zipper)
	   (cons node (children zipper)))
	  (t (list node))))))

(defun append-child (zipper node)
  (replace
   zipper
   (make-node
    zipper
    (cond ((not (branch? zipper))
	   (list (node zipper) node))
	  ((children zipper)
	   (append (children zipper) (list node)))
	  (t (list node))))))

(defun insert-left (zipper node)
  (let ((fresh (copy-loc zipper))
	(fresh-path (copy-path (loc-path zipper))))
    (push node (path-left fresh-path))
    (setf (loc-path fresh) fresh-path)
    fresh))

(defun insert-right (zipper node)
  (let ((fresh (copy-loc zipper))
	(fresh-path (copy-path (loc-path zipper))))
    (push node (path-right fresh-path))
    (setf (loc-path fresh) fresh-path)
    fresh))

The paper defines an insert_down function. It fails on a Leaf node, and otherwise inserts a singleton branch at the given location. The insert/append child functions above also insert nodes at a lower level at the current loc. They give you a choice about whether to insert the new node as the leftmost or rightmost child, and additionally succeed on Leaf nodes by including the leaf value as a child of the new branch.

There are, thus far, three compound modification functions; edit, splice-left and splice-right.

(defun edit (zipper f &rest args)
  (replace zipper (apply f (node zipper) args)))

(defun splice-left (zipper node-list)
  (reduce #'insert-left node-list :initial-value zipper))

(defun splice-right (zipper node-list)
  (reduce #'insert-right (reverse node-list) :initial-value zipper))

edit takes a function instead of a new node, and replaces the node at loc with the result of running that function on the existing node. The splice-* twins are fairly self-explanatory; they're like insert-left/insert-right, but work on multiple nodes rather than single ones.

I haven't yet implemented next, prev and remove because these might relate to the different representation of the traversal end? state. The reason for this seems to be that next/prev/remove assume a depth-first traversal. The reason I'm being weasely here is that I haven't thought about it hard enough to be sure that the end? marker is really necessary. It also seems odd to privilege depth-first over breadth-first traversals; ideally, I think you'd want to be able to support either. Possibly interchangeably.

Minor Housekeeping

That wraps it up for this edition. My immediate intention is to do more work on the cl-zipper and clj libraries, as well as that game I mentioned last time. Ideally, I'd like to up my blogging output too. Probably not to the same volume as I had at my peak, but it was definitely helpful to keep some sort of written journal around for a while. The current state of the world is, hopefully, going to make it easy for me to get more programming time in. All things considered, I'd count that as a win.

1. Although admittedly, it does require me to explain the concept of zippers to a few other people for maintenance purposes. So ironically, this adds complexity despite being much more technically elegant than other options.↩
2. There's a reason that langnostic.js is a raw JS file, rather than compiled from clojurescript source, and that reason is like 90% that the compilation process is nontrivial to set up.↩
3. "First", not "only". You can probably make educated guesses about which other ones I think you should learn.↩
4. In which case, why are you here? This blog could kill you accidentally with an errant click or two. You should probably just go do something else.↩

So, I ordered a bunch of native plants on Etsy, and they were WAY cheaper than they are in stores around here. They came as chunks of root, essentially. It only occurred to me after I ordered to worry about why they were so cheap — is it possible they’re being illegally harvested from woodlands? … Continue reading "Native Plants From Etsy"

It was all I could do, when I was reading the Futel Party Line zine, to not just call up their operator and say “I want a free pay phone. In Randolph.” Because, hey, that would be cool. But realistically, someone would have to manage that project. And, if I am being honest, I am […]

So hey I think I managed to break a leisure record this Virgo Month of Leisure! The bad news is that’s because I’ve been feeling borderline punk for a few months now. I always thought of myself as someone in pretty good shape, but every so often I just come down with… sinus nonsense, or […]

So Martin Scorsese said that the Marvel movies are “not cinema” and the internet kind of blew up because it is inherently polarizing, and the possibility that Scorsese is both one of our most talented living directors and also wrong about this particular subject is not particularly fun discourse for a lot of people on […]

This is the Call for Votes for the 2019 RSPW (Theszie) Awards. You can vote here. The Theszies are the oldest fan awards in pro wrestling history, going back to 1990 (when Mr. Perfect quite appropriately won Best Wrestler and Junkyard Dog v. Ric Flair at Clash of the Champions XI won Worst Match). They […]

A convocation of the Lover Triad of United States Grand Lodge will be held in Cleveland, Ohio, August 14-16 2020. Registration for the convocation is now open. See this site for more information.

To all local bodies within U.S. Grand Lodge: For all official gatherings, please observe all guidance issued by the CDC, and by state or local health authorities, pertaining to sanitation, hygiene, and event attendance related to the new Coronavirus.

Event cancellations at local bodies due to COVID-19 will reduce revenue, but not rent and other fixed expenses. Many local bodies already operate on extremely tight margins and struggle to pay their bills even during normal times. All members are encouraged to continue to financially support their local bodies, even if there are no events …

Continue reading

The in-person annual U.S. Grand Lodge Joint Meeting scheduled for July 2020 in Oakland CA has been canceled. Individual governing bodies will meet online; members of those bodies will receive further information. A decision on whether the Convocation of Lovers scheduled for August 2020 in Cleveland OH will be canceled will be announced by April …

Continue reading

The Convocation of Lovers scheduled for August 2020 in Cleveland has been indefinitely postponed due to the ongoing COVID-19 pandemic. Those with hotel reservations for this event should cancel them. There should be no cancellation fee charged if you made a reservation at the Courtyard Cleveland Westlake using the conference reservation link.

The Worst Things For Sale is Drew's blog. It updates every day. Subscribe to the Worst Things For Sale RSS!