Clockwork Clojure: A Protocol-Powered Runtime for Composable Evaluation - Ferri

[applause] Hi. Um, excited to be here. Um, all right. We're going to talk about this runtime I've been making on Swift for uh, All right, the most flashy part is the the iOS. We're going to look and I'm going to show you on here. I wanted to uh do a little bit more, but I I have less time than I thought. So, I actually cut out all my slides this morning to save some time. And all right, I wrapped a little app up around our runtime. You can evaluate. I'll show you this on here. I wanted to screen mirror, but we're going to have to make things easy. All right. As I start it, I'm going to tell you what it is. It We're going to look at it on iOS first, but that's just an accident. This isn't supposed to be closure on iOS. This is the closure runtime deconstructed and sliced apart so that we can put it on iOS. This is just a proof of [snorts] the architecture. I took a week or two and just uh had some swift guys help me wrap the runtime in this. The reason we can do this is because the novel thing about this this runtime I'm gonna try to hit these points here but uh is that it's it's a little bit inside out built inside out. When you go to start a runtime you you might think I'm going to start let's see I got to read I got to have all these things I'm going to start building this giant piece of software. What we did was we did it um inside out and we started with a explicit runtime and we started teaching it how to do things. Um so we'd pass a state in along with uh a command to-do and we'd have it do that and so we started building it up. What it feels like is a little bit of a we know reduce. So this is kind of a little bit of a big big powerful reduce that does extra things but think of it as reduce today meaning that we have a function that knows how to traverse a data structure. Uh the data structure might be an a we might be parsing but it might be anything. The first go at the a we might turn it into something else and then we're going to traverse that. So think of it as reduce meaning we know how to traverse this data structure that's coming. We can initialize it with an initial state. That's the explicit state of the runtime. we pass it in. This is nice because you can at any time see every part of the state. None of it's implicit, none of it's secret. And that means every iteration, every everything that the runtime does, every every effect is explicit and we can see the effects of it in the runtime at the end. Um, and part of the other the side effect, the fallout is that it's easy to put in this app because we're not running a big thing. We don't have to recompile it for this. uh we can just pass in a different in the spirit of reduce we can maybe pass in a different reducing function. This thing knows how to walk it but all we need is a little bit of special stuff for iOS. Um and so this is just uh this is actually not what we're delivering. We did not uh agree to deliver iOS at all. Um this is just a little proof of an addiction. what we what we said we were producing is a a runtime where you can swap things out uh and change things and that that includes you might swap it out to do nothing. That's a stripped down closure runtime. Good for maybe embedded devices if you don't need a lot of namespace support with with multiple namespaces. Maybe you say, "Hey, I want this to be faster. We don't need all that namespace stuff. We're just going to use one here because it's we want it to be very small." So that was the selling point is you can cut pieces out, swap them in, have them do different things. Uh, all right. So how it works in this app, let's just we'll evaluate a little bit. So what it does is it just has the reader function in here composed with a parser which doesn't have any state composed with an evaluator. And so we just put these forms through it and that's all there is to it. Um, let's try adding. Okay, cool. So, what what I have here is a bunch of forms we can try just to see how far it is. Let's not do do that quite yet. The tour of validity. I I was thinking, you know, if I were in the audience, I might have my doubts and I might say, [clears throat] there's some tricks. Someone's doing some tricks here. So, I have a few fun little typing [clears throat] them wrong. Let's just see what we can do here. All right. There's a Fibonacci function. Let's Let's try. Apparently, I'm going to hit D a lot today. All right. So, we've evaluated it. It's in the runtime and we can see it. Well, you know what? I need to make this fast. Let's Okay, we can map lazy sequences work. We can take range works. All right, this one has a loop. I'm just I'm just proving to myself and you that All right, then let's try running a Okay, let's try macro and then we're going to which because if this is so easy to do here, we could we should be able to do the exact same thing in the Mac OS, different target, but the same model. And this uh after we let's look at a couple more. I just want to expand this so you can see that macro expansion work. And this is going to stay up here. And then we could evaluate that if we want. Um [sighs] all right. And then I I wanted to go on and show you that we have records and protocols and everything. We can take uh we can deconstruct those with map access or keyword access I should say. Oh greet. Yeah. Okay. This this calls to a protocol that I haven't defined. So we're going to see what happens there. Um, let's just try a couple of these. Now, the the interesting one thing about the this is it doesn't do multiple forms unless you wrap them in a do because it's it's just one thing at a time. All right, I got to look at the time and make sure we move on here. Okay, there we've tried the tried the simulator a bit. Let's give it a rest. Uh this is showing you closure lang RT exists and we can call more on it. This is a dot form that exists in the Java runtime actually. So what we're looking at is is the runtime's ability to uh mimic the JVM and that comes from a mixture of what we're doing here. We're uh putting state behind protocols and we have this reduce model with an explicit state. So we can take this and say okay it's a dot form and it ends up uh we did this so that we can have compatibility so that if you have code that wants to run on the JVM you can kind of do that unless it's doing some really JVM stuff. Uh this is things you find in core. So we wanted to be able to load core. CLJ and and run it and get all the harvest the free stuff out of there. So, so it does know how to to pretend to be Java if if you wanted to and it's less performant than Java of course and in doing stuff. Here's another effect. This is the Macrepple and I'm showing you that um when we start it up after we stop it, I I have it compiled to dump some stuff. This is this will not stay here forever, but this is the explicit state we're talking about. Oops. Okay, this is the same runtime, but now it's in ripple form. All right, as we switch over, I just wanted to um come over to [snorts] show you some of the Swift code and how it's built. I hope this will make it click for you and then we'll see some other things that we could do. We'll talk about it. So um let's look at the reader is a good one. The reader [snorts] small. Now I'll talk about just in general how we build this. The the goal that we do when we do this and I what I do is I take an enum. It's not a it's not exactly a a closure thing but these correspond to the protocol. All right. I need to I need to explain this better. What we try to do is take split off all the logic from all the state. We have this explicit state. So let's go ahead and handle that in the reduce, right? We pass that in and it it gets updated through this reduction and we use protocol so that we can swap out the back. Now one key to this is when there's an effect and you need an updated state, we just make sure to return the new state uh from the protocol. So effectful methods in the protocol return a new updated version of themsel as we as closure data structures do. You add to a vector, you get a new one. So we modify the runtime, you get a new one. This allows us to undo stuff. If you're in the if you're in the iOS app, I thought one fun thing to do even though we're not shipping iOS is you can it doesn't have standard input, right? uses other things. A camera could take a picture of some code. We maybe we could load it straight off of GitHub. We're always connected. So, we can do some things like that. And uh this uh this design allows us to do that. And what we do is we end up separating the logic almost completely from the state. And [snorts] this is great because the the code just stays so pure. It looks it looks incredible. You're going to I think you're going to love it. It's uh I'm excited to share it with you. It feels it feels feels exciting. It works better than I thought it was going to work. Uh because [snorts] I've played with this model for a while. Um and the reason I use an enum is because yes, there's there's this protocol right here. This is represents a string or an input. We can we can wrap this. It's very simple. Look at that. Easy to get a string in there. You can put a a stream or a state in there. Uh bytes. H and we manipulate those with these enums. So these enums have less stuff. See the get on the protocol for one, it takes the object in. How am I doing on time? >> Oh, yes. Yes, I meant to do that. That was on my paper. I'm sorry. This is my first talk ever, so I'm a little bit scatterbrained. How's that? [applause] I'm sorry you didn't see any of that app. I hope you believed me. I just told myself, you know what, all these people, we're all friends. None of them know me, but they're not going to come at me with pitchforks. Thank you for helping me. Yeah. If something else goes wrong, please, please say, "Yeah." And if you have any questions, you can interrupt me. I don't mind answering them. All right. [laughter] >> Yes. We're going to use up all our time here, making it so you can see my talk when What's the Oh, what? That's why you're here. You want to see the talk? Uh, I don't know if I have time to make it on a light background, unfortunately. I don't I don't want to do that. Thank you for letting me go on that one. All right. So, we were talking about the enome and I use this um as a way to get completely detached from the state so that we're only dealing with logic. So, we manipulate these enums and that allows us to cut the state completely out. You'll see these all have less less stuff. Get as no arguments. All right. Uh and then that means the logic is down here. And what we can do is this is a Swift annotation. Swift has a lot of sugar. And all this does is uh automate some calls in between. So this just does the the piping of meshing these together is what I call it. mesh because it's a clockwork theme. So you can see that the with this annotation it kind of just stacks like a list of effects you want to do. End of word is these three. And now we can start doing end of word. Ignore means seek till the ignored character. Okay, you're getting an idea. We've got to we've got to keep moving. Here's the dispatcher. Take a character. If it's this, the effect. So, we're kind of defining the effect, but notice we're not actually doing it. So, on this, it's a closure comment effect. If it's a quote, read the next form, tag it with quote. Read the next form, tag with Deref. And the parser knows how to input these. So, the inputs flow and the state flows. The state might change, but it flows. All right. Um, and then, uh, let's just go down to the end of this reader and you can see the Okay, this is the implementation of the protocol on a string. That's what it looks like. It's that big. This is the reducer function that I talked about. This is a convenience, but unwind is what I called this reduce. It takes a reader command and a state and it just goes through. That's all it is. So, it maps it maps to there and you come out with an answer and a new effect if you want it. Let's just take a look at a couple of other little effects. And and then you'll see that what I'm actually doing is when when I have something to do, I start breaking it into effects. And since I don't like dealing with those, I used to always just put them off, try to cut them out like this. But I found it's even better to make them first class citizens. and instead of ignoring them, you attack them directly. So we we make those effects explicit and then you can manipulate them, you can change them, you can look at them before you run them. It's very powerful. Um let's look at some of those. So in the eval subsystem, and this is this is different effect systems tied together. Um so it's a little bit of a a bigger model, but I'm trying to simplify it so you so you know what's going on. And I I hope you are following. Here is enums for the eval subsystem. We can evaluate, we can deaf, we can if let loop, recur, recurrence points are saved, locals. All right, let's look at the runtime. It has some other enops capture the state qualified stuff, do namespace stuff, do IO stuff, resolver stuff. All right, when do I need to stop? 13 minutes. Okay, so those are some examples of the enums that we we manipulate and run through. Now, uh I also ported this to Closure. So, I'm going to show you how it looks in Closure to do this. Uh we don't have time to run it really, but I have it in the ripple and I ran some this morning and we can look at it. Um uh then maybe we should do that now. Um, eventually it's going to it's going to feel like our stuff is speaking closure to each other. And I didn't mean for this to happen. It just kind of feels that way. Um, all right. So these these enums what it looks like in closure when we do this is um I wanted to talk about namespaces first. So I said I put off namespaces. Uh the runtime at first I just didn't want to do that. We were doing let scopes, you know, scopes that can drop off loop recur. I didn't want to deal with namespaces. I thought we can deaf, we can look up and we're kind of just in this unnamed namespace or maybe it's called closure.core if you want or enum or whatever. There's just no namespace. Eventually, I had to do it because you have to stop faking it. But up till then, we did some things like, oh, let's take dotted symbols and just just treat them like they're not dotted. Just be naive about it. You can get kind of far that way. But eventually we had to do name spaces. And so when it comes time to do a system like this, I put it off because you kind of get an idea of what effects need to go in there. As you work around it, you'll have this name space shaped hole and you'll say, "Ah, I need to do this. I need to do that." And that helps you call out these effects that you need. And then you can combine them. Let's look at So when I made the namespace machine with the namespace events, I ported it to Closure. Um, I did ns star as my as a little fake uh fake version to show you how it how it works. When I did the closure one, you'll see that I called this complexed. Can you see that? Is that big enough? >> No. I'm glad I asked. Okay. How do you make Emacs have >> I I don't know how to make it bigger. Okay. I was trying that. I thought it says meta plus is undefined. This has taken me too long. Oh my gosh. Okay. Well, let's um maybe I'll cut it. It's just so this. Sorry. MX >> MX increase. >> Yeah, thank you. [laughter] >> Oh my god. Thank you guys. >> Oh, okay. text. There's a way to do this, too. I can run the last command. Interactive fun. Hey, you're welcome. All right. So, here's what happens when we take this namespace form and it looks just like a regular namespace form, but that star that put puts it into this machinery that I wrote for you to see. It's not a real solution, but this is what happens when we when we break down effects like this. And then as you saw in the reader, you mesh them together with without the logic. You have stuff like this create. And actually this thing is a protocol method that I just include with it just for fun. So and the these are the args. FU is the name space up here. There's a set current event. There's a require alias add refer ad. So you start coming up with these these effects. And then when your reduce like loop hits that effect, it knows which protocol to map it to and you get a new state out of it or perhaps just a query. So that is a concrete example of how breaking down into effects looks for for namespaces. Um okay. And then over here, let's look at in Swift. There's there's enums. Some of them are kind of nested. Okay, you get the idea. Um, this makes effects feel real easy because they're explicit. Your your loop can look at it literally first before you do anything with it. You don't want to do that. Don't do it. uh you're you're on the web and you're just going to take a picture of some code and you you well we can there's safe ways uh we can drop stuff off for example when we load core we have a special loader that says usually when you deaf something you overwrite if we're reloading core. CLJ JVM version we actually don't want that because it's going to overwrite some of our Swift native stuff with JVM stuff. So what we do is we have a partial and that's in here. I should show you that built-ins. We register these functions as being available in core. And then for the special core loader, our our reduce just happens to say if this already exists actually just don't do it. So it makes a deaf act like maybe a deaf once. It's easy as that. Okay. Um no landmines. Landmines's gone. State explicit. Okay. How much more time do I have? 10:20. I think I'm done. 7 minutes. Okay, here's what I'm leading to. That's fun. It's cool. Sounds good, right? Let's talk about what you can do, though. Not only can you change There's a couple different points you can extend stuff. One is you can change what you do with one of those effects when you see it. Your loop can can decide something different. You have control flow there. You can skip. You can do a little you can output at one point I had stuff printed each go so I could see everything happening. Um or you can or you can overload the state or the the protocol I should say the thing behind the protocol just uh pass in a different thing behind the protocol and you can wrap another thing and only override one piece. Um but some fun can happen. Um [clears throat] let's just see if there's anything else here I wanted to do. All right, let's just do we have time to try protocols? You know, maybe we'll do that later. Well, let's do it. All right, here this will it'll format a little funny, but okay. Did it Did it work? I think uh I think it didn't. Oh, well, you know what? We'll do that after. What I want to talk to you about is is what else we can do. Now what happens here when you have this model is you can say what else should I put behind that protocol right just for fun. So what should we do in this case we looked at namespaces and we have a protocol that that name spaces can hit for their effects. So I thought you know what would be fun normally we store this stuff in memory. So what else could we do? We could do different stuff in memory. But you know what might be fun to see? What if we store it in a different backing? Sure enough, you can do all you need to do is put some Reddus methods behind this protocol and then you have persistent namespaces. It's I didn't even say I was going to deliver this. This is just something you can do. So I I did it for us. Um, I'm going to talk about another thing I did and that's that I didn't I didn't have a build tool and so we we just put that off too. And and one of the fallout things is since closure leans into metadata hard, I thought, hey, why not just piggyback off that? Closure has powerful metadata systems. So, what we're going to do is restart this ripple and say we're going to enable Reddus. It's just going to use the default Reddus. And um it works just like like before except um okay, let's create a namespace. I'm going to annotate that namespace name with a reddus flag. And I did that because all we had to do was teach our little um alter meta alter config effect. So we just went in there and said, "Hey, if you happen to see Reddus, we're going to use a different backing." And in fact, when you alter meta, that's a system event. So we can alter meta and switch from Reddus backing to a different one. And we'll demo that if we have time. That works. Um hot swap. Okay. So we should be connected to to Reddus namespace. Is this going to work? I don't know. I think so. But it did this morning, but I don't know if stuff goes wrong, right? So, all right. Here's where we are. Let's deaf some stuff in there. Comes back out. That's good. Let's do a function in there, too. >> What's that? >> Oh, yes. I'm going to do so much better next time. Is that too too >> Okay, good. Forgive me for this. I'm Thanks for being patient. Do I need to stop? Do I have like three minutes left? Oh my gosh. Okay, I might Whoever's next, I might not surrender. [laughter] >> Oh, shoot. Well, I don't know. [clears throat] Let's see. We Let's wrestle. Okay. Greet. Um, man, I got to hurry. Ask questions if you want. I don't want it to be silence. If you have a question, we better just do that now. >> Well, I didn't really decide. I didn't have to. Uh it's the same. That's that's the beauty of this is a compiler and interpreter are just two different you're running over the same loop. Uh you might have a different state and a different backing behind your protocols, but it's it's actually the same path. You do it the exact same. You just swap out compile and interpret and you have it. The reason we do this and the reason to answer your question more directly, so answer A is I didn't choose. We have both and it's super easy to just swap. The other answer is because on iOS you can't compile. You can't do just in time compile. So if you want anything on iOS you're expanding macros interpreted. But we can do that just as easy as compile. You won't even know the difference. All right. Okay. Hi you. Now let's just you have HTTP too and we're not going to use that. I guess we don't have time, but I think I need to finish. Does anyone else have another question? >> Oh, there's a PHP project. Well, I I don't have any control over that. I don't know. Okay, we restarted and it's still there. Let's call a function. Okay, it's 10:20. I think my time's up. So, man, I wanted to show you more. [applause] THANKS. Just as I'm closing up, I wanted to say the one thing I left out was the loader. And I wanted to tell you that I discovered the loader is a complete fiction. It doesn't exist. [laughter] Yeah, it's just the reader uh parser which doesn't have any state really and the evaluator. And I put it off so long I realized there's no load. It's just the little thing that composes on the end. And this was when I thought, oh no, what are we going to do without the Java class path? But eventually I said, thank god we don't have that Java class path. Uh because what is the class path? It just takes a symbol and turns the symbol into bytes. One one event in that in that ops set. So we can actually swap out for load. We can take that beginning thing and say load straight off of GitHub. Or since GitHub is two things, we should be able to load off any HTTP and load off Git if we want locally. And I did implement that. I wanted to show you. But yeah, uh we have just like the Reddus, we have HTTP backed. And the cool thing is you can hit the namespace and it dumps out the entire namespace as if you wrote it that way. So you can actually load the namespace after you define a peace meal in the ripple. It will spit out a whole namespace form. And that's the type of things you can do. I wish I could show you. Man, I would take all day if I could, I guess. Thanks.

