(Done) June Meetup: Multiversion concurrency control

[frenchy64]

👍 to RSVP

https://madclj.com/

Wednesday, June 11th, 2025
6:30 PM to 9:00 PM CT

StartingBlock Madison
821 E Washington Ave
-!!->> 3rd floor ("Pop" Conference Room) <<-!!-
Madison, WI

This week, the subject is multiversion concurrency control, the basis of Clojure refs and a key concept in databases. Sayan will give a talk and we will follow the talk with a hack session to help relate the concepts of the talk to concrete Clojure code.

Speaker: Sayan Sivakumaran (@sivakusayan)

I plan to walk through the evolution of concurrency research at a high level, ending at some math that Postgres uses to promise the correctness of its serializable isolation level. For the sake of time, we'll place emphasis on intuition and high-level ideas over proofs:

• We'll start with concurrency research in the 1960s:
  • Briefly touching on the mutual exclusion problem explored by Djikstra, Knuth, and Lamport
  • Introduction to Petri Nets!
• We'll then specialize a bit into concurrency research in databases in the 1980s:
  • Mention intent locking strategy as introduced in "Granularity of Locks" paper
  • This will be a quick review of serializability theory that you might have learned in your database classes, especially around transaction management
• We'll finally go into multiversion concurrency research which builds upon the serializability theory discussed above, with a particular focus on Snapshot Isolation
  • The main star is the work by Alan Fekete et. al in "Making Snapshot Isolation Serializable"
  • We'll relate this back to Postgres's implementation where it checks for serialization anomalies

My presentation is mainly targeting MVCC. We do want to eventually transition into a discussion of Clojure's STM module, so I'll end with a discussion on transactional memory implementations in both software and hardware before handing it over to Ambrose.

Hack session ideas:

• understand and modernize a model Clojure ref implementation.
• relate the code back to Sayan's talk
• Maybe try using simplified refs in Rich Hickey's ant simulation or Overtone, which both use refs

Organizer notes

• bring microphone and slides clicker

[frenchy64]

@madclj/meetup this Wednesday, @sivakusayan will give a talk on multiversion concurrency control, the basis of Clojure refs and a key concept in databases. To follow up, we might then play with a simplified implementation of Clojure refs to help relate the concepts of the talk to concrete Clojure code.

[ericnormand]

I'll bring my kids. Is it the same place as last time?

[frenchy64]

Good question, I will double check with the building manager.

[frenchy64]

Yes, same place as last time. 3rd floor "Pop" conference room.

[brunchboy]

Ah, thanks for the heads up, I guess I was traveling for the last one. Looking forward to seeing people again!

[dpetranek]

I won't be able to make it this time, though I think the topic is fantastic - could we take notes/record?

[sivakusayan]

Ahh, I was hoping you could attend since you do databases for work! Recording would be cool, although I don't have a recording setup ready to go.

@frenchy64 I remember you used to record some of these presentations - would you be able to record this one? If not, I can try to figure something out.

[frenchy64]

I'll bring my microphone and clicker. I'll try and set it up on my computer, but as a backup if you can figure out how to screen record we can splice the audio in after.

[frenchy64]

I should be set to host a recording (not live-streamed).

[sivakusayan]

Oh, just for full transparency, I changed the agenda slightly. When I emailed Ambrose my idea a few weeks ago, I didn't realize how ambitious a presentation this would be, so I'm going to restrict the scope a bit 🙂

I plan to walk through the evolution of concurrency research at a high level, ending at some math that Postgres uses to promise the correctness of its serializable isolation level. For the sake of time, we'll place emphasis on intuition and high-level ideas over proofs:

• We'll start with concurrency research in the 1960s:
  • Briefly touching on the mutual exclusion problem explored by Djikstra, Knuth, and Lamport
  • Introduction to Petri Nets!
• We'll then specialize a bit into concurrency research in databases in the 1980s:
  • Mention intent locking strategy as introduced in "Granularity of Locks" paper
  • This will be a quick review of serializability theory that you might have learned in your database classes, especially around transaction management
• We'll finally go into multiversion concurrency research which builds upon the serializability theory discussed above, with a particular focus on Snapshot Isolation
  • The main star is the work by Alan Fekete et. al in "Making Snapshot Isolation Serializable"
  • We'll relate this back to Postgres's implementation where it checks for serialization anomalies

My presentation is mainly targeting MVCC. We do want to eventually transition into a discussion of Clojure's STM module, so I'll end with a discussion on transactional memory implementations in both software and hardware before handing it over to Ambrose.

[djwhitt]

A little late in my RSVP, but I'll be there!

[frenchy64]

Links:

• from Sayan's talk
  • https://www.cse.iitb.ac.in/infolab/Data/Courses/CS632/2009/Papers/p492-fekete.pdf
  • https://www.cs.cmu.edu/~15712/papers/bernstein83.pdf
  • https://en.wikipedia.org/wiki/Advanced_Synchronization_Facility
• stuff after the talk
  • started modernizing stm-in-clojure https://github.com/frenchy64/stm-in-clojure/blob/master/src/stm/v2_mvcc.clj
  • https://soft.vub.ac.be/~tvcutsem/talks/presentations/STM-in-Clojure.pdf
  • https://clojuredocs.org/clojure.core/alter
  • James' overtone contribution porting atoms to refs overtone/overtone@7334cd5