Last weekend I had a lively discussion with a friend about Pagans she has met who don’t condone or accept the LGBT community, especially as it is intermingled with Paganism.  She has met some of this ilk (I have not) and described how they do not condone non-straight sexuality when it is expressed in Paganism, and how this type also has a limited view of what should be expressed as Paganism, and other expressions are wrong.

I gave her the impression I was surprised to hear this, but it was not surprise, but shock.  I knew intellectually that this type exists (since all types of everything exist,) but this was the first I had heard of actual encounters with such thinking.

We followers of Earth-based spirituality are persecuted and ridiculed enough with us doing it to ourselves.  Think of how Christine O’Donnell (who has no business holding public office, but that is another story) was openly ridiculed when an old clip of her surfaced where she stated she dabbled in witchcraft.  It tanked whatever chances she had in her Senatorial race, and was it because she was the wrong picture to put on the pagan community?  No, it was because any inference that one is a practicing pagan is social suicide in most parts of the United States.

We pagans need to be accepting of each other, and open to the great cosmos that is all of us.  There is no “right” or “wrong” way to be a pagan.

Those who think otherwise are suffering from cognitive dissonance.

I really love the card game Lost Cities, designed by Reiner Knizia. When my husband Christopher and I were first getting to know each other, we used to meet up at Starbucks sometimes and play games. Lost Cities was one of our frequent picks. It’s a head to head, two player game in which both players are trying to outscore each other by laying down ascending runs of card suits on a small board between the two of them. There’s a theme laid over the mechanism (completing expeditions in the lost world) but it’s basically pasted on and so that is the last we will speak of it. So there we were, newly in love, eyeing each other across the table, smiling and flirting, and doing our best to beat one another at Lost Cities. It was awesome. And now, with the roll & write genre having made an impressive rebound a few years ago (let’s not forget the mechanism has actually been around since the 50s with Yatzee), Knizia has ported his award winning game Lost Cities  into this format, releasing Lost Cities Roll & Write  in 2021. 

You can play the new Lost Cities  with up to 5 players, but in an ode to our romantic beginnings, Christopher and I played it exclusively with one another in successive matches.  The components are compact, lacking the pretty illustrations of the original game, and few in number – the rule book, a scorepad, three pentagonal trapezohedron dice (that’s 10 sided dice for the uninitiated), and three 6 sided custom dice with color suit symbols. Oh, and some pencils. That’s it. We could have played on an even smaller Starbucks table if we had this back in our dating days.

The cards from the original game (wager cards and numbered cards 2 to 10, in five different suits) have been translated into dice roll results. On each turn, one player rolls all the dice and chooses one of the six sided dice to represent the suit and one of the ten sided dice to represent the number. A zero on the number die can represent either zero (mimicking the wager card from the original game which serves as a multiplier for the total score in the selected suit) or ten (mimicking the highest card in each suit).

In place of the tableau built up on a central board, each player tracks the progress of wager and number cards they’ve collected for each suit in color coded columns on their individual score sheet. Wager cards have been transformed into little circular boxes to be marked off from a suit column when rolled, while the numbered cards from the original game have expanded to include the number 1 and are recorded as numbers written manually in the square boxes running up each column. Whereas in the original game, only cards higher than the last card played in a suit were permitted to be played on subsequent turns by the same player, in Lost Cities Roll & Write, numbers that are higher than or equal to the last number recorded for a suit may be written into the column after future dice rolls. Expanding beyond the concepts from the original game, Knizia has included artifact icons on select spaces in each column and when those spaces are filled by a player, they may fill in one of the jars in the artifact column. Likewise, he’s included arrow icons on select spaces and when those spaces are filled by a player, they may fill in the next box in one of their suit columns with the number from the previous box in the column – note that it does not have to be the same column in which the arrow was filled.  There’s also a column for filling in dice shapes to represent rolls where a player could not or did not want to use any of the dice results. The latter column is particularly tricky to manage effectively, as it provides a similar point progression as the rest of the columns (negative scores for the first 3 boxes filled and then positive score for the rest) up until the last box in the column. If you color in that box, your score for the dice shapes column drops from 70 to 0. The bonus points awarded in the original game (20 points for laying down at least 8 cards in a suit) have been implemented in Lost Cities Roll & Write  for each column (including the artifact and dice shape columns) as a 20 point bonus to the player who is the first to fill in 7 boxes in the column on the scorepad. The roll & write game ends when either both players have filled in the dice shapes column completely or all eight columns have passed the bonus point marker. In our experience, the completed dice shapes column is a much more common trigger.

