Thank you so much, Joshua. I'm really excited to be here. Just to clarify or maybe I'll clarify as I get into it, I'm not great at naming things, so there's, like, a bunch of different names for things. Glozon is just a sort of umbrella term, which has very little meaning, but I wanted a website, so I picked a domain that was for $10 instead of having to pay, like, a lot more to get something that had meaning. So in any case, but I'll talk a little I'll use the terminology, and then you can sorta, like, follow my lead on the terminology. But it's not there's no reason for you to know that because, again, I'm not great at naming things. Cool. So, hi. I'm excited to be here. I usually start off demos and talks by going into the importance of democratic governance and explaining how so much of technology and the web doesn't assume democratic governance. It just sort of automatically instantiates the sort of, like, authoritarian, governance system. But I feel like that's kind of preaching to the choir with this crowd, and a lot of you are sort of already on board with that. So I'm gonna skip that segment, but I'm happy to, like, dive more into it during the q and a if folks are like, wait. Go back. I wanna hear more about about that side of things. Instead, I wanna focus mostly on just giving you a demo of the tool that I've been working on. Before I dive straight into that, I just wanna talk a little bit about my approach. So like a lot of people that I've talked to in this community and an encouraging number of people in the sort of tech sphere in general, I've been really influenced by Elinor Ostrom and, in particular, her book, Governing the Con Commons. I mean, if you've read that book, you know that there's a bunch of different things she talks about, and all of them have been influential, but one that was particularly influential on this project is one of the sort of guidelines she gives for effective commons governance is the idea that the people who are impacted by rules should be the ones who are making those rules. And, you know, I've also seen that when I see, like, non tech governance, when I look at, you know, rules that are made from, like, a really centralized position on a company or a really centralized place in, you know, federal or state government and the way that it can break down when those have sort of local applications and the people who are feeling the effects of the rules have no way to sort of get their voice back there to to to change those rules. So that that importance of local context, was really fundamental to this design. It's also so different from how so many tech platforms and websites work. You know, at best, you've got, like, a really good user feedback, user research, and user research, and support system. Often, it's not a good system. It's pretty terrible. I was just thinking about this in the context of Google, which I've been using Google products for, like, fifteen years, and I've literally never gotten in person support or response at any point. Like, Google is just a giant wall, and I, a person who is being affected by Google through using it, just have, like there's just a complete cutoff between me and Google. But even in the case where you've got a really effective product management process, there's still all of those people in between the user and the tool. So there's the the user support person who's sort of collecting the data or the user researcher. There's the product manager, the product designer, the engineers, like, whoever is, like, the engineering manager, like, all of these steps and people in between the user and the product. So I thought, well, the specific thing I'm concerned about here is rules and access to permissions. What if I built something that surfaced those permissions so they were directly accessible and settable to individual users and groups of users? So that was the sort of, like, the core motivation behind designing this. And then the sort of second sort of really high level design element is that when I decided to start working on this, I had been experiencing governance project problems in a bunch of different domains. I have a background in the sciences, and I saw problems with maintaining meta analysis. I saw problems with open source communities, managing, you know, when a open source project is highly used and then suddenly you've got tons of users and very little, capacity in trying to figure out who was part of that community and who was not, in my work as an activist, trying to figure out who to trust with, access to accounts. And so I was seeing these problems across a bunch of different domains, and no one, like, mega website was gonna solve all of the problems. So I decided to instead make a library or a framework which could be used to build a bunch of different sites to attack the problems of individual domain specifically. So what I'm gonna show you is a specific website. It's the first website, built using, the tool. And so here's the name thing. So okay. I, again, somewhat arbitrarily have named the tool slash framework that I've been building Concord, and the first website I've named Kybern, and then Poisson is the umbrella term. I don't expect you to memorize any of these, but just those are the terms that I use. If anyone's, like, an expert on, like, successfully naming things so that people can effectively reference them, I would totally welcome your advice. But yeah. So when I say conquered, I mean the library that people can use to build multiple sites. When I say Kybernet, I mean, the specific first site that I built. And then when I say, I just mean all of it, everything. So with all of that out of the way, I wanna jump into doing a demo. So I'm going to attempt to screen share. Please someone let me know if I start getting choppy or anything. I've had run into some trouble with my computer just dying a little when I try to use him to screen share, so I'm hoping everything works out. So I will share my screen. So I'm gonna start us off with a preexisting group, and then we'll end up with creating our own group. But, for now, here is an existing group that I've created. It's themed around the US Women's National Soccer Team because I love the US Women's National Soccer Team. So they're all my fake users. They're members of the team. So every group has a governance structure, and the governance structure really rev revolves around the idea of roles. So there are some special roles that you the names are preserved and they can't be removed or deleted. They always exist. There's leadership roles, and we'll get to those in a minute. There's members, which just it's very simply anyone who's in the group is a member. And then you have an arbitrary number of, custom roles. So you can make a thousand roles if you want to. They all have to have unique names, but other than that, it can be whatever you want. And you can change the members in a role if you have permission to do so. Let me log in with switch over to I'm gonna switch over to someone who has permission to do that. So you can change the members in a role, add them, remove them, but more importantly, any role can be associated with permissions. So permission is basically the right to do something in a group, and there are a lot of there are a lot of different options, especially at the level of a role. You can also assign permissions for, like, a specific resource or object. In that case, you would only see in this drop down the permissions that apply to it. But at the level of a group, you can set basically any permissions. So there's a whole bunch of them when you look at them here. And so you have things permissions around interacting with certain objects. So for instance, if you wanna interact with a forum and have a post, that's one type of permission. But there's also a community level permission. So for instance, changing the ownership, changing the leadership, adding people to roles, removing people from roles, all of these things are themselves permissions that can be changed by the group. So let me grab something. So a lot of the permissions are just kind of what they say on the tin. In some cases, you can make them more or less specific. So in this case, I'm adding people to role. You can give people broadly the ability to add people to roles, or you can give them a more specific limit. So you can say, this permission gives you the ability to add people to a role and to specify the specific role. So you could do that, and then you could go ahead and you could do it again and give it for a different a different a different one. I mean, these are two different ones. They look the same because I have not perfected the plain English descriptions. Basically, this description is getting automatically generated from the data that's saved in that database about this permission, and I just haven't surfaced that configuration. But the distinction is there. If you open this, you can see that it's distinct to the first one I did, and this is distinct as well. The other thing that you can do with a permission is you can apply a condition to it. And the condition basically is just another step that a person has to go through in order to take whatever the action being said is. Right now, the only kind of conditions that exist are decision making conditions, so something where some additional person or number of people have to do something in order for the action to go forward. On my road map is doing some automatic conditions, like filter conditions, like saying, you can anyone can do this, but they have to have created their user account more than a week ago or less than a week ago. Basically, that sort of, like, automatic, thing. I also wanna make it possible to set compound conditions. Right now, you can only set one condition at a time. But on the road map is both expanding the type of conditions and also letting you handle multiple ones at once. So in this case, right now, the three types of conditions I've actually created are approval, vote, and consensus. And when you set them, you have to configure them. So, for instance, if you do the vote condition, there are some basic information about how long should the vote last, who gets who's allowed to vote, Do you want a majority or a plurality? If we add a condition that's for consensus, there's a strict versus loose mode, which is not well described here because I added this last week, and I have not finished making all the help text. Again, minimum amount of time for discussion, people who can participate, etcetera. And then approval, which is the simplest one, which is basically just who can approve. And then oftentimes, this is the default one that I think people would wanna use because it's pretty simple. You just give give someone else an opportunity to check and make sure that the action is good. Cool. So I'm not gonna I'm just gonna delete these because it turns out that arbitrarily adding permissions to a group can sometimes mess with the demo. So, yeah, let's take a look at some of the specific resources that you can have in a group. So I've just got two resources here. One is forum. So, like, it's a very bog standard forum. Like, it's a forum. You add a post. You can comment on the post, etcetera. There's also something called a list, and I'm gonna dive into that because that'll be the one I use as an example. But the idea is that if you can define a data structure and if you can define the ways that you want that data structure to be able to change, then you can create a resource that uses this governance governance system. So I just have these two right now, but I have a road map full of additional things that I wanna add. My idea is that there would be, like, a subset of resources that are just part of the core Concord library, like forums, lists. The next one I wanna do is policies, which is basically something you could use for, like, codes of conducts, bylaws, basically, anything that has a sort of ordered list structure so you can you can add sections, you can add bullet points, etcetera. And then that policy resource could itself be governed. So you can say, well, here are our bylaws, and you could even just as when you're writing your bylaws legally, you have to say how bylaws get changed. You can set permissions and conditions on that bylaw policy. And, obviously, it wouldn't have legal force, but you could accomplish the the changing of it and then, you know, give it to someone to be like, okay. File the new bylaws or whatever you wanna do. And, certainly, most things that you're trying to govern collectively are not don't have a legal equivalence. You don't have to worry about matching it to, like, the bylaws that are on record with the state or what have you. So in any case, our policies are one resource that I wanna work on. But this is really where the sort of different domains come into play. So if you're working on scientific meta analysis and you wanna be able to collectively maintain them, then the data structure for a meta analysis is gonna have a it's gonna be very particular to how meta analysis work and the idea that, like, okay. Well, in a meta analysis, you have, like, a list of potential studies, and then you filter them out based on criteria. So you need data structures for the criteria. You need data structures for the potential studies. You need a data structure to keep track of what has been found to be, like, a a has met your criteria and should be incorporated into the analysis, etcetera. Or if you're doing some kind of activism, there might be a data structure you want that's specific to the type of activism you're doing, so, like, a petition or whatever you have. So the idea is that there's some subset of these resources that have just come with the library so that AnySight can sort of, like, plug and play use them, but it's also very extensible so that if you're using the back end, the Concord library, to create something specific to your needs, you can wrap that into whatever resource you want. So I'm gonna go ahead and switch to a user that's got a different subset of permissions, and I'll create a list. So let's say you've got I'm gonna create a list for the best 11, which is just a term for or the best excise that it's a, like, a best of list, like, for the best 11 players you could put in any position. The way that this particular resource works, you can specify columns. So let's say and I specify that there's a player column and a position column, and both are required. I'll delete this default column, and then I scroll down and submit it. And now it exists because I had already prefigured this to give this user the permission to add lists. So taking a look at the list permission hold on. No demo. My user should have the ability to set a template.

