I mean, Rich Hickey gave this talk 17 lifetimes ago in software terms called Simple Made

Easy. And

it feels

like the first thing to

talk about is just what the difference is, what do we think the difference is between those things? Simple and easy. I

have a theory. I could go or not. I

mean, I guess I could give my perspective on this of like, Oh, God. Yeah. This is hard for me to articulate. But like, simple can be hard, right? So it's like getting to something that is simple can sometimes take a lot of energy and effort. And sometimes things that are simple are not, say, a synom, be like beginner friendly, right? It can be confusing and difficult and challenging to interact with something simple. Whereas easy, it's just kind of like the, yeah, I don't know, I don't know if I can define them, but not in terms of each other. And I'm sure you have something, Sam. You definitely have something. So just go for it. That was a bad attempt. Go. Go. No, no, no, no, no, no, it's not

at all. Because it is, it is hard. So I think what one thing

we can note about the difference between

Simple and Easy

and that talk starts by talking about words, which I love

talking about too, it's probably the reason I love the talk. It's the history of

words,

but simple is something which at least arguably can be just like a property of a system. Something is simple, whether or not there is someone there experiencing it. Easy is saying inevitably something about a person, a user of a system and their experience of interacting with it. Did they have an easy time doing it? It's one of the few clear things

we can say. And I actually do think it ends up being

pretty difficult to talk directly about simplicity without getting back to some agent experiencing it. But I do

think it's worth at least sort of starting from separating out

these concepts. Because I mean, you know, some of the other stuff that we can say about this,

like, if we're going to talk, that's the it's the art of hiding away complexity,

right? Well,

question is how leaky is that abstraction that you

made? Usually

if you're going to hide away that complexity,

is that something that somebody else needs to unhide later? Because you made choices in the way that you had away that complexity

that was great. Let's start there. I can say more, but

yeah. Yeah, I feel like for the Simple versus Easy component does I like that comparison of like a property of a system versus a property of a entity experiencing that system? Because I feel like that puts it kind of on like a not purely objective, but like objective versus objective spectrum where it's like, what is easy for one person might not be easy for another. But that doesn't necessarily mean that just because it's not easy for someone that the system isn't simple. And similarly, you can have very complex systems that some people find easy, even if they are still like very complex. And maybe that's kind of there's an element here of like group sizing as well. So perhaps we get more towards something that is simple, the larger number of people that find it to be easy. I feel like there's probably some relation there as well. But yeah, I like Rob Pike's definition of simplicity kind of being about, you know, hiding some of this complexity, because I think there is inherent complexity in the world, and you can't always just reduce it down. You can't, you know, turn all of the complexity into simplex things. I think attempts of doing that wind you up with very noisy APIs and things like that, where you're like, well, everything is its own little world, own little piece. You got to assemble all the pieces together. So I think part of it is about taking complexity and putting simplicity around it. But that is, I think part of it is doing it in a way that isn't leaky. I feel like if you, if you make a simple, say, interface for something, and it leaks the complexity out, I feel like that it's not simple. Like you, you fail that your goal of making it simple, right? I feel like the garbage collector is a good example of the trade-offs here. Like you can't tune it. You can't do a lot with it. It's what you got. You don't really get to tell it what to do for the most part. I think there's like a knob or maybe like two knobs to adjust what it will do. And they could have made it, they could have exposed more of that complexity to make it so you could get more closer to what you want. But that would have made probably harder to use overall and harder to use correctly. So I feel like that's a place where they traded some amount of flexibility to make the whole overall system simpler and also make it easier for people to use.

Do you think that in exposing some controls because now, you know, certain environment variables tweak certain garbage collector behaviors, for example, right? Do you think the act of exposing controls can make the system intrinsically more complex or things built around

it?

Exposing more controls make the system.

Like when there are more knobs, when there are more knobs, sorry, let me ask this in the most cryptic way. Sorry. If we expose no knobs, then certainly we can at least say it's easy. We

don't know how much complexity we're

hiding away. Exposing more knobs can make it

harder to choose

the right knobs for your

case. So there we're talking about the

agent, the

entity that interacts with the system,

right? But

do you think that the act of exposing knobs makes things

potentially more complicated for the system itself, for the system designer, or for other systems that need other systems that need to interact with that system? I want

to talk about the opposite of that, right? Do you think exposing too few knobs can make it harder to use more complicated? Yeah, sure. So it seems there has to be some middle ground there. So it's, to me, making something simple and easy is exposing the right knobs, right? Yeah, which

wouldn't

we all like to do that? So how do we choose those right now? That's

the

game, isn't it? Yeah, it feels like it's not quite an orthogonal relationship, but it feels like these are two loosely correlated things, right? So I feel like in my mind, I'm like, yes, you can add knobs to something and it can make something more or less simple. And you can remove knobs from something and make it more or less simple. And that in my mind means that these two things are perhaps related, but not directly related, right? Because if they were, if they were more directly related, then you could be like, oh, removing knobs from something, that'll make it simpler, or removing knobs from something makes it more complex and have it always hold that way. Since it doesn't always hold, it feels like these are like, you can make something simpler by adding or removing knobs, but it depends on the thing that it is less on the simplicity itself. That goes back

to the objective subjective thing, right? Like, I mean,

I think there are some objective things we could say about this, right? Like having two knobs that do the same thing is more complex, right?