United Software Development: A new paradigm #1
(Copied from the Fediverse Futures post on Lemmy that led to creation of the Social Coding org)
Exploration of the idea involves looking from a non-technical perspective at all the possible ways in which Decentralization and fediverse standards (ActivityStreams, ActivityPub, Linked Data) can be leveraged to shape this paradigm.
Preliminary definition of United Sotware Development is “Free, libre software development, processes and culture united,. Sustainable, open and accessible to anyone.”, but I'm sure that can be further improved.
Loïc Dachary offers a very enticing look into what "Federated Development" might entail. I highly encourage people to read the SocialHub thread, and am very curious about your musings and thoughts.
Why not look at how free software is currently developed, to define what a United Software Development paradigm might look like?
The traditional free software development process can be divided into three parts:
- Somebody creates a project. They set the rules, goals, roadmap, development pace, forge, organization, etc.
- With luck the project gets to a release. Then some users might adopt the project and maybe somebody decides to collaborate on the project.
- If the project is successful, it's adopted by many more users and gains a developer community.
This process has several problems first amongst which is the reliance on the individual, that started this whole project.
In order to reach step 3, at which point the project could maybe survive without them, this individual has to be able to develop the project, document the project, provide Q&A, collaborate with other developers, provide potential up front costs (server costs, etc.). And all that without earning a penny for their work in most cases.
And after step 3, this individual might not be quite as relevant to the project as it used to be, but it is often still vested with an enormous burden and authority over a project (the title "Benevolent Dictator for Life" describes this situation quite well).
Thereby it is no wonder, that free software is struggling: It's development has to overcome extreme burdens, that have nothing to do with the quality of the project and it's idea, before reaching adoption and a developer community.
This makes starting a new free software project extremely unattractive for developers committed to free software. And those that do decide to start a new project often waste their energy, time and other resources developing projects, that fail at one of the hurdles described above. Making their efforts futile.
Thus I understand the United Software Development paradigm as an answer to this current situation, creating a path for developers to create new free software that is successful based on the merits of the project and not the ability of it's founder.
But in order for this to be achieved, the United Software Development paradigm has to include not just the actual development of the software, beginning with the creation of a repository, code and corresponding to step one in the traditional free software development paradigm.
It has to begin before that and give people the ability to find a group, an idea, and a basic organization together and to create a software from the beginning as a team effort and gain team members along the way.
The modern forges have become centers for open source software, but they do not provide developers with a way to connect, find like minded people, ideas and develop projects from these ideas as a team, because forges today (especially GitHub) are suited to the needs of big tech companies benefiting from the voluntary work done by open source developers.
Free software can only survive if free software developers can develop their own projects in a cost efficient manner and without being a Swiss army knife of a developer / designer / Q&A / security researcher / devops.
Yess!! A super follow-up to this brainstorm idea 💚
I've been interacting with Fedeproxy community, which is now called Forgefriends and came up with the idea of "Social Coding" which encompasses the entire process from earliest idea to mature and healthy software + communities. And ideally this process involves a broad range of people with all kinds of backgrounds and experiences, and lowering the barriers for them to participate as much as possible, and in any way they want and feel comfortable to while 'onboarding' them further.
Gitea is the first code forge that embraced the idea of forge federation and becoming part of the Fediverse. First steps have been made and this will progress next year. Hopefully with funding from NLnet via a NGI0 grant they applied for.
So in fact, they've become a true "forge friend". What we are hoping to achieve is to have Gitea team realize the absolutely "unique selling point" (USP) nature that offering federation support entails. It goes way beyond a mere technical capability that is added, and towards a vision on what "Social Coding" really means.
I agree fully with your take on this, and from your text there are countless points where Fediverse could facilitate these social processes in various different ways. It is very exciting. On fedi various apps are maturing Groups support now (including Lemmy) and a step further is solid Community support and facilitating Community Governance. That comes a long way into the direction of having FOSS initiatives be native citizens on the Fediverse that any fedizen can hop onto very easily.
And federated forges are just one part of this story. There's more and more FOSS hosting providers that supply infra and bundled services. And there are people interested in organizing dev circles that hop from project to project to program on it. For example @csddumi explaining in this toot:
"I'm trying such a new way of organizing #developers by gathering a group of young programmers, who work together on a project of our choice, instead of each of us working on our own projects."
Exploring the possibilities further is really uplifting exercise. This all goes beyond Microblogging into the thus far untapped potential of the Fediverse to enter new domains.
My post is incomplete though: I've defined problem that the united software development paradigm should set out to solve, but I didn't provide much information as to how that problem might be solved.
For that I suggest a new definition of the free software development process:
- An idea is had and published.
- The idea is made concrete.
- A group of developers finds themselves to work on the idea.
- The group writes the code.
- The group makes a release.
- The group's software gains adoption
- The community of users and the developer group grows.
At no point during this new process does the success of the
project depend on an individual. Indeed each step of this process could theoretically be done by a different person or persons.
Thus requiring a whole new definition of what a maintainer is, how they become one and forge software has to change accordingly.
And there should be software to support the first three steps of this process especially, software where you could publish ideas (1), make them concrete (2) and find developers to work on a project together (3). Federating this software and embedding it in Gitea or another federated forge would probably be the best approach.
Since Big tech cannot use this process really, since it includes giving away your ideas and not just your code to the commons.
Wholly on board again for this idea. Holistically addressing the whole process, including ideation and forming of the community that starts to tackle a particular idea. It need not even come off the ground into a streamlined project altogether. If a groups starts working on an idea, then leaves it by lack of interest or something, they will still have forwarded it and it is just waiting for the next person or group to add something to it. The whole idea of "dead projects" because the maintainer throws the towel in the ring can become smaller.
Maybe a little mental prototyping is in order:
A project based on the fediverse may be created, that:
- Allows any user to publish an "Idea" Object containing anything from a small word impulse to an entire whitepaper.
- That "Idea" Object can be extended to become a "Concrete" Object, containing more technical details.
- The "Concrete" Object is proposed to developers.
- Developers join a project. Meaning they want to work on the project. Creating a "Group" Object.
- Developers are given a public discussion room for internal discussion.
- Developers create a repository on a forge and select a maintainer from amongst their members. (Maybe by voting?)
- Development begins.
(Whenever I say Object, I mean an ActivityPub object)
Developers should be able to join and leave a project at any time.
And if they are a maintainer, the group should just be able to chose another developer from amongst their members.
(This can be risky, if a project is entirely abandoned and a malicious entity gains control of the project, at which point a "fork" of the project should be created - nobody with a link to the abandoned project should receive releases from that anymore.)
It may be easier to split this into two domains that can evolve separately: Ideation and Project Management.
Just some additional points to the ones you mentioned (obviously it should start minimal, but just brainstorming right now). Going further it may be an idea to diagram these domains, as that's a good way to slash details and focus on essential process.
- Anyone can create an Idea (e.g. in markdown format, and maybe deriving from an Idea template).
- An Idea may have a Category and Tags. E.g. category "Podcasting".
- Any fedizen can follow a Category and find new Ideas as toots in their timeline, containing Tags as hashtags.
- Any fedizen can comment / discuss the Idea, their comments become replies to the original toot.
- Might be possible to collectively edit/refine (parts of) the Idea text (might need revision checking, rollback by owner).
- People can navigate the UI, find all kinds of ideas based on the metrics collected for it.
- People state their interest to participate in a Project based on the idea, and what they can do for the project.
- Any Person can create a Project based on an Idea (an idea can have multiple projects).
When a project is created the Ideation still continues. The ideation process goes in parallel.
PS. Something along similar lines is the open-source-ideas GH repo.
- Project is the top-level object. It has association with the Idea. It has a Community (a group).
- The project creator becomes the Organizer and is responsible for bootstrapping the Community.
- People may Join or be Invited into the Community.
- The Community may have a Governance Policy (that sets CoC, ToS, voting scheme, doc templates, etc.).
- Community members may indicate their preferred Roles (e.g. UX Designer, Tester, Developer), maybe Availability too.
- For the more formal roles (those that come with privileges) there may be Votes.
- Ideally there's more than one person in an authoritative role (to tackle risk of maintainer abandoning).
- Maybe there could be a 'credentials vault' and a way to upvote trusted persons to a Role where they can manage it.
PS. I've witnessed some nasty examples of a maintainer disappearing and not even willing to update the README to point to the newly active fork where stuff continues.
PS2. There may also be a 3-domain split, where you have Community Governance and Project Management separately.
Those are great ideas. I'll try to minimize these into minimum viable product requirements based on the three domain split:
A service which allows the sharing, discussion and concretize ideas.
It should achieve these minimum features:
- To create ideas as ActivityPub Objects containing text, tags, and a reference to an Idea it's based on (if any).
- To discuss Idea Objects in the Fediverse.
- To gather the discussion in an easy to view UI.
- The change of Idea Objects should be possible for the author of the Idea.
- Any user should be able to create a new Idea based on an existing Idea Object.
- To generate a feed for users to find new Idea Objects.
A service closely working together with the Ideation and project management service.
It should achieve these minimum features:
- The creation of a developer community Object (group) based on an Idea.
- Users to join and leave a community.
- Users to assign themselves roles, describing their abilities and resources they can provide to the project.
- Users to vote for a maintainer of the project and communicate this with the project management service.
- Users to discuss the project on the Fediverse.
A forge that hosts the repositories of a project and allows for the Community to change the access levels of developers (Maintainers, Contributors, etc.).
It should achieve these minimum features:
- To create repositories for a community.
- The features of forge (issue trackers, contributions, etc.)
- To change access levels based on the Community Governance.
I decided for this three division, because Project Management can be seen as a Forge with some additional features (maybe implemented with just a plugin or bot) and the focus of development should lie on Community Governance and Ideation, the new and unique services.
I only include those requirements here, which I think can be reasonably implemented in a first release and nothing more.
Wonderful! Just going to add some remarks / thoughts.. we might call this the "Social Coding MVP" and when spinning up an app, it is a "social coding platform".
Ideation --> Idea Management
- "Idea Management" appears to be a more common domain name.
- Federation between social coding instances:
- Consider a
- Ideas should be spread far and wide, ideally federate between instances.
- A solarpunk "low-energy video editing" idea is interesting to vidartists, a "solar panel upcycle" idea is not.
- There may be need for a Topic as a separate concept. It might be an
as:Groupon the wire.
- Instances receive all Topics from across the fedi, then admin subscribes to interesting ones.
- Only Ideas matching Subscribed Topics are tracked / stored in a particular instance.
- Consider a
- Federation across the broader fediverse:
- From any federated app, e.g. Mastodon, a fedizen can Follow a Topic and then get all topical Ideas in their timeline.
- This works somewhat similar to Gup.pe groups app.
- If I follow "Video Editing" on vidartists, I will also get Ideas in that topic that were created on solarpunk.
- I don't know if de-doubling is handled if I subscribe to the topic on multiple instances.
- Licensing of ideas
- Different instances may have different ideas on how Ideas and the comments to them are licensed.
- The license that applies is determined by the instance that the Idea / Comment was created on.
- If one replies from e.g. Mastodon, then the license of Idea is used. It should be indicated in the Topic Profile.
- We can create a diagram and derive our own vocabulary extension for our domain. Interesting prior work:
- There's an idea ontology specification to be inspired from.
- Diagram can be simple with just balloons and arrows (taken from this Innovation Domain paper).
- There's another, rather complete ontology: Generic Idea and Innovation Management Ontology (Gi2MO)
- I'd split this into two separate parts / concepts: Community + Policies
- Both of these concepts have way broader applicability than our use case, and we can standardize on their definition.
For a minimal Community vocabulary extension that facilitates having arbitrary 'Roles' I suggested modeling them as follows:
- There is the DOAP Ontology to describe projects (also posted to forgefriends).
- I guess that the Project Management features here should be mostly informational.
- Referencing repo's, tools that may exist anywhere. Insight into any relevant project info.
- Ensuring that privileges are properly guarded and to the interest of the community as a whole.
Something to add here in the end:
I'll use the term "Social Coding" from
here on out, because "United Software Development Paradigm" is to clumsy a term for my liking.
Yes, that is fine and it is the reason I came up with the term. It is both snappier and catchier. I see "Social Coding" as the concept that is addressed in this initiative, and "United Software Development" as the 'root domain' as it were, or a field even, where social coding takes place. Many other applications & tools (different projects) might be built over time to cover this field more thoroughly.
'Coding' doesn't encompass this full scope, even with 'social' in front of it, though "social coding" aims to bridge the gap that exists between pure dev teams and people otherwise involved or using the software. The gap that is often complained about by other fedizens as they call devs privileged, elitist or even fossbro's.
I would like to use Social Coding in common language, but still acknowledge the broader domain. The latter might be mentioned in design, domain analysis, etc.
Also a better term might be coined for it, like e.g. "Social Software Process" or "Social Software Development Methodology", "Social Software Development Lifecycle". But that requires a bit more thinking and elaboration, and isn't important now.
@CSDUMMI you said that some things were unclear in SocialCoding/discussion#1 (comment) .. I elaborated further in SocialCoding/discussion#3 (comment) but if you have questions, by all means fire away :D
No due date set.
No dependencies set.
Deleting a branch is permanent. Although the deleted branch may exist for a short time before cleaning up, in most cases it CANNOT be undone. Continue?