A portentous reunion | The Observation Deck

Home

Menu

About

|

LIGHT

DARK

A portentous reunion

May 25, 2026

I just attended my thirtieth college reunion, and there were some clear trends
among my mid-life peers. First among them: grave concern for what AI means
for our future and for the future of our (broadly young adult) kids.

Now, surely many generations have looked back at the three decades since their
undergraduate years with a mix of nostalgia for the past and apprehension for
the future, so it’s hard to know if 2026 is truly exceptional in this regard.
And certainly, you can’t argue that today’s anxiety for the future is
unrivaled: my mother graduated in 1968, and is quick to remind that many of
her classmates faced a loss of their college deferments and (depending on
their lottery number) being drafted to fight in an unpopular war.

Still, 2026 does feel singular: every conversation that I had with my fellow
'96ers seemingly circled back to the effects that LLMs are having on knowledge
work — and the anxiety felt for the future.

Beyond LLMs, there was another topic that came up quite a few times (albeit
among an admittedly small and self-selecting demographic). This was a very
specific kind of nostalgia for the three-decades-old past, and explaining it
necessitates a bit of backstory…​

In my first year of college in 1992, my friends and I loved to play the
terrific Wesleyan Tetris by Randall
Cook, the so-called "asshole tetris" that would make your game difficult (by
inserting squares or taking them away or similar mischief) — and then make
fun of you for it.

I thought it would be neat to make a two-player Tetris with similar
inspiration — but instead of the computer making your life difficult, it
would be your networked opponent. In the summer of 1993, I resolved to write
a version of what I had in mind: two players duel in Tetris, accumulating
money (by getting dice in cleared lines), and then using that money to buy
weapons to screw up the opponent’s game (flipping their board upside down,
making the pieces spin out of control, giving them oddly shaped pieces, etc).
Local area networking was not found much outside of commercial and university
settings, so I instead connected two PCs with a null-modem cable. Over that
summer, I also had the blessing of a willing play tester in my younger sister
(thank you, Libby!): she and I spent much of that summer in our mom’s basement
in Colorado, listening to U2’s Zooropa, and playing early versions of what I
had dubbed BattleTris.

When I returned to Providence in the fall, I showed the game to my suitemates.
The game was an immediate hit (if a hyperlocal one!), and we resolved to build
a proper version from scratch for the group final project for our software
engineering class in the spring.

We started the course early in 1994, knowing exactly what we wanted to do (and
having already built it once and having an idea where some of the design
challenges were), we got to work, working on the final project long before it
was formally assigned.

By the time the course’s famous demo day arrived at the end of the semester,
the re-imagined BattleTris was pretty polished — and it brought the house
down: after our demo, it seemed as if everyone was playing the game that we
had created. (This long pre-dates digital photography, but an image that is
seared into my mind’s eye is walking into the back of
the Sunlab that
night — and seeing every computer playing BattleTris.) That was the good
news; the bad news was that it may have been relatively polished, but it was
by no means bulletproof — and the three of us scrambled to fix bugs.

Over the next two years, we continued to work on BattleTris as our time
allowed (and played plenty of it). BattleTris saw some of my own
undergraduate milestones: when my 21st birthday rolled around, my housemates
and I snuck a case of beers into one of the systems labs and turned BattleTris
into a drinking game (one that I was designed to lose — and very much did).

I graduated, and went to work for Sun. BattleTris was left behind, but very
much functional and intact. And indeed, a new generation of computer science
students behind us discovered and enjoyed the game.

Nearly three years after I graduated, I received an e-mail from a student
several years behind me:

From ahl@cs.brown.edu Fri Mar 12 16:45:31 1999
From: Adam Leventhal <ahl@cs.brown.edu>
To: Bryan.Cantrill@Eng.Sun.COM, Michael.Shapiro@Eng.Sun.COM
Subject: BattleTris

I am organizing a BattleTris tournament here at Brown. The first round is
going be open with a $5 entry fee. The money goes to the top finishers.
After that, the first 16 or 32 people will advance to the BattleTris
Invitational. I was wondering if either of you might be interested in
attending the invitational and competing. If so, is there a time when you
might be near by and a one day stop at Brown wouldn't be inconvenient?
We'd love to have you. Thanks, and thanks for making BattleTris.

--
Adam

I didn’t know this Adam character, but I sure
liked
the cut of his jib! (Yes, this is that Adam.)

I couldn’t make the tournament that Adam organized, but I was fortunate enough
to convince him to join us as an intern at Sun the next summer — and then
full-time after he graduated in 2001.

In that fall of 2001, Adam was settling in in California, but found that he
missed BattleTris; could we resurrect it at Sun? Now the better part of a
decade old, there were some burrs that needed to be sanded off on the game,
but with more of us working together we got the game working on Solaris x86
(in addition to Solaris SPARC) and with (relatively) modern X/Windows. Newly
within the walls of Sun, BattleTris found a warm reception: beyond Sun’s
Brown grads who had fond memories of duels in the CIT, new players discovered
the game.