this should be appearing. I'm not sure why it's not in here other than that it's not refreshed for some reason, but okay. Maybe now I can do this. Okay. Well, I don't know why this particular one isn't working, so I'm just gonna go back to the other user. This is one of the sort of challenges of one of the big challenges of this project is that by breaking down permissions into this, like, very fine grained way, I have found it quite a challenge to build all of those individual permissions back up to into bundles that make sense for people to use. And so that's, like, one of, if not the core design challenge still going forward. Forward. And you can see I've got these templates, and the templates are definitely helpful, but I don't think that they do enough to, to make things clear. So that's, like, definitely the the ongoing work that I've been doing is around trying to find ways of building the permissions up so that they're predictable and comprehensible. But they don't even they're not even know as comprehensible to me, and I built the thing. So, clearly, there's still a long way to go. So in any case, going back to this resource, you can set you can apply templates to a resource if and this basically lets you set a bunch of permissions at once. So for instance, in this case, this is a a template list resource, and, basically, it allows allows anyone who want to wants to be able to to add roles without needing approval, and then to edit or delete roles, or to edit the list itself, the creator of the list must approve. And the template details has auto generated text, which doesn't look great at the moment, but the idea is that you have, like, a human readable version. And then if anyone wants to double check that the thing they're applying does what they wanted to do, it also has, like, the very specific details of what's gonna be apply. So right now, the templates are not user creatable, but I wanna eventually make them user creatable. And in that case, you definitely wanna have some way for people to double check. So in a case, let me select the template. I'll apply it, and it creates the permissions and the conditions. And so now if I log in as the other user or just the other user, I can add a row, and I have the ability to do it. But if I try to edit it and say something else, then there's a condition. And you can go take a look at that condition, and it says I don't have the ability to approve or reject it, which makes sense because of that. The permission to approve or reject was sent to someone else. So if I go into that resource as the person who would have that permission, I can take a look at the list history. I can see this most recent decision to edit. Really? I knew there was gonna be a problem with this. I really wanna show you what a condition interaction looks like. Well, let me let me I I know I have a a GIF or a GIF, whatever you wanna call it somewhere. This is what I get from messing around with the code last night, is that it's not I've introduced errors somewhere. So let me just I think I have it in a blog post. Or, actually, I know I know where I have it. I have it in the documentation. There's a a a GIF of how it looks like, and I would like to show you what one of the condition interactions looks like. So if we go to here So this is how to add this is a document that shows you how to add conditions. So this is the sort of final version of the consensus condition. So this is exactly what I was gonna show you, but I'll just oh, it's it's a forum instead of a list. So here, the anyone with the role members is giving permission to being at a post, and then they're configuring or I'm configuring the condition to say, okay. People with the role starters and captains can participate in the discussion, but only captains can end the discussion, and I create that condition. So now anytime someone wants to add a post, it's gonna get that same screen the same screen as before with the little link to the condition, but now we should be actually be able to see what that interaction looks like. So this is the consensus condition, and it had a minimum date until two days are passed, so that's why the the screen is showing the screen is showing that functionality. We're gonna change the condition so that there's no minimum date so you can see it resolving as well. So instead of the minimum time being forty eight hours, minimum time is gonna be zero hours. So now when we log in to we log in to see it, we should be able to resolve it as well. So we'll have to take the action again to trigger the new condition. Once an action is taken, whatever the condition that was set on the permission, that's the one you have. So to to trigger it again, you would have to, to create a new so yeah. Is the condition say that again?