What if Clojure’s core semantics were modular, pluggable, and inspectable? Clockwork is a protocol-driven Clojure runtime hosted in Swift, rebuilt from first principles with no shortcuts. By abstracting effects and treating evaluation as data, we gained a live REPL on iOS plus a fully flexible evaluation substrate. Namespaces become dynamic, versioned mappings; macros evolve into remote, queryable services; interpreters, compilers, and pretty-printers swap on the fly. In this talk, you’ll see Clockwork demos that include: Live REPL-driven UI iteration on mobile Remote namespace hydration from Redis and Git Macro server with expansion tracing and visualization Hot-swapping evaluation strategies without breaking code Attendees will discover patterns for designing their own pluggable runtimes and DSLs, and witness how composable evaluation unlocks new horizons for Clojure tooling—on any platform. But this talk goes beyond demos: we’ll explore how protocol-based design empowers developers to rethink evaluation itself—turning it into a modular, inspectable, and swappable foundation. Whether you’re building a DSL, crafting runtime tooling, or transplanting Clojure’s interactive power into new environments, composable evaluation offers a transformative approach. Biography Paolo Ferri is a runtime designer, language hacker, and unapologetic lover of clean semantics. He’s spent the last year crafting a protocol-powered Clojure runtime that reshapes evaluation into a pluggable, composable architecture—with no shortcuts, no magic, just gears and grace. The result? Clockwork: a native Clojure runtime that interprets, hydrates, compiles, and hot-swaps its semantics seamlessly across platforms. Built in Swift from first principles, Clockwork runs a live REPL on iOS and supports macro servers, dynamic namespace hydration, and hot-swappable interpreters—all from pure Clojure code. Paolo’s philosophy? Architecture should move like a sonnet and hum like a well-oiled machine—precision earned in the quiet cafes and winding alleys of northern Italy, where beauty is non-negotiable and precision expected. He’s here to share Clockwork not as a personal achievement, but as an invitation—to rethink what a runtime can be when clarity wins, evaluation and effects are composable, and the REPL lives anywhere imagination can reach. Recorded Nov 13, 2025 at Clojure/Conj 2025 in Charlotte, NC.