Among these new players was a notable one outside of Sun: my girlfriend,
procrastinating on her PhD, started to play the game quite a bit. She was…​
(phrasing this delicately!) not the best BattleTris player. But she was
dogged, and slowly improved. She would play anyone at Sun who was up for a
game, and in particular, played several (very!) long, meandering games against
Matt Ahrens, who himself was procrastinating in the green field of what was
then known as Pacific (but would later become ZFS). She and I played against
one another often — and (unsurprisingly) I always won.

Well, nearly always. Sometime in the late fall of 2001, after she launched an
admittedly devastating weapons combination at me (for the record: Four By
Four, Broken Record, and Slide Denied), I…​ died. In the other room, she
exclaimed, "Hey, the game crashed." I was (as one might imagine!),
crestfallen — and silent.

She bounded into the room in which my laptop was connected via a long ethernet
cable (pre-WiFi!): "Hey, did you hear me? I said the game crashed."

"The game didn’t crash," I responded, "you…​ won."

"I…​ won?!" she said, seemingly tearing up with joy. What followed remains a
blur, but I seem to recall a parade of sorts through the apartment, as if a
great tyrant had been finally toppled.

Later that evening, I caught up with Adam. "She took a game off me," I said,
glumly.

"She…​ WHAT?!"

I could see that words of solace would not be forthcoming.

I tried to explain, but Adam cut me off: "You know what this means, right? It
means that she’s the one — you need to marry that girl." And while I would
like to believe that it’s unrelated to that game, the fact is that I proposed
to Brigid in the summer of 2002 — and she and I now have over two decades of
marriage (and three kids!) together.

BattleTris, meanwhile, fell into disuse. We were hot on the path of DTrace — and the work would become all-consuming over the next few years. Life itself
was becoming more complicated too, as we all entered new phases of life that
carried with them new responsibilities.

More years passed. We missed BattleTris, but getting it working again was
increasingly a serious project — and after we left Sun in 2010, a daunting
one: the crufty old game would need to be ported to new operating systems
(Linux and the Mac) and into modernity.

Speaking personally, as my kids grew into teenagers, I found myself pining for
BattleTris, if only play it with my kids (and, um, beat them at it).
But again, there
was much elsewhere to do
(starting
a company!) — and BattleTris felt hopelessly overgrown.

Fast forward to a few weeks ago. Adam and I were
reminiscing about BattleTris
on Oxide and Friends, retelling some old tales. Adam and I share a reunion
year, and our college reunions were coming up. Could we somehow…​ get it
working?

Sometime last week, Adam unleashed Claude on the task, and within a shockingly
small amount of time, the BattleTris splashscreen was working. Claude had
knocked down all sorts of gnarly issues, and the progress was promising, but
it wasn’t done. I picked it up, and tasked Claude to port it to Linux.
Another bevy of tedious issues (including debugging what turned out to be a
stowaway setting in my .Xresources
file!), but Claude and I got it working. Now we were cooking: I had it
working on Linux — and had every reason to believe that the game itself would
work as soon as I could scare up a second player.

Meanwhile, back at my reunion, that nostalgic topic that was frequently coming
up may now not be surprising, as several of my CS classmates approached me with
different variants of the same question: "whatever happened to BattleTris?"
The thrill when I showed them a photo that I had taken of the splashscreen on
my laptop was not unlike seeing a classmate for the first time in decades,
bringing a rush of memories back. The reactions were not uniformly positive,
though: when I told two dear friends about it — a couple that had been
happily together since the earliest days of their first year and having now
raised two kids into adulthood — the reaction was decidedly split. His
reaction: "God, I loved that game." Hers: "Right, that’s the game we almost
broke up over." (!)

Still, we hadn’t had an opportunity to actually play the thing, but thanks to
some crappy weather in Providence yesterday, we had our shot, and it didn’t
take long: Adam and I found ourselves playing
the first BattleTris game in
two decades.

Our frenetic combat lasted several minutes, but had an ignominious end as the
first BattleTris game in two decades ended in the first BattleTris crash in
two decades:

*** stack smashing detected ***: terminated
Aborted (core dumped)

The message about a core being dumped was — it turns out — a bit of a fib:
no core was to be found, and there was little to go on other than the fact
that Adam and I had both unleashed our full respective arsenals the moment it
crashed.

Lacking a better idea, I tasked Claude on this, and — stunningly — it found
a bug:

● I found a likely culprit — sendBoard allocates a stack buffer sized by sizeof(int) but writes with BTNET_PUTLONG which uses sizeof(unsigned long). On 64-bit Linux those differ (4 vs 8), causing a stack overflow. Let me verify.

Searched for 4 patterns, read 3 files (ctrl+o to expand)