Right. So that's a that's a great question. So the way that the the consensus condition works right now is that you do not get to configure what the options are. It's always support, support with reservations, stand aside, block, and no response. Response. And then in strict mode, there can't be any no responses, and there can't be any blocks. And in loose mode, there can't be any blocks, but there can be no responses. And that's part of why there's a minimum duration because if you had a situation where you could have no responses, then someone could, like, end it really quickly without giving people a chance to respond, which you might want in some subset of cases, but mostly, you probably don't. But, like, this is, like, really clear with voting that a voting condition cannot possibly be summed up in a single condition type. There's just so many different ways that you can vote. And I think that's also true of consensus and a lot of other things. So I think that, like, as the project gets developed, they'll end up being multiple different types of consensus conditions that take certain things, to be assumed. And at what point you say this is a configuration of one single type of condition versus just make two different conditions that work in different ways. That's a little bit arbitrary and will kind of be seen by, like, what people are actually using this for. But yeah. So there's definitely a lot of assumptions built into the way that the consensus condition currently works. Some of it is just can be configured. Some of it will change to make it so it's configurable, but in some cases, it might make sense to just make a separate consensus condition and call it, like then you have to figure out what to call it, but so, like, the voting condition that exists is definitely gonna be changed to a specific type of voting, and then there might be, like Mhmm. Right. Depending on what the different voting is, they'll have different names. Oh, so let me just show you the last element, which is just creating a new creating a new group. So when you create a new group, you can start from scratch, which basically means that there's just, like, absolutely no specific permission set for you, but most people who wanna create a group are not gonna wanna do that. So you can also use a governance template. And I just have three of these here, but the idea is you can have an arbitrarily large number of them. So for instance, you can say, we're gonna have a system where there are voting members, and they're the owners of the community. And anyone who gets the voting member role becomes an owner of the community. But in order for them to do anything, they've gotta take a vote, and anyone to join the community. So then if you select that template you have to specify some fields around how voting was, Apply it to create your group and then when you go to the governance it's pre created for you. So you've got that members role there. If you look down at the net down here you can see that we've got the board members role with that that local member. And then just to quickly take show you the leadership, something I've sort of built into it at a fundamental level is a distinction between owners and governors. So the idea is that owners have fundamental power in the community. They can change whatever they want. And often, that means that you wanna put a condition on that power. So for instance, say, in order for the owners to do anything at all, they've gotta vote or come to consensus or whatever decision making process you decide. But practically speaking, that's a really tough way, especially to start up a community if you've got everyone who has to vote. So it also allows you to give trusted individuals a lot of default power in the community, but that default power doesn't apply to sort of basic things. Like, they can't delete the community. They can't change who the owners are. They can't change who the other governors are. So you're giving people power within the community, but the owners always have the ability to take that away. And so that's, like, a default governance structure that's sort of built in. It can change a little bit, but one of the things I realized when I was building this is that there has to be some sort of default system. Is Yeah.

