Integrate GAnarchy

could you integrate GAnarchy into the forgefed thing? that way there would be more incentive for projects to give up their trademarks for forks of them, allowing us to bring death of the author to the free software world.

Could you maybe elaborate how ganarchy works?
It seems like it’s some kind of database that matches repos based on their root commit, did I understand that correctly?

At the moment forgefed for me is not about bringing death to authorship, for now removing the disadvantages it brings to not be on github is big enough. :smiley:

And to me forged right now is rather about the collaboration around a specific project instance across software-development-software instances.

Still feel free to make suggestions how to integrate it into forgefed; I’d say bringing it to forgefed is rather you “pushing” it in then us “pulling” it in, other topics are in focus right now (for me federated merge requests and everything that’s connected to that) and keep us busy.

I don’t feel like there’s a particular need to ignore other requests while focusing on a main thing.

Anyway, I see projects getting abandoned all the time, or going in user-hostile directions. Firefox is a good example of that, with the introduction of DRM and things.

GAnarchy is meant to offset that, through instance-based curation mechanisms.

(Side note: I still don’t understand why ForgeFed aims to duplicate the efforts of the VCS. I think it should just have bearer tokens/private keys and let the other end pull/push/merge as needed. This also allows supporting arbitrary VCSes as long as both ends support it. Maybe it’s nice to carry commit messages around as AP objects but it feels like wasted effort to me, and is gonna lead to more problems than it attempts to solve.)

Maybe it’s nice to carry commit messages around as AP objects but it feels like wasted effort to me, and is gonna lead to more problems than it attempts to solve.

Commits are carried around as JSON objects in existing forges. It’s not new; the ability to do that in ForgeFed would simply preserve a feature that exists in forges already, and make it easier to implement federation. Whether or not implementations will be relying on that data is a different question, which I’m exploring, but the starting point is to have the data available in a manner very similar to how it’s already being done in forges.

Anyway, I see projects getting abandoned all the time, or going in user-hostile directions. Firefox is a good example of that, with the introduction of DRM and things.

GAnarchy is meant to offset that, through instance-based curation mechanisms.

Can you please describe in which way GAnarchy would be taken into account in ForgeFed? I mean, which vocabulary and which behaviors would you want to have? Some example or user story would help me very much to understand.

Currently there are no user stories. As it turns out it’s really hard to get ppl to give a project up, even if that project is dead. (sometimes especially if that project is dead - e.g. if the author is dead.)

But simply put, GAnarchy has the concept of a “project commit”, which explicitly marks a project as welcoming of GAnarchy’s goals and ideals.

soni - the question was not asking about people who currently use
the software - the question was just asking you to describe
how it works

“user stories” are just design statements that the developer
writes, usually before the software is even written, in order
to describe the functionality and workflow, in terms of:

  • which sort of people would use it
  • why they would want to use it
  • how they would interact with it
  • what job it accomplishes or problem it solves,
    and how it does so

“user stories” typically have a form like:

  • GIVEN THAT (certain conditions are met)
  • AS A (person who is or does something peculiar)
  • IN ORDER TO (accomplish some specific goal)
  • WHEN I (do some specific thing)
  • THEN (some important event happens, or goal is met)

from the description you gave, that would be:

  • GIVEN THAT some source code repo is published
  • AS THE publisher of that repo
  • IN ORDER TO mark my project as
    welcoming of GAnarchy’s goals and ideals
  • WHEN I add a “project commit” to my repo
  • THEN the “project commit” will be publicly visible,
    indicating that my project is welcoming of GAnarchy’s
    goals and ideals

you can see the story alone, is incomplete - what may happen
next, that would make accomplishing the first step into something
useful? - there is usually at least one additional user story
(usually several), describing what happens afterward, given that
the some of the preceding stories are completed - such as:

  • GIVEN THAT someone other than myself has published a repo
    containing a “project commit”
  • AS A (different person than the publisher)
  • IN ORDER TO find projects that are
    welcoming of GAnarchy’s goals and ideals
  • WHEN I (do something … ???)
  • THEN (something else important happens … ???)

the “AS A …” should describe who else may be interested in that
“project commit” (in this example, maybe that is another dev who
would like to fork the repo, or it could be the operator of a
software spider, automatically searching for such repos on
behalf of others)

the “IN ORDER TO …” should describe why such a person would be
interested, what value it has to that person, or what special
job can be accomplished, with a repo that has a “project commit”,
which could not be accomplished with another repo which does not
contain a “project commit”, but does contain the identical
source code (in this example, the interest is only to find one -
presumably, a following story would describe why finding one is
useful; because that is obviously missing in this example)

the “WHEN I do …” in that example should describe what that
person must do in order to make use of it (in this example, that
use is only how to find it)

then there would probably be another story following that one,
describing what that person may do with the “project commit”
after one is found, and why that person would want to do so, and
which useful job that would accomplish or which problem it would

you can look at these user stories that describe how forge-fed
should work for more examples