● Found it. In sendBoard (BTCommManager.C:352), the buffer is sized with sizeof(int) (4 bytes per board cell on x86-64), but BTNET_PUTLONG writes sizeof(unsigned long) bytes per cell — 8 on x86-64 Linux. With BT_BOARD_HGT × BT_BOARD_WTH = 280 cells, that’s a write of 2240 bytes into a 1126-byte stack buffer — a 1114-byte overflow that the stack canary catches.

This wouldn't have triggered on the original Solaris build because that was 32-bit (sizeof(unsigned long) == sizeof(int) == 4). The board is sent whenever weapons
like BT_CONDOR, BT_AMES, or BT_ACE are active during piece placement — which matches your "we both threw weapons" scenario.

Wow! Code inspection revealed that this was a definite bug, but might not have
been the one that we had seen: Adam had told me what weapons he had used on
me, and it didn’t include any of the weapons that would induce the bug
(namely, the spying weapons that allow you to watch your opponent’s game).

I told Adam what Claude had found — that it had found a bug, but probably
not the bug? — and Adam replied that he had, in fact, also deployed a
spying weapon: the bug that Claude found looked likely to be what we hit!

We quickly verified that the spying weapons did indeed induce the failure, and
then applied the fix, rebuilt, and played our game anew.

This time, the game was complete. (It would be indecent to say who won that
first game, but let’s just say that Adam later settled the score.)

Meanwhile, fellow Brown CS alum (and BattleTris aficionado) Matt Amdur had
returned from errands to the beachhouse where we were staying together. More
BattleTris was played, drinks were opened, a requisite selfie was taken:

We played BattleTris deep into the night. It was a perfect reunion: fun as
hell, with so many fond memories coming back to us.

It is no exaggeration to say that this was brought to us by Claude. Yes, we
of course could have gotten BattleTris working without Claude’s help (but the
preceding two decades tells us pretty clearly that we wouldn’t have!). The
reasons that we wouldn’t have done it (didn’t do it!) on our own
are myriad: yes, the work involved is tedious (and time-consuming),
but also because it is so indeterminate as to be speculative: when porting
something (which is what this amounted to, even if porting into modernity and
with as light a touch as possible), it is very difficult to have forward
visibility as to progress. That is, you can feel deceptively close to your
goal (only to discover some major piece that needs to be rethought) — and you
can also be deceptively far (what feels like smoldering wreckage is sometimes
but a single fix away from functional software).

So paradoxically, this profoundly human, joyful moment was indisputably
brought to us by the very thing that we are worried is going to strip us of
our humanity.

Where does that juxtaposition leave us? As I have outlined in
Oxide RFD 576, I believe that LLMs
are but a tool, albeit an exceedingly powerful one. When we cease to believe
this — when we think of it not as a tool, but as dehumanizing mechanistic
overlord — we subject ourselves unnecessarily to it. Yes, LLMs mean a lot of
changes to domains that may be unaccustomed to technological change, and yes,
some of those changes will leave us wistful for a bygone era — but I also
believe that there will be many more BattleTris-like experiences in our
collective future: delightfully human moments that remind us why we build
stuff in the first place.

As for BattleTris itself, yes, we know — and yes, stay tuned!

The author reflects on the concerns of their mid-life peers at a college reunion, noting a widespread apprehension regarding the future implications of artificial intelligence and its effect on younger generations. This anxiety is juxtaposed against a deep-seated nostalgia for the past, which the author elaborates through a detailed account of creating and developing a networked Tetris game during their college years. The game, initially inspired by Randall Cook's Tetris, evolved into BattleTris, which the author developed by creating a two-player version that utilized local area networking to allow opponents to manipulate each other's game states through acquired in-game currency and weapons. This project involved collaboration with peers and family, culminating in a polished version for a software engineering class project.

Following graduation, the game persisted, evolving through various stages, including being used as a drinking game and later finding new players among computer science students. Years later, the author and a friend revisited the game, aiming to resurrect it. This effort involved leveraging the capabilities of a large language model, Claude, to tackle the complex task of porting the legacy game into modern operating systems like Linux. During this process, the interaction revealed a critical bug in the original software, stemming from an overflow caused by a mismatch in how memory buffers were allocated and written, a flaw that was triggered specifically when certain "spying" weapons were activated by opponents.

The successful identification and correction of this technical bug, aided by the LLM, ultimately led to a shared, joyful experience with a fellow alumnus, emphasizing a potent juxtaposition between abstract technological problem-solving and profound human connection. This shared experience of rediscovering the game, culminating in a final, albeit crashing, match, served as a powerful reminder of the tangible, human elements that persist despite the advancement of technology. The author suggests that this moment of shared experience—a feeling of delight and memory—was brought about by the very technology they often worry about. The text posits that while LLMs are powerful tools, viewing them solely as mechanistic overlords subjects individuals to them unnecessarily. Instead, the author argues that these advancements should engender more human experiences, reminding people of the fundamental reasons for creating things.