Sorry. So I was gonna say, is there, like, a I wanna say a a naming convention or a way that you, like, make a distinction between that type of power and the sort of governance power? Because in in my experience, it's the difference between operations and governance. So in order for a community to operate, you need people with rights to do things that happen with higher frequency, maybe more like, hey, this is always done more or less in the same way, but it's different to context so people can, you know, operate, do stuff. And I I'm curious whether within the sort of, you know, ontology of this, whether you have a distinction between governing the community and the community just kinda doing what it does.

Ish. Yes. Ish. So I think there's more of a there's sort of there's a lot of things that some people might call community governance that I think fall into that operational care category, so things like, changing the membership of roles, giving people permissions to access certain things. Those are I would call I would definitely call them governance. I mean, I would call I would literally call all of it governance, but some people might say, oh, that should go in the on the governance side of things as opposed to the operational side of things. But I think that there's a there's a number of things that are about granting people permissions or specifying what roles people are in that are operational. So the core distinction that this that this ontology makes is between whether something is foundational or not. So whether it involves a specific subset of changes relating to, changing the leadership, or changing the powers of the leadership, or just delay.

They're higher impact and they tend to change on a slower pace. There's like a almost like frequency domain cutoff where things that are are are slow and have big consequences sort of have have the have one set of, you know, criteria, whereas the the conditions associated with the sort of higher frequency lower individual event impact things are not quite as tightly control.