I’ve played a ton of roll & write games over the past few years. Some are instant objects of adoration, while others are infuriating piles of poo (I’m looking at you Imperial Settlers R&W). Lost Cities Roll & Write is fantastic; a great addition to the genre. Knizia did an excellent job of translating the feel of the original game into the new mechanism. The iconography is clean and easy to read and the game can be taught and played in less than a half hour. And of course, it takes up very little table real estate, making it perfect for travel or tight spaces (when traveling as a passenger, simply roll the dice into the box cover). If you twisted my arm and forced me to choose between Lost Cities or Lost Cities Roll & Write, I’d be forced to pick the original, but only because of the lovely artwork on the cards and the sentimental value I have attached to the game after my love and I played it in our early days. But who would go around doing such arm twisting? Nobody. Therefore, with a retail price point under $15 for each of these, unless you’re down to your last $15, I recommend you pick up both. Play the card game with someone you love when you have a little more table space. Play the roll & write anywhere, with up to four additional friends. 

-------------------------------------------------

Publisher: Kosmos
Players: 2-5 (We played with 2)
Actual Playing Time (vs the guideline on the box): about 20 minutes per game
Game type: roll & write, dice rolling

Rating:

Rating scale:
OUI: I would play this game again; this game is ok. I probably would not buy this game myself but I would play it with those who own it and if someone gave it to me I would keep it.
OUI OUI: I would play this game again; this game is good. I would buy this game.
OUI OUI OUI: I LOVE THIS GAME. I MUST HAVE THIS GAME.
NON: I would not play this game again. I would return this game or give it away if it was given to me.

Shiva Baby [US, Emma Seligman, 4] The ambient social pressures of a post-funeral gathering skyrocket for a directionless college student (Rachel Sennott) when attendees include not only the expected ex-girlfriend (Molly Gordon) but also the sex work client she’s caught feelings for. Knife-edge comedy of emotional suffocation uses a plucky suspense score for that extra frisson of social anxiety.

If you've been missing family events during the pandemic, this film is the cure for that. Polly Draper and Fred Melamed appear as the loving but insufferably intrusive parents.