given that a project uses ganarchy, as an user of that project, in order to find alternatives to the build I’m using, when I look the project commit up, then I see a list of forks of that project curated by an instance admin.

What exactly is the project commit, what info does it contain and in what sort of encodiing/representation?

How do you look up the project commit?

How does the curation process happen, and why does it require the project commit? (what’s the difference between that, and a markdown file listing some repo URLs)

a project commit is basically just a commit that starts with [Project]. there’s nothing really special about it. but this is what allows it to (semi-)automatically federate.

the curation process is literally editing the configs to add/remove repos where desired.

I could just ignore project commits entirely but 1. that wouldn’t federate nicely and 2. project commits allow authors to opt-in/consent to ganarchy’s thing. if I take that mechanism out, I’m not allowed to use the project’s actual name like I do on the webpage above.

What sort of federation gets done? How would you suggest to use ForgeFed for this?

ganarchy federation is part of the curation process - you, as an admin, stick another instance’s config.toml in your config.toml, and ganarchy will fetch their (published) config.toml for you and include repos and projects from it. it’ll also publish your “effective” config.toml (combined local config.toml + remote sources).

i still dont quite understand how this is related to forges,
or how forge-fed could handle it - from the explanation, it is
something that the ganarchy server does, based on things that
people do manually, using their VCS software; things that forges
can not do nor have any knowledge of

to answer “how could forge-fed handle this?”, is the same
as: “how would a forge handle the same information or actions?”

  • if the only data is a git commit, and the only user
    interaction is to add that git commit; then to the forge, it
    is just another commit like any other - the forge has no way
    to detect that commit as having some special significance or to
    represent it as something distinct from any other commit message
  • which means that forge-fed be able to do anything special
    with it either

the forge-fed protocol is not going to collect or process any
information itself - it is only a communications protocol,
transmitting information about things that forges need to do,
and notifying others about things that the forge did - forge-fed
will not know anything about the contents of any git repo;
because forges do not know anything about the contents of any
git repo

it would be different if some forge had a database entry like
‘ganarchy-status’; then there could be forge-fed messages like
‘set-ganarchy-status’ and ‘get-ganarchy-status’ - otherwise, if
that information is only in the form of a git commit, then
neither forge-fed nor the forge would have direct access to it,
and no way to store it, or represent it’s special meaning

the closest thing i can imagine would be a forge-fed message for
‘list-all-changes’; but even with that feature, the forge-fed
protocol would have no way to recognize the special commit or to
represent it in a meaningful way - it would only be passing the
data through to the requestor, unmodified and unfiltered - the
requesting client would need to process the data and detect the
interesting commit


I’m thinking, at the least, forge-fed could have messages for ganarchy project commits, and broadcast them around. as well as there could be a search function for those project commits that ganarchy could use.

ideally with ganarchy the plan is to support activitypub-based issues through tags like #gan385e734a52e13949a7a5c71827f6de920dbfea43, allowing mastodon users to post and comment on issues and feature requests. only the OP would need to have the tag tho and there would be no “close” mechanism (but there should be a way to refer to the issues somehow, so that you can use the issue tracker to find a repo that suits your needs). maybe forgefed can help me here tho?

i suppose you could setup an issue tracker based on activity-pub
and use forge-fed for that - i dont thnk any exists though - you
would probably need to write it

the first things you mentioned are probably not possible though

  • that is what i tried to explain in my previous post
    in theory, forge-fed could have “messages for ganarchy project
    commits”; but in reality they would just be “commits” - even if
    forge-fed identified them as something special, no existing
    forge would recognize of it - it would not be possible to
    search for them unless the forge can recognize it’s special
    significance, and have a feature for searching for them

forge-fed will not “broadcast them around”; because it would
not do anything on its own - the only things that can be
broadcasted, are events that happen on the forge - it is the
forge that initiates all broadcast messages - if the forge could
recognize the special significance of an incoming ganarchy
commit, then it could broadcast that event on the forge-fed
channel - otherwise, it will just look like any other ordinary
commit, even if forge-fed labeled it as special, the forge would
still need to be interested in recognizing it as special, and do
something special with it

it is interesting BTW, that ppl are thinking of things that
forge-fed could do, that forges do not do

1 Like

@SoniEx2, I think we need a more detailed verbal description of the exact software behavior you’d like to support.

Btw remember ForgeFed isn’t about any specific software, so the best way to describe things is to use generic terms like “instance”, " repo" and “fork” and so on, decoupling specific implementation detail from the general concept. However, a more detailed description of what ganarchy does and how it could benefit from ForgeFed would be a good starting point. I still don’t really understand :stuck_out_tongue:

What does it mean it “includes repos and projects” from some config file? Can you please describe the exact logic flow that occurs there, the exact process? An example would be helpful too.


combine with:

to make:

(configured by because I didn’t have that integrated into GAnarchy at the time, and am still in the process of implementing it “properly” tbh.)