Yeah. Exactly. So that is the end of my demo, and I'll totally start screen sharing again if I need to show you anything, but it's nice to be able to see all of your all spaces. So I stopped screen sharing for now.

Yeah. Go ahead.

I'm not entirely sure what your question is. I thought you were starting to talk about templates, but now but when you finished, it didn't sound like that's what you're asking.

So and this is you can go look in the code base and the documentation. I'm happy to, walk people through it in more depth later if they're interested. But the sort of basic, unit is something called, a state change, and the state change defines essentially what change of state that state change implements. So for instance, there's, like, an add people to role state change, and it just basically you give it people and a role, and it adds people to the role. And there's a bunch of there's a few different methods that are on that all state changes that allow it to be let's say, for instance, something to help it be surfaced to the user, something to help it create, like, a form field for the user to use, the actual implementation on the database side of things, and then the state change object, all actions in the system have a state change object, like, that just specifies what the action is actually doing, and then all permissions also have a state change object because it links basically, permissions have the roles or individuals assist that have the permission, and the change that they have the permission to take, plus, again, the thing that they're taking the permission on. So that's the sort of what's happening at the database level, but I'm happy to share the code with you, go through it in more depth because there's definitely a talk for hours about the details of how that is implemented.

line? Yeah. That's a great question, especially because this first site that I've built is essentially meant to show off the core library. So there's it's very hard to distinguish that from the core library because there's literally there's almost nothing else that's added by, the implementation other than a couple of things, which I'm eventually gonna fold back into the library, but I kept them separate because I just wanted to make sure that, like, the actual process of extending was working. So for instance, right now, the forums are actually in the implementation, because I wanted to just make sure that I could add the forums in the implementation and it would still all work. But I think forums are a good core resource to have. But the idea is that the core library will have the core library has a set of resources that not every project will use all of them, but the idea is that many projects will wanna use some of them. Like, many I think many projects would wanna just have forum capabilities, and probably policy capabilities too, and I think some sort of, like, structured data. So, right now, there's this list thing. I personally am very intrigued by building the idea of, like, a a table, so, like, columns and rows, and there's a number of just things that I wanna crowdsource in a data structure and, like, a a table. So I wanna build the table thing so I can start, like, actually working on this project. It's, like, several years later. But then if you wanna build a site so maybe you literally just wanna build the same site, but you wanna host it, or maybe you wanna have, like, certain amount of branding. Like, maybe way, way down the line, there'll be, like, custom theming or whatever built into the core library, but that's, like, very much not a priority. But I could see someone being like, I wanna have a site just like this one, but I want it to be themed like me, and have some, like, additional pages that are specific to my project or whatever. So they might actually implement virtually no more resources, no more stage changes, etcetera. They would just, like, override some of the default templates to add some pages and change the colors of the fonts or whatever.