Night of the Kings [Côte d'Ivoire/France , Philippe Lacôte, 4] When the red moon rises over MACA, the Ivory Coast’s toughest prison, its inmate boss appoints the new arrival as storyteller—a post that results in death if the tale ends before sundown. Prison drama with compelling narrative hook widens out to encompass ancient warfare, contemporary politics, and even a wizard duel.

Spring Blossom [France, Suzanne Lindon, 4] Bored with her classmates, an awkward 16 year old (played by the writer-director) pursues her attraction for a ruggedly handsome stage actor (Arnaud Valois.) Character drama sets aside the sexual aspect of this staple French cinema situation to focus on the emotion, periodically breaking from naturalism to have its characters express their feelings through dance.

This year’s Q&As are Zoom interviews between the programmers and filmmakers, which drop on YouTube when the films become available for online viewing. In the Q&A for this one we discover that the director wrote it when she was 15, a year younger than her character. She’s 20 now. Lindon is the daughter of well-known French actors Vincent Lindon and Sandrine Kiberlain.

Get the Hell Out [Taiwan, I-Fan Wang, 4] Taiwan’s notoriously pugilistic parliament tips into arterial spray when the effluent of a controversial chemical plant triggers a zombie epidemic. Zombie comedy features an eye-searing palette and an onslaught of optical overlays, and is paced like a quarter kilo of crushed Adderall. 

It’s quite an achievement to find the worst hue of every color on the visible spectrum. Fortunately the underlying message, that government officials would respond to a pandemic by idiotically making it worse, has no bearing on anything that comes to mind.

1. Murder charge after beloved Elvis impersonator found dead after karaoke night  9News
2. Beloved Elvis impersonator allegedly murdered after karaoke night  Sydney Morning Herald
3. Love Island winner's best mate is accused of killing beloved grandad - after the Good Samaritan had tried to h  Daily Mail
4. Video: Elvis impersonator named as alleged murder victim  WAtoday

How the inclusion of Katie Taylor v Amanda Serrano on the bill legitimises the carnival of Mike Tyson v Jake Paul in Texas

We just made the decision to ship the remaining copies of Feast to us. There are about 800 left, out of the original 2000 copy print run. Which is a lot of copies, but given that we were originally scheduled to launch March 2020, and had to cancel an entire summer’s worth of scheduled bookstore […]

[BULLETIN: Quicklisp now has the latest version of FSet.]

Sycamore, primarily by Neil Dantam, is a functional collections library that is built around the same weight-balanced binary tree data structure (with leaf vectors) that FSet uses.  While the README on that page comments briefly on the differences between Sycamore and FSet, I don't feel that it does FSet justice.  Here is my analysis.

Dantam claims that his library is 30% to 50% faster than FSet on common operations.  While I haven't done comprehensive micro-benchmarking, a couple of quick tests indicates that this claim is plausible.  A look through the internals of the implementation confirms that it is clean and tight, and I must commend him.  There may be some techniques in here that I could usefully borrow.

Most of the performance difference is necessitated by two design choices that were made differently in the two libraries.  One of these Dantam mentions in his comparison: FSet's use of a single, global ordering relation implemented as a CLOS generic function, vs. Sycamore's more standard choice of requiring a comparison function to be supplied when a collection is created.  The other one he doesn't mention: the fact that FSet supports a notion of equivalent-but-unequal values, which are values that are incomparable — there's no way, or at least no obvious way, to say which is less than the other, and yet we want to treat them as unequal.  The simplest example is the integer 1 and the single-float 1.0, which have equal numerical values (and cl:= returns true on them), but which are nonetheless not eql.  (I have a previous blog post that goes into a lot more detail about equality and comparison.)  Since Sycamore expects the user-supplied comparison function to return an integer that is negative, zero, or positive to indicate the ordering of its arguments, there's no encoding for the equivalent-but-unequal case, nor is there any of the code that would be required to handle that case.

Both of these decisions were driven by my goal for the FSet project.  I didn't just want to provide a functional collections library that could be called occasionally when one had a specific need for such a data structure.  My ambition was much grander: to make functional collections into a reasonable default choice for the vast majority of programming situations.  I wanted FSet users (including, of course, myself) to be able to use functional collections freely, with very little extra effort or thought.  While Lisp by itself reaches a little bit in this direction — lists can certainly be used functionally — lists used as functional collections run into severe time complexity problems as those collections get large.  I wanted the FSet collections to be as convenient and well-supported as lists, but without the time complexity issues.

— Or rather, I wanted them to be even more convenient than lists.  Before writing FSet, I had spent years working in a little-known proprietary language called Refine, which happened to be implemented on top of Common Lisp, so it was not unusual to switch between the two languages.  And I had noticed something.  In contrast to CL, with its several different predefined equality predicates and with its functions that take :test arguments to specify which one to use, Refine has a single notiion of equality.  The value space is cleanly divided between immutable types, which are compared by value — along with numbers, these include strings, sets, maps, and seqs — and mutable objects, which are always compared by identity.  And it worked!  I found I did not miss the ability to specify an equality predicate when performing an operation such as "union".  It was just never needed.  Get equality right at the language level, and the problem goes away.

Although FSet's compare generic function isn't just for equality — it also defines an ordering that is used by the binary trees — I thought it would probably turn out to be the case that a single global ordering, implemented as a generic function and therefore extensible, would be fine the vast majority of the time.  I think experience has borne this out.  And just as you can mix types in Lisp lists — say, numbers and symbols — without further thought, so you can have any combination of types in an FSet set, effortlessly.  (A project I'm currently working on actually takes considerable advantage of this capability.)

As for supporting equivalent-but-unequal values, this desideratum flows directly from the principle of least astonishment.  While it might not be too surprising for a set or map implementation to fail distinguish the integer 1 from the float 1.0, it certainly would be very surprising, and almost certainly a source of bugs in a compiler that used it, for it to fail to distinguish two uninterned symbols with the same name.  (I saw a macro expansion recently that contained two distinct symbols that both printed as #:NEW.  It happens.)  A compiler using Sycamore for a map on symbols would have to supply a comparison function that accounted for this; it couldn't just compare the package name and symbol name.  (You'd have to do something like keep a weak hash table mapping symbols to integers, assigned in the order in which the comparison function encountered them.  It's doable, but FSet protects you from this madness.)

Along with those deep semantic design choices, I've spent a lot of time on developing a wide and featureful API for FSet (an effort that's ongoing).  FSet has many features that Sycamore lacks, including:

• seqs, a binary-tree sequence implementation that holds arbitrary Lisp objects (Sycamore ropes hold only characters, which is certainly an important special case, but why restrict ourselves?)
• default values for maps and seqs (the value to return when the key is outside the domain is associated with the collection, not supplied at the call site; this turns out to be a significant convenience)
• generic functions that operate on both lists and FSet collections, to shadow the CL builtins
  
• the powerful map-union and map-intersection operations (I'll blog about these in the future)
• more ways to iterate over the collections (the FSet tutorial has a good summary, about 3/4 of the way down)
• speaking of the tutorial, FSet has lots more documentation

Let me digress slightly to give an example of how FSet makes programming more elegant and convenient.  Joe Marshall just put up a blog post comparing Go(lang) with Common Lisp, which is worth a read on its own; I'm just going to grab a code snippet from there to show a little bit of what programming with FSet is like.  Here's Joe's code:

 (defun collate (items &key (key #'identity) (test #'eql) (merger (merge-adjoin #'eql)) (default nil))
   (let ((table (make-hash-table :test test)))
     (dolist (item items table)
       (let ((k (funcall key item)))
         (setf (gethash k table) (funcall merger (gethash k table default) item))))))

 (defun merge-adjoin (test)
   (lambda (collection item)
     (adjoin item collection :test test)))

And here's what I would write using FSet:

(Well, I would probably move result outside the dolist form to make it clearer what the return value is, but let's go with Joe's stylistic choice here.)

For those who haven't used FSet: the form (map :default (set)) creates a map whose default is the empty set, meaning that lookups on that map will return the empty set if the key is not in the map.  This saves the includef form from having to handle that possibility.

My version makes assumptions, it's true, about how you want to collect the items with a given key; it doesn't give you other choices.  It could, but what would be the point?  It's already using a general set with better time complexity than lists, and saving you from having to write anything like merge-adjoin.  The extensible global equivalence relation means you're not going to need to supply a :test either.

I think the FSet-enhanced code is cleaner, more elegant, and therefore clearer than the plain-CL version.  Don't you agree?  Maybe you wouldn't say it's a huge improvement, okay, but it's a small example; in a larger codebase, I would argue, these small improvements add up.

* * * * *

To summarize: if you just want a library you can call in a few places for specific purposes, Sycamore might work better for you (but think hard if you're writing a comparator for symbols).  FSet can certainly be used that way, but it can be much more.  If you want to see one way in which Common Lisp can be made into a better language, without giving up anything that we love about it, I urge you to give FSet a try.

FSet has changed the way I write Lisp programs.  — an FSet user

(UPDATE: the magnitude of the performance difference between FSet and Sycamore surprised me, and inspired me to do some profiling of FSet.  It turned out that I could get a 20% speedup on one micro-benchmark simply by adding some inline declarations.  Mea culpa, mea culpa, mea maxima culpa; I should have done this years ago.   With that change, the generic function overhead appears to be the only significant cause of the remaining ~20% performance difference.  I tried creating a Sycamore set using a thin wrapper around fset:compare, and the resulting performance was very similar to that of FSet with its new inlines.)