@shalabh.com
Programmable software systems "research" and philosophizing. shalabh.com/programmable-systems Computation is a physical process. Any models we use to describe this process is imposed by us. What models would you choose?
Agree English isn't great for this. LLMs change the equation for English <-> code translation. You could have a prog system designed for LLM/human hybrid editing. This is where I feel research is valuable. LLMs still rely on 'hard logic' for correctness source of truth, but help comprehension.
The open access version of Cultures of Programming is now available online. Just in time for the holiday break!
Read it here: www.cambridge.org/core/books/c...
If you prefer a real book, use PETRICK26 for a 20% discount (valid until January 31) at: www.cambridge.org/9781009492348
New blog post: "Going for robustness"
https://blog.khinsen.net/posts/2025/03/05/going-for-robustness.html
Thank you I appreciate the links!
they key aspects of this design i see are:
1. each node determines quorum independently
2. conflict free and order independent fact messages
3. each node only makes decisions for itself, but can be aware of the quorum decision being different.
finally, these set of peers can be maintained by quorum as well, by using `peers` as a value.
if you read this far and are so inclined, lmk if this protocol or a better studied version exists. also lmk about obvious holes.
C) if you propose N distinct values for key1 simultaneously, no value will get quorum. if you keep doing this you will have a livelock.
maybe this can be resolved by each peer noticing there's a quorum failure at version `@v3` and flipping their choice by proposing a new value the next version.
B) if you propose (key1@v2=value2) and (key1@v2=value3) ie conflicting values to two peers simultaneously, one of the values will achieve quorum but all peers will eventually become aware of the quorum.
so running thru scenarios:
A) if you propose (key1@v1=value1) to a peer on a new cluster, the peer will accept it and broadcast (key1@v1=value1, accepted_by=peer1). other peers will accept it facts will trickle through the cluster, eventually which each peer will be aware of the consensus.
5. each peer determines quorum independently. so if N=5 and a peer sees that (key1@v2=value3) has been accepted by 3 peers, it knows that's the quorum and will reply 'key1@v2=value3' to the query for `key1`.
4. every peer *accepts* the first key@version=value it gets for that key and version. this creates a new fact (keyX@versionY=valueZ, accepted_by=peer) - which is then broadcasted around. there are no conflicting facts ever, it's all append only information.
In total armchair theorizing fashion, here is a consensus protocol I am thinking of:
1. no leader, N peers
2. peers gossip/broadcast facts to each other
3. each fact is (key1@v2=value3, accepted_by=peer5).
facts can always be forwarded as-is. the @v2 is the version for key1.
I quite liked this talk – sets up a clear perspective on how to look at consensus protocols. I didn't find Raft all that simple anyway (but I also bias towards leaderless consensus).
Please submit to Onward! papers and essays. One of the best places to publish ambitious non-mainstream ideas on programming.
2025.splashcon.org/track/splash...
2025.splashcon.org/track/splash...
Not a live system but tangentially related: github.com/Instagram/Mo...
Has anyone ever heard of a live programming system that uses the types of dynamic values to feedback into static analysis?
Plenty of reasons for this, which we've detailed in our newsletter: https://buttondown.com/northbaypython/archive/weve-extended-our-talk-submissions-window/
the most important thing: we do want to hear from you, so get your talk ideas in soon!
Hi, I'm curious what you think has held cython back?
When activated, the runtime objects themselves can link back to the source objects they arose from. So we have a way to represent deep provenance.
So a type annotation or a function call is not represented as "just text" – it is represented as a hyperlink to another object (the target type or function object). You probably don't need import statements because these links are resolved at edit time.
Dynamic objects change over time or when you interact with them. But they still link to other objects (either static or dynamic).
In this world you dont have plain text languages. Programs are natively represented by a web of hypermedia objects.
I personally want to see a native hyper-object OS. The core abstraction is a hypermedia object. It contains words interspersed with hyperlinks that link to other hypertext objects. Objects can be static or dynamic. Static objects are most similar to hypertext documents.
Most hobby OSes and OS courses mimic the Unix model with a "filesystem", "executables", "processes", "byte streams" and such. This is unfortunate. The design space to explore new core abstractions here is so much bigger.
Is SNOBOL's native pattern type similar to this? www.regressive.org/snobol4/docs...
But I don't know if it qualifies as general purpose.
Wow this is neat!
Here's the original youtu.be/495nCzxM9PI?...
How does one introduce a substrate without building an operating system?
Yeah, I guess it would.
I agree that compuation is about viewing/ interpreting properties of a system target than intrinsic. Another philosophy question, what is interpretation? Can any system interpret or what is special about our brains?
The question should be whether we can have a programming system that is version aware across all core abstractions.