But if you had, like if you were doing something much more complex, you could create resources specific to your to, like, journalism or science or whatever specific domain you're trying to build out. And and

Yeah. So there is a plug in architecture. So, right now, if they wanted to do quadratic voting, that would be a condition. The condition system is in flux. I'm still trying to work through how to get get all the functionality that I want in it, but for now, let's just say it's a condition. They can do two things. Probably the first thing they would do is they would implement it locally. So they can just add another condition, and the system is set up to look for all things that descend from condition model. It has to be within, like it can't be, like, nested in, like, you know, 12 folders deep. But if you put it in your and this is just I've been mentioning this, but this is built on Django. So if you put it in your Django app, and it descends from condition model, which you can just import from the core library, then, it'll be found automatically and surfaced to the user. So probably what a person or a development team would do is they would make that quadratic voting condition. They would test it locally. They would make sure they liked it, and then they would go back to the core library and say, hey. We've got this thing. Would you like it to be part of the core library? And we would probably be, like, yes. Of course, we want it as part of the library, and we would literally just move it into the core library. And then if we said no, they would still be able to use it locally. I mean, and they might just start with the core library if they weren't in a rush to use it, because I imagine it'd be quicker for to do it locally, then they'll go do the community vetting and process. But you could also just, like, open an issue to start working on and then the community could start at the core. But there's always the option to customize.

What's the prospect of, like, some sort of API and tools to wrap other functionality? Since it's Python, I mean, in theory, you could just have a a functional archetype and that that would wrap an arbitrary set of rules then, you know, I could write my rules and then presuming that you because this is a Python based system, I could imagine just saying, you have a meta rule and you say if you can fit your rule into this class, then you would be able to support it.

Yeah. So I've thought a lot about this, but I haven't done any work to start actually building it. But, but I think this is an answer to your question, but let me know if it's not. But I've been thinking a lot about, exposing the back end, like you said, through an API where essentially so the way that the state changes work in the system if you're building with the library, the state changes actually interact with the database. So the last every every state change has an implement method, and the implement method is the only place in the system, barring any sort of, like, additional extraneous stuff where you can actually make changes to state. So you can't add a you can't change the roles of community unless it's in a state change. I mean, a a developer could patch around that, but, like, the system tries to enforce only making stages in those implement methods.

Actually so what I was gonna ask and maybe we can take it offline at some point is, like, how you've interrelated the the state which, you know, is basically your database state and the set of admissible actions that that are available which are conditioned on the role that you have in a variety of other things, like, this fits into, like, a pretty general formal framework that I've been working on with a researcher in Belgium and I I I asked the question because that formalism of a generic legal state change as a function of the states, which is determined by the permissions the actor has, is actually a pretty re actually, it's an extremely generic form. So insofar as you sort of recognize the the form, I suspect implementing something that would allow people to define their own without breaking your software's code structure is probably not that hard. But we can chat about it offline if you want. And I'll show you the the mathematical formalisms that back up the software formalism, which says, suppose the system is in a certain state, then conditioned on your role, you have a set of admissible actions and if you take those admissible actions, they mutate the state to a new state, but you can actually define it very locally like that. So it's really just state transitions plus permissioning, but in a sufficiently generalized form that it should be pretty implementable.

Yeah. You know, that sounds really interesting. I'm happy to follow-up with you later. Just to finish my thought, because I think we were Sorry. No. Talk about slightly different things. So the the thought I had was to offer up an API that basically says you decide how a permission or a state change actually gets implemented. But you can have this you can still access the rules that keeping track of rules, governance, permissions, conditions, all of those things. It's just that instead of the system implementing a change for you, it just keeps track of the name of the change. So that would require this would give people more freedom to not like, you wouldn't have to you wouldn't even have to work in Python as long as you were able to interact with that Python. I mean, and if it was working through an API, you could have, like, a little Yeah. Chrome server posting up the API, and we'll just track your roles, individuals, permissions, conditions, and then the state of all those things. But then the actual state changes, you could just be like, I'm gonna name it this random thing, and the system would track it for you. And it wouldn't say it wouldn't implement it for you. It would just say it would come back with basically, like, a yes, no, or wait on whether you whether a given user could do a given job.

Your code's only job is to tell to determine whether or not that was okay. Their code could work however it wanted.

Right. So that seems like a pretty logical extension of what I built. So that's also on the road map, but it's not right away on the road map. So there's definitely, like, a lot of time to think about how the best way for that to be implemented. But I definitely would like this to be available to more people than just people who happen to already be programming with Python and Django, which is currently kind of how it works. Like, it just uses those packages. So to to work with them for now, you have to be programming.

My my general argument for why building things like this and and anything that actually can people are building in the governance space makes sense to use. I I I'm a huge proponent of Python is precisely because of the large scale open source community and modularity. So the idea that you could just keep growing up people building the quadratic voting or the whatever or the whatever. And that once someone built it as long as they published it, that you people would just be able to keep, like, oh, I want that one and import it without blowing up your package, without blowing up you know, this like, it already I I'm a really big fan of the way that the Python ecosystem has grown as a it's a very polycentric develop, like, very large scale comprehensive tool base. So

I had

Yeah. And, I mean, that's I think both of us have been sort of wrestling with how you surface as much control as possible to users while still protecting the fundamental integrity of the system. Like, obviously, you don't wanna just be like, here like, here's a string. Write whatever code you want, and we'll just execute it on the server. Like, that's terrible. We wouldn't do that. But figuring out where to draw those boundaries. So right now, in order to add a condition, not only do you have to change the code base, like, to change the core library, you have to go through a sort of entirely separate governance system where you there's, like, code review and people test out your thing. So right now, like, there's a lot of, what's sort of looking for? Quality control, for lack of a better term, or governance control over the content of a condition. What you're doing, by trying to surface, a code editor for people to work with, potentially, and I'm sure you've thought about this a lot, like, potentially exposes potentially exposes problems depending on how that code is parsed and implemented on the back end. So I don't know how your code editor works, but, like, yeah, I think that I think that we both wrestled with the question of how to, surface as much as much power to the user as possible and the much as much flexibility to the user as possible, while still recognizing there need to be some limits, and we've drawn those limits in slightly different places.

I think the way that I applied it really separates out those the group's users and developers because if you want like, if someone wants to make a change that's not available in the platform, they can come in and change the core library or change the implementation that they're working in, which is, like, a very, very large skills request for somebody who wants to make that change. Whereas the way you've got it set up, someone who has this sort of developer capacity to create a condition, they don't have to do any of that. They can just do it locally in the code editor. And I think but that also does assume that that user, whoever it is that wants to make the change, either knows how to code in the way that your code editor requires. Although, I imagine in the longer term, you could do something that's kind of like, Scratch or some other, like, very visual code editor that allows people to create conditions in a way that doesn't not just writing code, and you're making you're you can generate code from the sort of movement of the blocks or whatever sort of visual thing you're using. So so, yeah, I think, I mean, I think we just sort of, like when we recognize the same problem, we went about it in separate ways, which actually, I'm really glad that we went around it separate ways because now we get to see how both of the ways turn out. And maybe at some point, either you or I will be or our communities will be like, wow. That other way was definitely better. Like, how do we change course to to go in that direction? But yeah. Do you

Yeah. Definitely. I think I would love to have I think the sort of earlier version is, like, a a library in the repo. I would love to, in the longer term, be able to let people create and submit conditions as users on the front end. Like, I kind of think about both of our projects as once we all get all of the resources we need and all the people involved and, like, can just do whatever we want because just got so much time and resources Mhmm. That we would actually end up converging in somewhat of a similar place. Because I think your the way you've got it, the way your policy kit is designed, like, there's no reason that there can't be a code editor for mine or that you can't wouldn't be able to have, like, a more a less code focused more, like, visual interactions, and it doesn't require code to create, in yours. It's just, like, we prioritize different things and different approaches going forward.

Yeah. That would be

I'd be very excited to work on that with you.

So I I the code is on GitHub. And as I show I think I briefly showed you when I was searching to get the the GIF or GIF or whatever you call it, as a backup when my permissions didn't work. I do have documentation, and in particular, there's three documents that I made over the last month called how to build a resource, how to build a template, and how to build a condition. And literally no one besides me has ever followed them before, so I if you try them, I am sure you will run into problems, but I'll be right here. You can always email me and be, this instruction doesn't make any sense or it didn't work. So you can totally like, if someone is like, hey. I want a condition that does this. Like, you can try to follow the doc to create and, you know, submit the condition. You can try to build an implementation using Concord as a back end. Although, please talk to me before you do that because right now, a lot of the stuff that belongs in Concord is still currently in the Kybernet repository. I just haven't refactored it to go into Concord yet. Yes. Mhmm. And then probably the easiest way to get started is with the templates because building a condition or building a resource takes me with all of my experience using this very specific system, it takes me about a day or two to add a condition, like, all of the things from, like, the back end and the front end and, like, close to a week to add our resources. I mean, half of that time is spelled is done, like, adding tests and stuff, but it's still it's still like, it's an investment of time. Makes sense. And I wanna make it easier, but it's still in the early stages. So a lot of the sort of efficiencies are not there yet. Although, I would very much welcome people doing it, and I'm happy to give you whatever, like, level of mentorship you need in order to actually do the complicated thing. But the templates are much simpler. It takes me about it can take me as little as ten or fifteen minutes to add a template, longer if it's more complex. So adding a template is like, you know, like, I wanna see if I can make this idea for how to govern a community and make it into a default governance template that people can pick from when they're creating their community at first. Like, that's something that theoretically should take, like, under an hour. So it's probably the easiest first step. But, yeah, very eager to have folks try things out.

Donna. Yeah. Right? See you