You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@cassandra.apache.org by Josh McKenzie <jm...@apache.org> on 2025/10/20 19:24:05 UTC

[DISCUSS] Understanding fork motivations (backport branch follow-up)

We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k

When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.

So: why are people running forks? Some reasons I've seen brought up:
 1. You need bespoke code to integrate with internal infrastructure
 2. You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
 3. Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
 4. You have stability concerns with GA releases or running a release based off trunk
The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.

If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.

I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.

~Josh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
> I can land fix/improvements to my internal fork faster than having it accepted/landed in the open-source, so I will land it locally and then upstream it

It’s likely that this is true for everyone, especially if we’re talking about larger changes. Unfortunately this particular path also means there’s a risk of divergence: a fix you land in open-source might be slightly different from your original version, maybe due to review feedback, or due to concurrent developments.

On Tue, Oct 21, 2025, at 3:20 AM, Jaydeep Chovatia wrote:
> I think there is one more more version for people to run their own fork, which is "I can land fix/improvements to my internal fork faster than having it accepted/landed in the open-source, so I will land it locally and then upstream it." Over the period of time, the maintenar will lose track of the upstream tickets because internally it got already landed/working. Eventually, the fork will end up with many more custom patches and then people are forced to continue with the private fork forever.
> 
> Jaydeep
> 
> On Mon, Oct 20, 2025 at 12:37 PM Jeff Jirsa <jj...@gmail.com> wrote:
>> There’s a variant of (1) I’ve seen at multiple past employers, which is “we have a problem right now and we’re not sure what the long term fix is, but we’re addressing it internally and may do something different long term in the public repo.” It’s not actually about bespoke integration, it’s more about nascent ideas that get tested and deployed and iterated on. For example, early TWCS started out as a DTCS patch that used an alternative timestamp in the sstable metadata with the old DTCS tiering logic before the approach changed into avoiding the tiering and using the existing timestamp. 
>> 
>> 
>> 
>> 
>> 
>>> On Oct 20, 2025, at 12:24 PM, Josh McKenzie <jm...@apache.org> wrote:
>>> 
>>> We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>>> 
>>> When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
>>> 
>>> So: why are people running forks? Some reasons I've seen brought up:
>>>  1. You need bespoke code to integrate with internal infrastructure
>>>  2. You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
>>>  3. Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
>>>  4. You have stability concerns with GA releases or running a release based off trunk
>>> The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
>>> 
>>> If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
>>> 
>>> I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
>>> 
>>> ~Josh
>>> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jaydeep Chovatia <ch...@gmail.com>.
I think there is one more more version for people to run their own fork,
which is "I can land fix/improvements to my internal fork faster than
having it accepted/landed in the open-source, so I will land it locally and
then upstream it." Over the period of time, the maintenar will lose track
of the upstream tickets because internally it got already landed/working.
Eventually, the fork will end up with many more custom patches and then
people are forced to continue with the private fork forever.

Jaydeep

On Mon, Oct 20, 2025 at 12:37 PM Jeff Jirsa <jj...@gmail.com> wrote:

> There’s a variant of (1) I’ve seen at multiple past employers, which is
> “we have a problem right now and we’re not sure what the long term fix is,
> but we’re addressing it internally and may do something different long term
> in the public repo.” It’s not actually about bespoke integration, it’s more
> about nascent ideas that get tested and deployed and iterated on. For
> example, early TWCS started out as a DTCS patch that used an alternative
> timestamp in the sstable metadata with the old DTCS tiering logic before
> the approach changed into avoiding the tiering and using the existing
> timestamp.
>
>
>
>
>
> On Oct 20, 2025, at 12:24 PM, Josh McKenzie <jm...@apache.org> wrote:
>
> We had a long conversation about the potential of piloting a supported
> backport release branch here:
> https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>
> When I tried to summarize the thread and identify next steps, one
> observation stood out: I think we did a good job establishing the shape
> of the challenge we'd like to address (people want to work on OSS, not
> maintain private forks), but I don't think we got to the root of why this
> challenge exists. If we take action now we run the risk of having the wrong
> solution to the right problem.
>
> So: why are people running forks? Some reasons I've seen brought up:
>
>    1. You need bespoke code to integrate with internal infrastructure
>    2. You've written a new feature targeting your internal version,
>    upstreamed the code, and have to wait for the feature to be in a GA release
>    3. Someone else has contributed a feature to trunk that's attractive
>    and it's less work or more palatable to back-port it to your private fork
>    and maintain the diff than to qualify a custom release off trunk
>    4. You have stability concerns with GA releases or running a release
>    based off trunk
>
> The backport branch we discussed in the previous thread would primarily
> address #4 (stability concerns) and secondarily #2 and #3 (feature
> availability). All four motivations could be addressed in other
> ways—ideally by reducing the pressure to fork in the first place, rather
> than accommodating forks as inevitable.
>
> If you're running a fork and open to sharing your experience, do these
> reasons match yours, or is something else at play? The more detail we can
> gather, the better we can target improvements where they'll actually help.
>
> I know these conversations take time and can be hard; I appreciate
> everyone taking the time and energy to help us collectively improve.
>
> ~Josh
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jeff Jirsa <jj...@gmail.com>.
There’s a variant of (1) I’ve seen at multiple past employers, which is “we have a problem right now and we’re not sure what the long term fix is, but we’re addressing it internally and may do something different long term in the public repo.” It’s not actually about bespoke integration, it’s more about nascent ideas that get tested and deployed and iterated on. For example, early TWCS started out as a DTCS patch that used an alternative timestamp in the sstable metadata with the old DTCS tiering logic before the approach changed into avoiding the tiering and using the existing timestamp. 





> On Oct 20, 2025, at 12:24 PM, Josh McKenzie <jm...@apache.org> wrote:
> 
> We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
> 
> When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
> 
> So: why are people running forks? Some reasons I've seen brought up:
> You need bespoke code to integrate with internal infrastructure
> You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
> Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
> You have stability concerns with GA releases or running a release based off trunk
> The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
> 
> If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
> 
> I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
> 
> ~Josh
> 


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
>  1. Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
Of course, it’s always possible to cherry-pick from open source without contributing back, but the whole point of a community is to engage, collaborate, and shape the project in ways no individual organization could.

When we had doubts about stability of 3.0 some years ago, we created in-jvm dtests to simplify writing tests, then iterated on fuzz tests, and found, reported, and fixed numerous issues. I wonder where we’d be today if we’d been skeptical about CASSANDRA-8099 and just backported what we needed into 2.1 instead of spending that time to harden and qualify the release. 

I’d encourage folks to engage and collaborate when possible. In the short term, individual organizations may occasionally need to backport fixes, but that should remain a temporary measure. The real solution is a community that can deliver provably stable releases on a collectively acceptable cadence.

On Mon, Oct 20, 2025, at 9:24 PM, Josh McKenzie wrote:
> We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
> 
> When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
> 
> So: why are people running forks? Some reasons I've seen brought up:
>  1. You need bespoke code to integrate with internal infrastructure
>  2. You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
>  3. Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
>  4. You have stability concerns with GA releases or running a release based off trunk
> The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
> 
> If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
> 
> I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
> 
> ~Josh
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Mick <mc...@apache.org>.
> Could you elaborate how back porting features from trunk to other branches incentivise adoption? So far from the conversation I got an impression that folks are asking for backports branch to avoid adopting trunk, stick to known set of moving parts, and save time by avoiding qualifying trunk.


If a backports branch, e.g. cassandra-5.1 was in leu of both trunk alpha releases and a releasable trunk, then a rebase to it from cassandra-5.0 is one step closer to trunk.  e.g. the work of rebasing and testing both jdk21 and cep-37* are done, and makes the next step to trunk (when it offers its first release) easier.   The more we break up the steps the easier it gets, IMO.   The balance here for the project is how do we do this in a way that balances the trade-off costs.

This is also in the context where with or without a backports branch forks are not qualifying trunk.  If we release trunk more often, if we put more effort into a releasable trunk, and/or make monthly/quarterly alpha releases off trunk,  and get people actually qualifying trunk that's obviously better (as Josh has already well illustrated).  And I do see the benefits of a releasable trunk to be numerously more (but it's also a lot more work to get there).

*) jdk21 and cep-37 in a backports cassandra-5.1 isn't the best example here, if we come to agreement that they can go into cassandra-5.0.   But they're used just as the theoretical example, you get my drift i hope.

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
> Both the ideas of a back port branch and monthly/quarterly alpha releases from trunk (which is a variant of the notion of releasable trunk) provide ways to bring forks closer to trunk.

I do see how frequent alpha releases make it easier to qualify and subsequently adopt trunk, and am fully in favour of cutting more frequent releases. Could you elaborate how back porting features from trunk to other branches incentivise adoption? So far from the conversation I got an impression that folks are asking for backports branch to avoid adopting trunk, stick to known set of moving parts, and save time by avoiding qualifying trunk.

On Sat, Oct 25, 2025, at 12:48 AM, Mick wrote:
> 
> 
> > On 24 Oct 2025, at 23:43, Jeremiah Jordan <je...@apache.org> wrote:
> > 
> > Or at the least letting our fork more closely follow trunk, rather than following a previous GA branch, with us only needing to put things in the fork that only make sense because of the DBaaS bits.
> 
> 
> Both the ideas of a back port branch and monthly/quarterly alpha releases from trunk (which is a variant of the notion of releasable trunk) provide ways to bring forks closer to trunk.    So a back port branch would in fact be useful to DataStax, but limited value compared to alpha releases off trunk and especially a releasable trunk.
> 
> One of my observations is the rebasing from one GA branch to the next has a cost and uncertainty that increases disproportionately the biggest the diff between those GA branches are.   Being able to rebase more often but in smaller more incremental steps would end up being less work and more predictable.  I would say the release early, release often mantra applies equally to forks as it does operators.

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Mick <mc...@apache.org>.

> On 24 Oct 2025, at 23:43, Jeremiah Jordan <je...@apache.org> wrote:
> 
> Or at the least letting our fork more closely follow trunk, rather than following a previous GA branch, with us only needing to put things in the fork that only make sense because of the DBaaS bits.


Both the ideas of a back port branch and monthly/quarterly alpha releases from trunk (which is a variant of the notion of releasable trunk) provide ways to bring forks closer to trunk.    So a back port branch would in fact be useful to DataStax, but limited value compared to alpha releases off trunk and especially a releasable trunk.

One of my observations is the rebasing from one GA branch to the next has a cost and uncertainty that increases disproportionately the biggest the diff between those GA branches are.   Being able to rebase more often but in smaller more incremental steps would end up being less work and more predictable.  I would say the release early, release often mantra applies equally to forks as it does operators.

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
> On the other hand the idea of moving the project towards always having a releasable trunk with no new things being enabled by default is intriguing to me, as that is something which could possible reduce our need to fork. 

I am very supportive of an idea of having trunk releasable. With our current arsenal of test tooling (in jvm dtests, targeted fuzzers, simulator, harry, ast test) we were able to gain confidence in both new features and features that were around but we didn’t have experience with. At least from my perspective there’s very little missing for us to release trunk more often. Is there anything we can change, from your perspective, to make it easier to release it more frequently?

On Fri, Oct 24, 2025, at 11:43 PM, Jeremiah Jordan wrote:
> To get back to the original goal of this thread: Understanding fork motivations.
> 
> At DataStax (an IBM Company) we are currently maintaining a long term fork for a few reasons.
> 
> We run a micro services based DBaaS that uses Apache Cassandra code as a library to implement different parts of the service.  To do this we have had to add different hooks, abstractions, interface points and some behavior changes to the code that do not make sense when running as the monolithic service that is Apache Cassandra.  So we maintain those in our fork.
> 
> Then the bigger reason for our fork, as a DBaaS we have a very different release cycle and maintenance burden from the main project.  We keep our main branch releasable, and release from main every few months.  Our main branch tracks an Apache Cassandra GA branch, with our features on top of it.  So we maintain a fork where we can put the new stuff we are working on for our next release (which will be within a couple months at most), while also contributing things upstream in parallel (where it may be a year or more before it releases).  How much we maintain in our fork goes up and down over time, as the Apache Cassandra project releases new GA versions we are able to bring those in and drop anything from our fork that we upstreamed during the previous cycle.  We will then accumulate new differences until the next Apache Cassandra GA happens and we bring that in.
> 
> So for DataStax I do not think a “back ports” branch would do much for us in terms of making it so we don’t need to maintain our own fork.  The things we put in our fork are not restricted to “stuff that doesn’t change how the DB works”.  We release from our main branch every few months, and all features worked on go there.
> 
> On the other hand the idea of moving the project towards always having a releasable trunk with no new things being enabled by default is intriguing to me, as that is something which could possible reduce our need to fork.  We could just always be releasing from trunk, with all our development work only happening on trunk, and not needing to be on our fork and also trunk in parallel.  Or at the least letting our fork more closely follow trunk, rather than following a previous GA branch, with us only needing to put things in the fork that only make sense because of the DBaaS bits.
> 
> -Jeremiah
> 
> 
> On Oct 20, 2025 at 2:24:05 PM, Josh McKenzie <jm...@apache.org> wrote:
>> 
>> We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>> 
>> When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
>> 
>> So: why are people running forks? Some reasons I've seen brought up:
>>  1. You need bespoke code to integrate with internal infrastructure
>>  2. You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
>>  3. Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
>>  4. You have stability concerns with GA releases or running a release based off trunk
>> The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
>> 
>> If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
>> 
>> I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
>> 
>> ~Josh
>> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jeremiah Jordan <je...@apache.org>.
 To get back to the original goal of this thread: Understanding fork
motivations.

At DataStax (an IBM Company) we are currently maintaining a long term fork
for a few reasons.

We run a micro services based DBaaS that uses Apache Cassandra code as a
library to implement different parts of the service.  To do this we have
had to add different hooks, abstractions, interface points and some
behavior changes to the code that do not make sense when running as the
monolithic service that is Apache Cassandra.  So we maintain those in our
fork.

Then the bigger reason for our fork, as a DBaaS we have a very different
release cycle and maintenance burden from the main project.  We keep our
main branch releasable, and release from main every few months.  Our main
branch tracks an Apache Cassandra GA branch, with our features on top of
it.  So we maintain a fork where we can put the new stuff we are working on
for our next release (which will be within a couple months at most), while
also contributing things upstream in parallel (where it may be a year or
more before it releases).  How much we maintain in our fork goes up and
down over time, as the Apache Cassandra project releases new GA versions we
are able to bring those in and drop anything from our fork that we
upstreamed during the previous cycle.  We will then accumulate new
differences until the next Apache Cassandra GA happens and we bring that in.

So for DataStax I do not think a “back ports” branch would do much for us
in terms of making it so we don’t need to maintain our own fork.  The
things we put in our fork are not restricted to “stuff that doesn’t change
how the DB works”.  We release from our main branch every few months, and
all features worked on go there.

On the other hand the idea of moving the project towards always having a
releasable trunk with no new things being enabled by default is intriguing
to me, as that is something which could possible reduce our need to fork.
We could just always be releasing from trunk, with all our development work
only happening on trunk, and not needing to be on our fork and also trunk
in parallel.  Or at the least letting our fork more closely follow trunk,
rather than following a previous GA branch, with us only needing to put
things in the fork that only make sense because of the DBaaS bits.

-Jeremiah


On Oct 20, 2025 at 2:24:05 PM, Josh McKenzie <jm...@apache.org> wrote:

> We had a long conversation about the potential of piloting a supported
> backport release branch here:
> https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>
> When I tried to summarize the thread and identify next steps, one
> observation stood out: I think we did a good job establishing the shape
> of the challenge we'd like to address (people want to work on OSS, not
> maintain private forks), but I don't think we got to the root of why this
> challenge exists. If we take action now we run the risk of having the wrong
> solution to the right problem.
>
> So: why are people running forks? Some reasons I've seen brought up:
>
>    1. You need bespoke code to integrate with internal infrastructure
>    2. You've written a new feature targeting your internal version,
>    upstreamed the code, and have to wait for the feature to be in a GA release
>    3. Someone else has contributed a feature to trunk that's attractive
>    and it's less work or more palatable to back-port it to your private fork
>    and maintain the diff than to qualify a custom release off trunk
>    4. You have stability concerns with GA releases or running a release
>    based off trunk
>
> The backport branch we discussed in the previous thread would primarily
> address #4 (stability concerns) and secondarily #2 and #3 (feature
> availability). All four motivations could be addressed in other
> ways—ideally by reducing the pressure to fork in the first place, rather
> than accommodating forks as inevitable.
>
> If you're running a fork and open to sharing your experience, do these
> reasons match yours, or is something else at play? The more detail we can
> gather, the better we can target improvements where they'll actually help.
>
> I know these conversations take time and can be hard; I appreciate
> everyone taking the time and energy to help us collectively improve.
>
> ~Josh
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
I should add to qualify: it was only a suggestion to keep a discussion on ML. If folks think it'll be more productive to talk things through, they're more than welcome to do this. I also should not have mentioned any "third-party" concerns, just mine.

On Fri, Oct 24, 2025, at 9:26 AM, Alex Petrov wrote:
> > I suggest we organize a call to discuss this. It might help with questions that everybody has. We can then bring it back to the dev list.
> 
> I think we should keep this discussion on the mailing list for visibility, even if the only reason is that organizing a meeting friendly to all timezones is rather difficult. I already heard concerns from multiple folks expressing an opinion that backport branch was all but decided in some meeting between interested parties, even if the result of this conversation was brought back to the mailing list.
> 
> > Could you elaborate on what makes you say that there is suggestion of a consensus?
> 
> I also had an impression of implication of consensus. I do not want to quote specifics to avoid lengthy discussion about this, but I'd like to reassure that Scott isn't the only one thinking this way.
> 
> > Is there any other cost related to retiring this pilot that you think I haven't accounted for?
> 
> There is a potential for lasting (even if reversible) damage to the community coming from disincentivizing folks from targeting trunk. 
> 
> 
> 
> I'll add that I strongly agree with what Stefan says: 
> 
> > I also think that cooperation in the broader community on your patch (or patches of others) is better.
> 
> This keeps focus on the community, and incentives engagement for a common goal, driving all of us forward, rather than spreading efforts in multiple directions. I'll re-iterate that "do everything that we can to be ready to deploy trunk" should remain our common goal.
> 
> 
> On Fri, Oct 24, 2025, at 7:09 AM, Dinesh Joshi wrote:
>> On Thu, Oct 23, 2025 at 5:49 PM Jon Haddad <jo...@rustyrazorblade.com> wrote:
>>> 
>>> I’m opposed to teams solving their technical debt issues by pushing more responsibility onto the project.  
>> 
>> There are no teams here. There is just the project and contributors. Official backports are not a new or novel concept in open source projects. Whatever is being discussed here needs to be sustainably supported by the project in the longterm.
>> 
>> We have volunteers who are willing to participate in backporting some features. The project needs to create a path forward for them to contribute. The concerns around sustainability, testing, support are valid and there are suggestions to mitigate those concerns. Assuming all goes well with the pilot, it will help grow the project. If it doesn't go well, it's not a big deal. This is not an irreversible decision – hence the suggestion for a limited time pilot.
>> 
>> Given that there has been a lot of interest in this conversation, I suggest we organize a call to discuss this. It might help with questions that everybody has. We can then bring it back to the dev list.
>> 
>> Thoughts?
>> 
>> Dinesh
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
> I suggest we organize a call to discuss this. It might help with questions that everybody has. We can then bring it back to the dev list.

I think we should keep this discussion on the mailing list for visibility, even if the only reason is that organizing a meeting friendly to all timezones is rather difficult. I already heard concerns from multiple folks expressing an opinion that backport branch was all but decided in some meeting between interested parties, even if the result of this conversation was brought back to the mailing list.

> Could you elaborate on what makes you say that there is suggestion of a consensus?

I also had an impression of implication of consensus. I do not want to quote specifics to avoid lengthy discussion about this, but I'd like to reassure that Scott isn't the only one thinking this way.

> Is there any other cost related to retiring this pilot that you think I haven't accounted for?

There is a potential for lasting (even if reversible) damage to the community coming from disincentivizing folks from targeting trunk. 



I'll add that I strongly agree with what Stefan says: 

> I also think that cooperation in the broader community on your patch (or patches of others) is better.

This keeps focus on the community, and incentives engagement for a common goal, driving all of us forward, rather than spreading efforts in multiple directions. I'll re-iterate that "do everything that we can to be ready to deploy trunk" should remain our common goal.


On Fri, Oct 24, 2025, at 7:09 AM, Dinesh Joshi wrote:
> On Thu, Oct 23, 2025 at 5:49 PM Jon Haddad <jo...@rustyrazorblade.com> wrote:
>> 
>> I’m opposed to teams solving their technical debt issues by pushing more responsibility onto the project.  
> 
> There are no teams here. There is just the project and contributors. Official backports are not a new or novel concept in open source projects. Whatever is being discussed here needs to be sustainably supported by the project in the longterm.
> 
> We have volunteers who are willing to participate in backporting some features. The project needs to create a path forward for them to contribute. The concerns around sustainability, testing, support are valid and there are suggestions to mitigate those concerns. Assuming all goes well with the pilot, it will help grow the project. If it doesn't go well, it's not a big deal. This is not an irreversible decision – hence the suggestion for a limited time pilot.
> 
> Given that there has been a lot of interest in this conversation, I suggest we organize a call to discuss this. It might help with questions that everybody has. We can then bring it back to the dev list.
> 
> Thoughts?
> 
> Dinesh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Dinesh Joshi <dj...@apache.org>.
On Fri, Oct 24, 2025 at 8:39 AM Alex Petrov <al...@coffeenco.de> wrote:

>
> I took part in multiple 6.0 features, and after reading "that is why
> everyone will be on 5.0/5.1 for years", I thought it is important to reach
> out and understand what I can do to improve 6.0 adoption and convince folks
> in its stability and quality.
>

I'd like to address this specific example while trying not to derail this
thread. I agree with Alex and I was personally disappointed with this
interaction on the dev list. I'm sorry that it wasn't addressed in the
other thread. It is not fair to the authors who have worked hard on this
feature.

Features can and do have rough edges. It is important for us to engage
constructively in any conversations. If there are gaps, it is important to
file JIRAs or bring discussions with concrete, actionable feedback so that
the authors can work on it. Better yet, offer patches that the authors can
review. It doesn't necessarily imply that they will accept all suggestions
/ reports / patches as-is. They may act on the reports in consultation with
broader audience and stakeholders in the community. The social contract
exists on both ends - author and operator/users.

After this particular interaction on the dev list, Alex reached out to a
number of people who had concerns about TCM and collected their feedback.
This is going beyond my expectations.

Dinesh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Alex Petrov <al...@coffeenco.de>.
> suspicion, in-group out-group assumptions, and vitriol

I do not think this is fair to say this. I can reassure you that at least from my side there are no suspicions, theories, or assumptions, and for sure there is no vitriol. I always do my best to assume positive intentions when talking to folks over email. I think togetherness is extremely important in the community, and trying to do my best to encourage it.

I took part in multiple 6.0 features, and after reading "that is why everyone will be on 5.0/5.1 for years", I thought it is important to reach out and understand what I can do to improve 6.0 adoption and convince folks in its stability and quality. It was mentioned by both Chris and you that back ports were brought up on some call (likely same working session you mention). I was not present on this call, or even known that a call where contributors can talk about rolling out new versions, existed.  

The only reason for me to participate in this thread encouraging trunk stability and wanting to make 6.0 the best release, so I reached out to several folks who have expressed support for back port branches and got busy making documentation and some tooling etc., easier to discover. But to be honest after this discussion I feel a bit discouraged. 

Maybe it's worth re-iterating something I mentioned in my conversations/6.0 research here: if you think that there's not enough documentation, or some tool seems to be missing, reach out to the persons involved. Sometimes nothing is missing: it's just buried or misplaced. Sometimes it is missing, but without bad intent: all have busy schedules and are working on the "next" big thing.

Cheers,
--Alex


On Fri, Oct 24, 2025, at 3:41 PM, Josh McKenzie wrote:
>> I already heard concerns from multiple folks expressing an opinion that backport branch was all but decided in some meeting between interested parties, even if the result of this conversation was brought back to the mailing list.
> I want to take a moment to speak to this as I've had some very unpleasant and difficult direct conversations about this and continue to hear things 2nd and 3rd hand.
> 
> The "unofficial backport branch in public" was brought up and discussed at CoC in a room with 40+ people in it, many committers and PMC members, and I took an action item to follow up with the people who'd mentioned this shared pain to help them engage with the dev list. They're new contributors and didn't really know what the path looked like to constructively engage w/the community on the topic. I had no horse in that race other than I want to help people contribute and build skills around how to engage with the community.
> 
> There was a follow up general unstructured working session that some contributors have to share tips, learnings, insights into what they run into rolling out new versions, etc, and I still hadn't gotten around to that todo item to bring that to the list. So naturally that topic came up since it wasn't addressed yet, people brainstormed, came up with they thought might work, and next blocking step was to bring it to the list to see what the community thought.
> 
> Then it was brought to the list.
> 
> No secret back-channel dealings. No "all but decided". The topic came up during the cassandra track and while unfortunately not everyone could be at the conference in person, nobody at any point suggested anything was decided or that any governance would change. It was an idea that people wanted to do enough work to feel comfortable bringing it to the broader dev community, and then I helped them do so.
> 
> We need to be able to have discussions about ideas and proposals without the immediate reaction being suspicion, in-group out-group assumptions, and vitriol. People need to be able to brainstorm something and do enough work to test that their idea is solid enough to take up everyone else's time and attention with it. This is why we have the CEP process, to provide a path for people to explore technical ideas enough to then bring them to the community for consideration. The idea of a backport branch *was no different, *excepting it seems it's a topic that sparked a lot of emotion from various people on various sides and some less than professional engagement in the discussion.
> 
> This:
>> concerns from multiple folks expressing an opinion that backport branch was all but decided in some meeting between interested parties, even if the result of this conversation was brought back to the mailing list.
> Directly intersects with what Mick has said:
>> Just because you disagree please don't try to shut down the discussion–  please be more generous to the exploration.
>> 
>> For example, take this spin-off thread where Josh has tried to take a step back and further explore the problem statement, but still this thread gets hit with repeated objections from the original thread–  that's not very engaging or trusting of others' intent.  
> 
> And finally, the email I brought to the list about this topic was, I think, pretty clear it was just a proposal that was being opened for discussion:
>> The proposal we came up with: 
> and
>> If you’re interested in helping curate or maintain this branch - or have thoughts on the idea - please reply and voice your thoughts.
> 
> If you don't like the idea of a backport branch: I get it. I don't prefer it either; I've tried to make clear in this thread the solution I personally think better balances the needs of the community. But I'm trying to keep an open mind, and I think either the backport branch idea, looser backports to latest GA, looser or more frequent exercising of our backport mechanisms, or tightening up quality of trunk and cutting trunk alphas *are all better than the status quo of people wasting time and energy on redundant drudge work they'd rather be investing in the community*.
> 
> Hopefully the above does more good than harm; I don't think there's any villains here and I think everyone engaging on these threads genuinely wants the project to succeed and isn't actively trying to do that at anyone else's expense. We all need to work to explore how these ideas impact each others' workflows to try and figure out the best balance and compromise to move forward.
> 
> Thus ends my TED talk. =/
> 
> 
> On Fri, Oct 24, 2025, at 9:07 AM, Mick wrote:
>> 
>> 
>> > On 24 Oct 2025, at 11:44, Jeff Jirsa <jj...@gmail.com> wrote:
>> > 
>> > There’s dozens of voices of dissent at varying levels of intensity
>> 
>> 
>> 
>> Agree with Jeff here.
>> 
>> I have not seen any hint or pretension of a consensus in either thread.   It's appreciated that a certain level of energy and progression in a discussion can be conflated with consensus and seen as exclusive behaviour (everyone should be conscious and proactive against that). 
>> 
>> What I have seen is folk bringing forward an idea that addresses real problems, that is reversible in a pilot, a way to grow the dev community, and a typical thing to do in open source projects.  
>> 
>> IMHO, it has been by-and-large brought forward and carried out in an open-minded and explorative manner.  
>> 
>> Just because you disagree please don't try to shut down the discussion–  please be more generous to the exploration.
>> 
>> For example, take this spin-off thread where Josh has tried to take a step back and further explore the problem statement, but still this thread gets hit with repeated objections from the original thread–  that's not very engaging or trusting of others' intent.  
>> 
>> 
>> Scott, you make a statement that I both disagree with and feel might be critical to moving the discussion forward (or at least putting aside concerns to the original thread and allowing us to continue this one in better faith).
>> 
>> 
>> > There is a path forward for such backports to be contributed today, and it’s pretty well established. 
>> 
>> 
>> I find that statement risks polarises the discussion– if, like me, you can't see that practice alone addressing all the problems being raised in both threads.  I really do not wish to see certain features back ported into our stable GA branches.
>> 
>> Having said that, it is an entirely legitimate practice that solves many back port possibilities, and if we do agree that the current need for a back port branch remains only runtime jdk21 and cep-37, and we agree both can comfortably fit in that existing practice, then there is no need today for a back port branch and we can and should leave the discussion of creating such a back port branch open and ongoing, without urgency.
>> 
>> In this thread: that I hope we can seperate as it was intended; we should continue to seek input from those running forks, to better understand them and see what we could and might do to help them.  Josh also raised solid suggestions that had nothing to do with introducing a back port branch, let's not hijack that please.
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
> I already heard concerns from multiple folks expressing an opinion that backport branch was all but decided in some meeting between interested parties, even if the result of this conversation was brought back to the mailing list.
I want to take a moment to speak to this as I've had some very unpleasant and difficult direct conversations about this and continue to hear things 2nd and 3rd hand.

The "unofficial backport branch in public" was brought up and discussed at CoC in a room with 40+ people in it, many committers and PMC members, and I took an action item to follow up with the people who'd mentioned this shared pain to help them engage with the dev list. They're new contributors and didn't really know what the path looked like to constructively engage w/the community on the topic. I had no horse in that race other than I want to help people contribute and build skills around how to engage with the community.

There was a follow up general unstructured working session that some contributors have to share tips, learnings, insights into what they run into rolling out new versions, etc, and I still hadn't gotten around to that todo item to bring that to the list. So naturally that topic came up since it wasn't addressed yet, people brainstormed, came up with they thought might work, and next blocking step was to bring it to the list to see what the community thought.

Then it was brought to the list.

No secret back-channel dealings. No "all but decided". The topic came up during the cassandra track and while unfortunately not everyone could be at the conference in person, nobody at any point suggested anything was decided or that any governance would change. It was an idea that people wanted to do enough work to feel comfortable bringing it to the broader dev community, and then I helped them do so.

We need to be able to have discussions about ideas and proposals without the immediate reaction being suspicion, in-group out-group assumptions, and vitriol. People need to be able to brainstorm something and do enough work to test that their idea is solid enough to take up everyone else's time and attention with it. This is why we have the CEP process, to provide a path for people to explore technical ideas enough to then bring them to the community for consideration. The idea of a backport branch *was no different, *excepting it seems it's a topic that sparked a lot of emotion from various people on various sides and some less than professional engagement in the discussion.

This:
> concerns from multiple folks expressing an opinion that backport branch was all but decided in some meeting between interested parties, even if the result of this conversation was brought back to the mailing list.
Directly intersects with what Mick has said:
> Just because you disagree please don't try to shut down the discussion–  please be more generous to the exploration.
> 
> For example, take this spin-off thread where Josh has tried to take a step back and further explore the problem statement, but still this thread gets hit with repeated objections from the original thread–  that's not very engaging or trusting of others' intent.  

And finally, the email I brought to the list about this topic was, I think, pretty clear it was just a proposal that was being opened for discussion:
> The proposal we came up with: 
and
> If you’re interested in helping curate or maintain this branch - or have thoughts on the idea - please reply and voice your thoughts.

If you don't like the idea of a backport branch: I get it. I don't prefer it either; I've tried to make clear in this thread the solution I personally think better balances the needs of the community. But I'm trying to keep an open mind, and I think either the backport branch idea, looser backports to latest GA, looser or more frequent exercising of our backport mechanisms, or tightening up quality of trunk and cutting trunk alphas *are all better than the status quo of people wasting time and energy on redundant drudge work they'd rather be investing in the community*.

Hopefully the above does more good than harm; I don't think there's any villains here and I think everyone engaging on these threads genuinely wants the project to succeed and isn't actively trying to do that at anyone else's expense. We all need to work to explore how these ideas impact each others' workflows to try and figure out the best balance and compromise to move forward.

Thus ends my TED talk. =/


On Fri, Oct 24, 2025, at 9:07 AM, Mick wrote:
> 
> 
> > On 24 Oct 2025, at 11:44, Jeff Jirsa <jj...@gmail.com> wrote:
> > 
> > There’s dozens of voices of dissent at varying levels of intensity
> 
> 
> 
> Agree with Jeff here.
> 
> I have not seen any hint or pretension of a consensus in either thread.   It's appreciated that a certain level of energy and progression in a discussion can be conflated with consensus and seen as exclusive behaviour (everyone should be conscious and proactive against that). 
> 
> What I have seen is folk bringing forward an idea that addresses real problems, that is reversible in a pilot, a way to grow the dev community, and a typical thing to do in open source projects.  
> 
> IMHO, it has been by-and-large brought forward and carried out in an open-minded and explorative manner.  
> 
> Just because you disagree please don't try to shut down the discussion–  please be more generous to the exploration.
> 
> For example, take this spin-off thread where Josh has tried to take a step back and further explore the problem statement, but still this thread gets hit with repeated objections from the original thread–  that's not very engaging or trusting of others' intent.  
> 
> 
> Scott, you make a statement that I both disagree with and feel might be critical to moving the discussion forward (or at least putting aside concerns to the original thread and allowing us to continue this one in better faith).
> 
> 
> > There is a path forward for such backports to be contributed today, and it’s pretty well established. 
> 
> 
> I find that statement risks polarises the discussion– if, like me, you can't see that practice alone addressing all the problems being raised in both threads.  I really do not wish to see certain features back ported into our stable GA branches.
> 
> Having said that, it is an entirely legitimate practice that solves many back port possibilities, and if we do agree that the current need for a back port branch remains only runtime jdk21 and cep-37, and we agree both can comfortably fit in that existing practice, then there is no need today for a back port branch and we can and should leave the discussion of creating such a back port branch open and ongoing, without urgency.
> 
> In this thread: that I hope we can seperate as it was intended; we should continue to seek input from those running forks, to better understand them and see what we could and might do to help them.  Josh also raised solid suggestions that had nothing to do with introducing a back port branch, let's not hijack that please.

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Mick <mc...@apache.org>.

> On 24 Oct 2025, at 11:44, Jeff Jirsa <jj...@gmail.com> wrote:
> 
> There’s dozens of voices of dissent at varying levels of intensity



Agree with Jeff here.

I have not seen any hint or pretension of a consensus in either thread.   It's appreciated that a certain level of energy and progression in a discussion can be conflated with consensus and seen as exclusive behaviour (everyone should be conscious and proactive against that). 

What I have seen is folk bringing forward an idea that addresses real problems, that is reversible in a pilot, a way to grow the dev community, and a typical thing to do in open source projects.  

IMHO, it has been by-and-large brought forward and carried out in an open-minded and explorative manner.  

Just because you disagree please don't try to shut down the discussion–  please be more generous to the exploration.

For example, take this spin-off thread where Josh has tried to take a step back and further explore the problem statement, but still this thread gets hit with repeated objections from the original thread–  that's not very engaging or trusting of others' intent.  


Scott, you make a statement that I both disagree with and feel might be critical to moving the discussion forward (or at least putting aside concerns to the original thread and allowing us to continue this one in better faith).


> There is a path forward for such backports to be contributed today, and it’s pretty well established. 


I find that statement risks polarises the discussion– if, like me, you can't see that practice alone addressing all the problems being raised in both threads.  I really do not wish to see certain features back ported into our stable GA branches.

Having said that, it is an entirely legitimate practice that solves many back port possibilities, and if we do agree that the current need for a back port branch remains only runtime jdk21 and cep-37, and we agree both can comfortably fit in that existing practice, then there is no need today for a back port branch and we can and should leave the discussion of creating such a back port branch open and ongoing, without urgency.

In this thread: that I hope we can seperate as it was intended; we should continue to seek input from those running forks, to better understand them and see what we could and might do to help them.  Josh also raised solid suggestions that had nothing to do with introducing a back port branch, let's not hijack that please.

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jaydeep Chovatia <ch...@gmail.com>.
These two, in my view, are among the most fundamental aspects—an observation
shaped by my own experience and conversations with several operators.

  

These small cohort operators truly serve as our brand ambassadors. They often
absorb the pressure from their leaders and stakeholders while continuing to
advocate for Apache Cassandra. It’s important that we ease their challenges;
otherwise, over time, we risk losing their support—and that would be a
significant setback for the community as a whole.

  

Jaydeep

  

> On Oct 24, 2025, at 10:19 AM, Dinesh Joshi <dj...@apache.org> wrote:  
>  
>

> 
>
> Are there any features other than JDK21 and CEP-37 (auto repair) that we
> would like to backport?
>
>  
>
>
> Everybody is afraid of upgrading to the next major. Are there any concrete
> gaps that y'all see that need to be addressed other than the obvious one -
> upgrade testing?
>
>  
>
>
>  
>
>
> On Fri, Oct 24, 2025 at 9:53 AM Jaydeep Chovatia
> <[chovatia.jaydeep@gmail.com](mailto:chovatia.jaydeep@gmail.com)> wrote:  
>
>

>> Let me offer a different perspective by looking at this from the lens of
our day-to-day Cassandra operators — especially those who don’t have large
teams or deep internal investments (often just one or two people, which
represents the majority in the community).

>>

>> Today, many of these operators are successfully running  **Cassandra 4.1**
, but they frequently face some fundamental questions from their leadership or
stakeholders, such as:

>>

>>   1.  **“Why can’t we move to JDK 21? Everyone else in the company has
already moved off JDK 11.”**

>>

>>     * When can we move to JDK 21? → Likely with Cassandra 6.0, which may
still be a couple of years away.

>>

>>     * What prevents upgrading to Cassandra 6.0? → The release introduces
several changes that aren’t yet widely adopted or extensively tested for
upgrade/downgrade stability.

>>

>>     * As a result, operators often feel cautious, and this uncertainty can
unintentionally create a negative perception of Cassandra’s readiness and
modernization pace.

>>

>>   2.  **“Why does Cassandra occasionally lose or resurrect data that was
already written?”**

>>

>>     * Answer: “We need to run repair regularly to ensure data consistency.”

>>

>>     * Follow-up: “Why don’t we run it automatically?” → Because automated
repair is only available in Cassandra 6.0.

>>

>>     * Next question: “Then why not upgrade to 6.0?” → Same concern as above
— adoption risk and testing confidence.

>>

>>     * Again, this situation can lead to doubt about Cassandra’s
reliability, even though it’s fundamentally sound.

>>

>>   3.  **“Can we use new features like cross-shard transactions?”**

>>

>>     * Response: These are available only in Cassandra 6.0.

>>

>>     * This doesn’t create as much concern as the previous points, but it
still reinforces the perception gap between versions.

>>

>>

>>

>> In most cases, teams decide to remain on  **Cassandra 4.1** , but the
ongoing conversations around modernization and stability can gradually
**erode confidence in the Apache Cassandra brand** , especially when compared
with managed or cloud-native alternatives.

>>

>> For large operators with dedicated Cassandra teams, these challenges are
easier to manage — they can backport features or enhancements as needed. But
for the majority of smaller teams, that isn’t feasible.

>>

>> As a community, it’s important that we continue to  **strengthen
Cassandra’s reputation**  by ensuring that the fundamentals — reliability,
compatibility, and operational ease — remain first-class.  
> Whatever steps we can take to make Cassandra easier to run and evolve
> confidently, we should pursue together.
>>

>>  
>
>>

>> Jaydeep

>>

>>  
>
>>

>> On Fri, Oct 24, 2025 at 9:04 AM Dinesh Joshi
<[djoshi@apache.org](mailto:djoshi@apache.org)> wrote:  
>
>>

>>> On Fri, Oct 24, 2025 at 2:44 AM Jeff Jirsa
<[jjirsa@gmail.com](mailto:jjirsa@gmail.com)> wrote:  
>
>>>

>>>> The outcome of the first round of discussion was “ok there’s no agreement
to do this and there’s not even agreement about why people run forks or if
it’s good that they maintain forks”  
>
>>>

>>>  
>
>>>

>>> Well I guess we're talking about two different things here and it is
totally my fault. Let me clarify.

>>>

>>>  
>
>>>

>>> I am talking about the idea of backports. My general reading of both
threads is that we all agree to a varying degree that backports are valuable.
This is where I believe there is general agreement. If that is not the case,
please point it out and I will happily stand corrected.

>>>

>>>  
>>>

>>>> And then we’re back pushing for consensus.  
>  
>  There’s no consensus here to speed up.  
>
>>>

>>>  
>
>>>

>>> Maybe it is poor choice of words but my aim here was to help build shared
understanding of the problem so we can talk about possible paths to a
solution.

>>>

>>>  
>
>>>

>>> Dinesh

>>>

>>>  


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Dinesh Joshi <dj...@apache.org>.
Are there any features other than JDK21 and CEP-37 (auto repair) that we
would like to backport?

Everybody is afraid of upgrading to the next major. Are there any concrete
gaps that y'all see that need to be addressed other than the obvious one -
upgrade testing?


On Fri, Oct 24, 2025 at 9:53 AM Jaydeep Chovatia <ch...@gmail.com>
wrote:

> Let me offer a different perspective by looking at this from the lens of
> our day-to-day Cassandra operators — especially those who don’t have large
> teams or deep internal investments (often just one or two people, which
> represents the majority in the community).
>
> Today, many of these operators are successfully running *Cassandra 4.1*,
> but they frequently face some fundamental questions from their leadership
> or stakeholders, such as:
>
>    1.
>
>    *“Why can’t we move to JDK 21? Everyone else in the company has
>    already moved off JDK 11.”*
>    -
>
>       When can we move to JDK 21? → Likely with Cassandra 6.0, which may
>       still be a couple of years away.
>       -
>
>       What prevents upgrading to Cassandra 6.0? → The release introduces
>       several changes that aren’t yet widely adopted or extensively tested for
>       upgrade/downgrade stability.
>       -
>
>       As a result, operators often feel cautious, and this uncertainty
>       can unintentionally create a negative perception of Cassandra’s
>       readiness and modernization pace.
>       2.
>
>    *“Why does Cassandra occasionally lose or resurrect data that was
>    already written?”*
>    -
>
>       Answer: “We need to run repair regularly to ensure data
>       consistency.”
>       -
>
>       Follow-up: “Why don’t we run it automatically?” → Because automated
>       repair is only available in Cassandra 6.0.
>       -
>
>       Next question: “Then why not upgrade to 6.0?” → Same concern as
>       above — adoption risk and testing confidence.
>       -
>
>       Again, this situation can lead to doubt about Cassandra’s
>       reliability, even though it’s fundamentally sound.
>       3.
>
>    *“Can we use new features like cross-shard transactions?”*
>    -
>
>       Response: These are available only in Cassandra 6.0.
>       -
>
>       This doesn’t create as much concern as the previous points, but it
>       still reinforces the perception gap between versions.
>
> In most cases, teams decide to remain on *Cassandra 4.1*, but the ongoing
> conversations around modernization and stability can gradually *erode
> confidence in the Apache Cassandra brand*, especially when compared with
> managed or cloud-native alternatives.
>
> For large operators with dedicated Cassandra teams, these challenges are
> easier to manage — they can backport features or enhancements as needed.
> But for the majority of smaller teams, that isn’t feasible.
>
> As a community, it’s important that we continue to *strengthen
> Cassandra’s reputation* by ensuring that the fundamentals — reliability,
> compatibility, and operational ease — remain first-class.
> Whatever steps we can take to make Cassandra easier to run and evolve
> confidently, we should pursue together.
>
> Jaydeep
>
> On Fri, Oct 24, 2025 at 9:04 AM Dinesh Joshi <dj...@apache.org> wrote:
>
>> On Fri, Oct 24, 2025 at 2:44 AM Jeff Jirsa <jj...@gmail.com> wrote:
>>
>>> The outcome of the first round of discussion was “ok there’s no
>>> agreement to do this and there’s not even agreement about why people run
>>> forks or if it’s good that they maintain forks”
>>>
>>
>> Well I guess we're talking about two different things here and it is
>> totally my fault. Let me clarify.
>>
>> I am talking about the idea of backports. My general reading of both
>> threads is that we all agree to a varying degree that backports are
>> valuable. This is where I believe there is general agreement. If that is
>> not the case, please point it out and I will happily stand corrected.
>>
>>
>>> And then we’re back pushing for consensus.
>>>
>>> There’s no consensus here to speed up.
>>>
>>
>> Maybe it is poor choice of words but my aim here was to help build shared
>> understanding of the problem so we can talk about possible paths to a
>> solution.
>>
>> Dinesh
>>
>>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jaydeep Chovatia <ch...@gmail.com>.
Let me offer a different perspective by looking at this from the lens of
our day-to-day Cassandra operators — especially those who don’t have large
teams or deep internal investments (often just one or two people, which
represents the majority in the community).

Today, many of these operators are successfully running *Cassandra 4.1*,
but they frequently face some fundamental questions from their leadership
or stakeholders, such as:

   1.

   *“Why can’t we move to JDK 21? Everyone else in the company has already
   moved off JDK 11.”*
   -

      When can we move to JDK 21? → Likely with Cassandra 6.0, which may
      still be a couple of years away.
      -

      What prevents upgrading to Cassandra 6.0? → The release introduces
      several changes that aren’t yet widely adopted or extensively tested for
      upgrade/downgrade stability.
      -

      As a result, operators often feel cautious, and this uncertainty can
      unintentionally create a negative perception of Cassandra’s readiness
      and modernization pace.
      2.

   *“Why does Cassandra occasionally lose or resurrect data that was
   already written?”*
   -

      Answer: “We need to run repair regularly to ensure data consistency.”
      -

      Follow-up: “Why don’t we run it automatically?” → Because automated
      repair is only available in Cassandra 6.0.
      -

      Next question: “Then why not upgrade to 6.0?” → Same concern as above
      — adoption risk and testing confidence.
      -

      Again, this situation can lead to doubt about Cassandra’s
      reliability, even though it’s fundamentally sound.
      3.

   *“Can we use new features like cross-shard transactions?”*
   -

      Response: These are available only in Cassandra 6.0.
      -

      This doesn’t create as much concern as the previous points, but it
      still reinforces the perception gap between versions.

In most cases, teams decide to remain on *Cassandra 4.1*, but the ongoing
conversations around modernization and stability can gradually *erode
confidence in the Apache Cassandra brand*, especially when compared with
managed or cloud-native alternatives.

For large operators with dedicated Cassandra teams, these challenges are
easier to manage — they can backport features or enhancements as needed.
But for the majority of smaller teams, that isn’t feasible.

As a community, it’s important that we continue to *strengthen Cassandra’s
reputation* by ensuring that the fundamentals — reliability, compatibility,
and operational ease — remain first-class.
Whatever steps we can take to make Cassandra easier to run and evolve
confidently, we should pursue together.

Jaydeep

On Fri, Oct 24, 2025 at 9:04 AM Dinesh Joshi <dj...@apache.org> wrote:

> On Fri, Oct 24, 2025 at 2:44 AM Jeff Jirsa <jj...@gmail.com> wrote:
>
>> The outcome of the first round of discussion was “ok there’s no agreement
>> to do this and there’s not even agreement about why people run forks or if
>> it’s good that they maintain forks”
>>
>
> Well I guess we're talking about two different things here and it is
> totally my fault. Let me clarify.
>
> I am talking about the idea of backports. My general reading of both
> threads is that we all agree to a varying degree that backports are
> valuable. This is where I believe there is general agreement. If that is
> not the case, please point it out and I will happily stand corrected.
>
>
>> And then we’re back pushing for consensus.
>>
>> There’s no consensus here to speed up.
>>
>
> Maybe it is poor choice of words but my aim here was to help build shared
> understanding of the problem so we can talk about possible paths to a
> solution.
>
> Dinesh
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Dinesh Joshi <dj...@apache.org>.
On Fri, Oct 24, 2025 at 2:44 AM Jeff Jirsa <jj...@gmail.com> wrote:

> The outcome of the first round of discussion was “ok there’s no agreement
> to do this and there’s not even agreement about why people run forks or if
> it’s good that they maintain forks”
>

Well I guess we're talking about two different things here and it is
totally my fault. Let me clarify.

I am talking about the idea of backports. My general reading of both
threads is that we all agree to a varying degree that backports are
valuable. This is where I believe there is general agreement. If that is
not the case, please point it out and I will happily stand corrected.


> And then we’re back pushing for consensus.
>
> There’s no consensus here to speed up.
>

Maybe it is poor choice of words but my aim here was to help build shared
understanding of the problem so we can talk about possible paths to a
solution.

Dinesh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jeff Jirsa <jj...@gmail.com>.

> On Oct 24, 2025, at 2:49 AM, Dinesh Joshi <dj...@apache.org> wrote:
> 
> Synchronous calls are not intended to exclude anybody. It will simply speed up the process of building consensus among those who are interested in joining such a call


There’s dozens of voices of dissent at varying levels of intensity

The outcome of the first round of discussion was “ok there’s no agreement to do this and there’s not even agreement about why people run forks or if it’s good that they maintain forks”

And then we’re back pushing for consensus. 

There’s no consensus here to speed up.




Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Ruslan Fomkin <ru...@gmail.com>.
Hi,

I am a new contributor of a few bug fixes, and Aleksey’s comment resonates with me.

Nowadays, bug fixes go to four branches (4.0, 4.1, 5.0, trunk). Each additional branch introduces significant overhead, so I am not looking forward for having more branches to contribute a fix.
I’ve also experienced difficulty to find committers, and, I believe, that the need to commit to multiple branches contributes to this challenge.

I hope my input as a contributor (not a committer) helps illustrate some of the tradeoffs, and that future changes will not make bug fix contributions more complicated.

Best regards,
Ruslan

> On 30 Oct 2025, at 16:23, Aleksey Yeshchenko <al...@apple.com> wrote:
> 
> The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.
> 
> Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.
> 
>> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>> 
>> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.
> 


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jon Haddad <jo...@rustyrazorblade.com>.
I've been running a few hundred nodes with Shenandoah on Java 17 for the
last year, and while I can say it's been mostly nice it still has some
issues.  While pause times are definitely better than G1 (typically < 3ms),
Shenandoah isn't generational, so there's quite a bit of overhead from GC
when the allocation rate is high.  Shenandoah achieves low pause time by
throttling the allocator (pacing).  Since we allocate a *ton* during
compaction, we need to use huge heaps to compensate.  I've seen pacing take
up 35% of CPU time when profiling a cluster with perf issues.

<mildly off topic rant>
Generational ZGC should be a significant improvement, but it's not a silver
bullet.  I'd classify it as more of a crutch to mitigate the excessive
allocation found in our read and compaction paths.  Addressing a small
handful of unnecessary allocations would allow us to run much smaller heaps
while also reducing pause time (both median and at the tail) and
significantly overall throughput.  Every allocation results in a CPU stall,
inflates the side of the live set and adds overhead to every collection.  I
love the improvements in new collectors but I've found that people
sometimes massively overestimate what they can do for us and use it as an
excuse to abdicate from responsible memory management.

See CASSANDRA-20428 [1] for an example of an allocation in the hot path
that if we addressed would *massively* improve pause times and throughput.

To the future, newer JDK's have off heap Arenas [2], Memory Segments,
Memory Layouts and Structured access [3].  Leaning into that would allow us
to almost completely eliminate every single on-heap allocation, giving us
the ability to run C* on tiny heaps and have practically zero GC.

If we did that the collector an operator picks wouldn't matter at all,
because the collector would almost never run.

Feel free to branch this into a new discussion if you want to go down this
rabbit hole with me :)
</mildly off topic rant>

Jon

[1] https://issues.apache.org/jira/browse/CASSANDRA-20428
[2]
https://docs.oracle.com/en/java/javase/21/core/memory-segments-and-arenas.html
[3]
https://docs.oracle.com/en/java/javase/21/core/memory-layouts-and-structured-access.html



On Tue, Nov 11, 2025 at 7:29 AM Josh McKenzie <jm...@apache.org> wrote:

>
>    - [Must have] Minimum JDK21 support on 4.1 and higher
>
> Is this purely due to genZGC? While it's playing very nicely so far, I
> would expect the gap between tuned G1 and genZGC to be less than tuned CMS
> and genZGC.
>
> @Jon Haddad - got any insight on the above (CMS vs. G1 vs. shenandoah vs.
> genZGC)?
>
> fwiw - I think backporting the ability to run on JDK21 (or any newer JDK
> tbh) should be pretty simple and a favorable cost/benefit. Just want to
> explore if it's just the GC in the new JDK or something else at runtime
> people are looking for.
>
> On Fri, Oct 31, 2025, at 2:14 PM, Jaydeep Chovatia wrote:
>
>
>    - [Must have] Minimum JDK21 support on 4.1 and higher
>    -
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
We agreed on not dropping a JDK if it'd kill a feature (or at least called out the shape of this challenge): https://cwiki.apache.org/confluence/display/CASSANDRA/JDK+Version+Support+Policy

> In the very rare case a feature would have to be removed due to JDK change (think UDF's scripting engine)...
So we at least spoke to the implications on *part* of the intersection of JDK support and features. Good points Ekaterina and Scott - this would throw a wrinkle in my "backporting runtime support to older branches should be easy" claim. Barring those kind of exceptions I don't think it'll be a huge *technical* hurdle going forward. I'm not sure how we want to tackle this and if there'd be a path for conditional run of newer JDK w/Nashorn disabled at runtime that'd work; don't know enough about that impl to know if it's even a sane line of questioning. :)

> - jamm update will be needed, to the version we have in 5.0 or we may need new release of jamm for versions post JDK 17. It may lead to flushing change of behavior etc in a patch release
I reached out to Jonathan Ellis about this; he's receptive to us merging the jamm codebase into the C* repo which would make it far simpler to modify, test, and maintain. I don't love the idea of having to carry jamm support into the future but on reflection I think that primarily stems from the hurdle of maintaining and validating it in a separate repo. There aren't really any obvious license-compatible alternatives so at the very least, getting it to low friction to validate and modify jamm should help.

On Tue, Nov 11, 2025, at 11:03 AM, C. Scott Andreas wrote:
> The most pressing motivation for folks to get off JDK11 is that many organizations consider it end-of-life. It was released 7 years ago and Oracle Premier support ended two years ago, so it's in its final "extended support" lifecycle which runs through 2032 at what I'm sure is substantial expense.
> 
> Agree with Ekaterina's concerns about Nashorn removal in JDK15+ and the impact to API surface.
> 
> Good motivation to stay current in all respects – for us to continue advancing support for new JDK LTS releases; and for users to upgrade to current major versions of the database.
> 
>> On Nov 11, 2025, at 7:48 AM, Ekaterina Dimitrova <e....@gmail.com> wrote:
>> 
>> 
>> “fwiw - I think backporting the ability to run on JDK21 (or any newer JDK tbh) should be pretty simple and a favorable cost/benefit. Just want to explore if it's just the GC in the new JDK or something else at runtime people are looking for.”
>> 
>> Some caveats which are not about complexity but which need to be considered:
>> - we removed scripted UDFs to move forward and are not going to remove them in 4.1 (CASSANDRA-18252)
>> 
>> - jamm update will be needed, to the version we have in 5.0 or we may need new release of jamm for versions post JDK 17. It may lead to flushing change of behavior etc in a patch release
>> 
>> 
>> 
>> On Tue, 11 Nov 2025 at 10:29, Josh McKenzie <jm...@apache.org> wrote:
>>> __
>>>>  • [Must have] Minimum JDK21 support on 4.1 and higher
>>> Is this purely due to genZGC? While it's playing very nicely so far, I would expect the gap between tuned G1 and genZGC to be less than tuned CMS and genZGC.
>>> 
>>> @Jon Haddad - got any insight on the above (CMS vs. G1 vs. shenandoah vs. genZGC)?
>>> 
>>> fwiw - I think backporting the ability to run on JDK21 (or any newer JDK tbh) should be pretty simple and a favorable cost/benefit. Just want to explore if it's just the GC in the new JDK or something else at runtime people are looking for.
>>> 
>>> On Fri, Oct 31, 2025, at 2:14 PM, Jaydeep Chovatia wrote:
>>>>  • [Must have] Minimum JDK21 support on 4.1 and higher
>>>>  • 
>>> 
> 
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by "C. Scott Andreas" <sc...@paradoxica.net>.
The most pressing motivation for folks to get off JDK11 is that many organizations consider it end-of-life. It was released 7 years ago and Oracle Premier support ended two years ago, so it's in its final "extended support" lifecycle which runs through 2032 at what I'm sure is substantial expense. Agree with Ekaterina's concerns about Nashorn removal in JDK15+ and the impact to API surface. Good motivation to stay current in all respects – for us to continue advancing support for new JDK LTS releases; and for users to upgrade to current major versions of the database. On Nov 11, 2025, at 7:48 AM, Ekaterina Dimitrova <e....@gmail.com> wrote: “fwiw - I think backporting the ability to run on JDK21 (or any newer JDK tbh) should be pretty simple and a favorable cost/benefit. Just want to explore if it's just the GC in the new JDK or something else at runtime people are looking for.” Some caveats which are not about complexity but which need to be considered: - we removed scripted UDFs to move forward and are not going to remove them in 4.1 (CASSANDRA-18252) - jamm update will be needed, to the version we have in 5.0 or we may need new release of jamm for versions post JDK 17. It may lead to flushing change of behavior etc in a patch release On Tue, 11 Nov 2025 at 10:29, Josh McKenzie < jmckenzie@apache.org > wrote: [Must have] Minimum JDK21 support on 4.1 and higher Is this purely due to genZGC? While it's playing very nicely so far, I would expect the gap between tuned G1 and genZGC to be less than tuned CMS and genZGC. @Jon Haddad - got any insight on the above (CMS vs. G1 vs. shenandoah vs. genZGC)? fwiw - I think backporting the ability to run on JDK21 (or any newer JDK tbh) should be pretty simple and a favorable cost/benefit. Just want to explore if it's just the GC in the new JDK or something else at runtime people are looking for. On Fri, Oct 31, 2025, at 2:14 PM, Jaydeep Chovatia wrote: [Must have] Minimum JDK21 support on 4.1 and higher

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Ekaterina Dimitrova <e....@gmail.com>.
“fwiw - I think backporting the ability to run on JDK21 (or any newer JDK
tbh) should be pretty simple and a favorable cost/benefit. Just want to
explore if it's just the GC in the new JDK or something else at runtime
people are looking for.”

Some caveats which are not about complexity but which need to be considered:
- we removed scripted UDFs to move forward and are not going to remove them
in 4.1 (CASSANDRA-18252)

- jamm update will be needed, to the version we have in 5.0 or we may need
new release of jamm for versions post JDK 17. It may lead to flushing
change of behavior etc in a patch release



On Tue, 11 Nov 2025 at 10:29, Josh McKenzie <jm...@apache.org> wrote:

>
>    - [Must have] Minimum JDK21 support on 4.1 and higher
>
> Is this purely due to genZGC? While it's playing very nicely so far, I
> would expect the gap between tuned G1 and genZGC to be less than tuned CMS
> and genZGC.
>
> @Jon Haddad - got any insight on the above (CMS vs. G1 vs. shenandoah vs.
> genZGC)?
>
> fwiw - I think backporting the ability to run on JDK21 (or any newer JDK
> tbh) should be pretty simple and a favorable cost/benefit. Just want to
> explore if it's just the GC in the new JDK or something else at runtime
> people are looking for.
>
> On Fri, Oct 31, 2025, at 2:14 PM, Jaydeep Chovatia wrote:
>
>
>    - [Must have] Minimum JDK21 support on 4.1 and higher
>    -
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
>  • [Must have] Minimum JDK21 support on 4.1 and higher
Is this purely due to genZGC? While it's playing very nicely so far, I would expect the gap between tuned G1 and genZGC to be less than tuned CMS and genZGC.

@Jon Haddad - got any insight on the above (CMS vs. G1 vs. shenandoah vs. genZGC)?

fwiw - I think backporting the ability to run on JDK21 (or any newer JDK tbh) should be pretty simple and a favorable cost/benefit. Just want to explore if it's just the GC in the new JDK or something else at runtime people are looking for.

On Fri, Oct 31, 2025, at 2:14 PM, Jaydeep Chovatia wrote:
>  • [Must have] Minimum JDK21 support on 4.1 and higher
>  • 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jaydeep Chovatia <ch...@gmail.com>.
How about we flip the problem statement. Let's first find out all the
fundamental changes any operator would need. Once we all agree on the list,
then we can find out the right way to support them, it might we just not
create a new branch and backport on the official branch similar to how we
do bug fixes.

Here is my list and opinion:

   - [Must have] Minimum JDK21 support on 4.1 and higher
   - [Should have] CEP-37 on 4.1 or higher

Of course, we should do a formal vote and then come up with a curated list.
So, if the list is small enough, we might as well not go for a new fork;
instead, just support the agreed list of items on the existing branch, say
4.1.12 with JDK21 support, 4.1.13 with CEP-37, and so on. That way, we
serve two purposes: 1) Continue to support fundamental items for Cassandra
to everybody, which helps smaller and larger operators, 2) Avoids extra
fork, which reduces burden on committers, etc.

Sure, we can argue that adding JDK21 + CEP-37 involves a lot more code
changes, but we should only select features that are mostly not touching
critical pieces, such as messaging structure, disk structure, isolated
code, etc., so that reduces the risk when doing minor version upgrades.

For the long run to avoid such backports, we should start a separate
discussion on how to build more confidence in trunk and how we can speed up
the Cassandra deployment from trunk by the majority at a much smaller
cadence, say 6 months. So, we don't have to worry about backporting
fundamental stuff in the future.

Jaydeep

On Fri, Oct 31, 2025 at 10:43 AM Josh McKenzie <jm...@apache.org> wrote:

> Nowadays, bug fixes go to four branches (4.0, 4.1, 5.0, trunk). Each
> additional branch introduces significant overhead,
>
> For merging and CI, yes. Thanks for chiming in with your perspective!
>
> I also think this would be easier if we were to stop doing merge commits,
> use github PR's to merge in code (pre-commit checks you say?), and have a
> PR to apply to each branch for a change breaking up the --atomic
> requirement blocker for multi-branch patches and reducing the toil there.
> It's a lot easier to automate the creation and maintenance of that than it
> is our current flow.
>
> Which I can cause a ruckus with on another [DISCUSS] thread.
>
> :D
>
> On Fri, Oct 31, 2025, at 1:39 PM, Josh McKenzie wrote:
>
> In fact, since JDK 25 is now the latest LTS release, *per our policy* we
> should now prioritise moving trunk to 25 and adding support for LDK 25 to
> 5.0 (and 4.1).
>
> I'd have JDK21 support merged already if I were working on that instead of
> accidentally rabble-rousing with email threads. =/
>
> I *think* we can get JDK21 support in to unblock 6.0 discussions and then
> just incrementally add JDK25 as an incremental step peri or post 6.0
> qualification, backport ability to run it through all branches, and kind of
> incrementally win here.
>
> The downside to doing that would be 6.0 LTS branch being constrained to
> JDK21 language levels, but this would be a post 6.0 GA world where mostly
> bugfixes would be going to that branch and we could push lang level to 25
> on trunk as soon as other GA was tested runtime with it.
>
> +1 on us just having a [DISCUSS] around a selective backport for CEP-37.
>
> I really do believe cadenced releases + alphas from trunk will give us
> almost all the same benefits we're chasing with a backports branch w/out
> adding another branch maintenance burden (merge path + CI). "Qualify a
> release from backport branch" should be comparable to "Qualify a release
> from an alpha branch" in terms of exposure to new features and disruption.
> If we did a quarterly alpha that'd give people some flexibility on
> checkpoints of where they wanted to take on qualifying and integrating a
> release on their fleet.
>
> On Fri, Oct 31, 2025, at 9:11 AM, Aleksey Yeshchenko wrote:
>
> Regarding JDK 21: it is *already* our policy to backport new JDK LTS
> support to all supported GA branches.
>
> We do not need to cut 5.1 for that. We are *expected* to add support for
> JDK 21 to 5.0 once it’s landed in trunk:
>
> *[New LTS JDK Adoption]*
>
>    - When a new JDK goes LTS, we prioritize:
>
>
>    -
>       - Moving trunk to build, run, pass CI, and support language level
>       of that JDK, dropping others
>       - Adding support to *run* on that JDK to all supported GA releases,
>       passing all CI using that JDK
>
>
> (via
> https://cwiki.apache.org/confluence/display/CASSANDRA/JDK+Version+Support+Policy
> )
>
> In fact, since JDK 25 is now the latest LTS release, *per our policy* we
> should now prioritise moving trunk to 25 and adding support for LDK 25 to
> 5.0 (and 4.1).
>
> That leaves just CEP-37 as something folks seem to want to backport. If we
> do that, I would prefer the backport land in 5.0 rather than an in-between
> 5.1 branch with just the CEP-37 in it (which seems like overkill to me).
>
> On 30 Oct 2025, at 16:32, Štefan Miklošovič <sm...@apache.org>
> wrote:
>
> I would just reiterate what I wrote here (1).
>
> While we are not running forks as already described / explained above,
> that does not mean that just because of that I will be against some
> kind of a solution which makes people's life easier. Sure, have your
> branch if you want and if you have people to release it and so on ...
> Who am I to forbid that ...
>
> The response of Jaydeep in this thread is very reasonable and
> resonates with me the most, everybody in this thread is from a company
> who has capacity to have forks and manage them etc. but what about the
> folks who would just have to run this and they are genuinely afraid /
> stuck? We should look beyond our immediate interests here, IMHO.
>
> But on the other hand, and that is what I think I did not get a
> satisfactory answer to, is what will be the scope of that branch you
> are proposing to create? I want to meet you somewhere in the middle,
> sure make 5.1, make it supporting Java 21 and sure put CEP-37 there,
> but only that!
>
> I think that if we had just these two things in plus bug fixes from
> 5.0 that would make people in general way more acceptable to this
> idea. But so far it seems to me that once we create 5.1, over time it
> will be just a branch to backport this and that and I don't want that
> for the sake of some basic predicatiblity and I do not want myself to
> suddenly find deep down in backport business.
>
> Just make 5.1 to fix the pain points Jaydeep was talking about if you
> want but please let's keep it somehow manageable.
>
> If somebody strongly opposes the creation of any additional branches,
> that is fine and that is their opinion I respect. I just want to say
> that I will not be the one who will vehemently and ultimately block it
> AS LONG AS we will keep it strongly about Java 21 + CEP 37 + bugfixes
> from 5.0.
>
> (1) https://lists.apache.org/thread/mgb8y66wdwq0w5s6hl10qmxd9fbwswmd
>
> On Thu, Oct 30, 2025 at 4:34 PM Aleksey Yeshchenko <al...@apple.com>
> wrote:
>
>
> Overall I’m strongly opposed to any solution which introduces additional
> branches.
>
> OTOH I have no problem at all with backporting JDK 21 support to an
> existing branch where viable.
>
> On 30 Oct 2025, at 15:23, Aleksey Yeshchenko <al...@apple.com> wrote:
>
> The mandatory extra work would come from having additional branches on the
> merge path up. In addition to actually merging the code, it’s the hassle of
> getting green CI results for the backport branches, delaying the merge.
>
> Or these branches are skipped on the regular merge path and it becomes the
> job of the branch-backport volunteers - now responsible for every single
> commit that lands in that branch, including the future-ports of bug fixes.
>
> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>
> Committers are not required to backport their features to these branches
> so I don't see this as 'mandatory' for all committers. Please elaborate if
> there are aspects of maintenance that I've missed.
>
>
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
> Nowadays, bug fixes go to four branches (4.0, 4.1, 5.0, trunk). Each additional branch introduces significant overhead,
For merging and CI, yes. Thanks for chiming in with your perspective!

I also think this would be easier if we were to stop doing merge commits, use github PR's to merge in code (pre-commit checks you say?), and have a PR to apply to each branch for a change breaking up the --atomic requirement blocker for multi-branch patches and reducing the toil there. It's a lot easier to automate the creation and maintenance of that than it is our current flow.

Which I can cause a ruckus with on another [DISCUSS] thread.

:D

On Fri, Oct 31, 2025, at 1:39 PM, Josh McKenzie wrote:
>> In fact, since JDK 25 is now the latest LTS release, *per our policy* we should now prioritise moving trunk to 25 and adding support for LDK 25 to 5.0 (and 4.1).
> I'd have JDK21 support merged already if I were working on that instead of accidentally rabble-rousing with email threads. =/
> 
> I *think* we can get JDK21 support in to unblock 6.0 discussions and then just incrementally add JDK25 as an incremental step peri or post 6.0 qualification, backport ability to run it through all branches, and kind of incrementally win here.
> 
> The downside to doing that would be 6.0 LTS branch being constrained to JDK21 language levels, but this would be a post 6.0 GA world where mostly bugfixes would be going to that branch and we could push lang level to 25 on trunk as soon as other GA was tested runtime with it.
> 
> +1 on us just having a [DISCUSS] around a selective backport for CEP-37.
> 
> I really do believe cadenced releases + alphas from trunk will give us almost all the same benefits we're chasing with a backports branch w/out adding another branch maintenance burden (merge path + CI). "Qualify a release from backport branch" should be comparable to "Qualify a release from an alpha branch" in terms of exposure to new features and disruption. If we did a quarterly alpha that'd give people some flexibility on checkpoints of where they wanted to take on qualifying and integrating a release on their fleet.
> 
> On Fri, Oct 31, 2025, at 9:11 AM, Aleksey Yeshchenko wrote:
>> Regarding JDK 21: it is *already* our policy to backport new JDK LTS support to all supported GA branches. 
>> 
>> We do not need to cut 5.1 for that. We are *expected* to add support for JDK 21 to 5.0 once it’s landed in trunk:
>> **
>> *[New LTS JDK Adoption]*
>>  • When a new JDK goes LTS, we prioritize:
>>  •    • Moving trunk to build, run, pass CI, and support language level of that JDK, dropping others
>>    • Adding support to *run* on that JDK to all supported GA releases, passing all CI using that JDK
>>  
>> (via https://cwiki.apache.org/confluence/display/CASSANDRA/JDK+Version+Support+Policy)
>> 
>> In fact, since JDK 25 is now the latest LTS release, *per our policy* we should now prioritise moving trunk to 25 and adding support for LDK 25 to 5.0 (and 4.1).
>> 
>> That leaves just CEP-37 as something folks seem to want to backport. If we do that, I would prefer the backport land in 5.0 rather than an in-between 5.1 branch with just the CEP-37 in it (which seems like overkill to me).
>> 
>>> On 30 Oct 2025, at 16:32, Štefan Miklošovič <sm...@apache.org> wrote:
>>> 
>>> I would just reiterate what I wrote here (1).
>>> 
>>> While we are not running forks as already described / explained above,
>>> that does not mean that just because of that I will be against some
>>> kind of a solution which makes people's life easier. Sure, have your
>>> branch if you want and if you have people to release it and so on ...
>>> Who am I to forbid that ...
>>> 
>>> The response of Jaydeep in this thread is very reasonable and
>>> resonates with me the most, everybody in this thread is from a company
>>> who has capacity to have forks and manage them etc. but what about the
>>> folks who would just have to run this and they are genuinely afraid /
>>> stuck? We should look beyond our immediate interests here, IMHO.
>>> 
>>> But on the other hand, and that is what I think I did not get a
>>> satisfactory answer to, is what will be the scope of that branch you
>>> are proposing to create? I want to meet you somewhere in the middle,
>>> sure make 5.1, make it supporting Java 21 and sure put CEP-37 there,
>>> but only that!
>>> 
>>> I think that if we had just these two things in plus bug fixes from
>>> 5.0 that would make people in general way more acceptable to this
>>> idea. But so far it seems to me that once we create 5.1, over time it
>>> will be just a branch to backport this and that and I don't want that
>>> for the sake of some basic predicatiblity and I do not want myself to
>>> suddenly find deep down in backport business.
>>> 
>>> Just make 5.1 to fix the pain points Jaydeep was talking about if you
>>> want but please let's keep it somehow manageable.
>>> 
>>> If somebody strongly opposes the creation of any additional branches,
>>> that is fine and that is their opinion I respect. I just want to say
>>> that I will not be the one who will vehemently and ultimately block it
>>> AS LONG AS we will keep it strongly about Java 21 + CEP 37 + bugfixes
>>> from 5.0.
>>> 
>>> (1) https://lists.apache.org/thread/mgb8y66wdwq0w5s6hl10qmxd9fbwswmd
>>> 
>>> On Thu, Oct 30, 2025 at 4:34 PM Aleksey Yeshchenko <al...@apple.com> wrote:
>>>> 
>>>> Overall I’m strongly opposed to any solution which introduces additional branches.
>>>> 
>>>> OTOH I have no problem at all with backporting JDK 21 support to an existing branch where viable.
>>>> 
>>>> On 30 Oct 2025, at 15:23, Aleksey Yeshchenko <al...@apple.com> wrote:
>>>> 
>>>> The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.
>>>> 
>>>> Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.
>>>> 
>>>> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>>>> 
>>>> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.
>>>> 
>>>> 
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
> In fact, since JDK 25 is now the latest LTS release, *per our policy* we should now prioritise moving trunk to 25 and adding support for LDK 25 to 5.0 (and 4.1).
I'd have JDK21 support merged already if I were working on that instead of accidentally rabble-rousing with email threads. =/

I *think* we can get JDK21 support in to unblock 6.0 discussions and then just incrementally add JDK25 as an incremental step peri or post 6.0 qualification, backport ability to run it through all branches, and kind of incrementally win here.

The downside to doing that would be 6.0 LTS branch being constrained to JDK21 language levels, but this would be a post 6.0 GA world where mostly bugfixes would be going to that branch and we could push lang level to 25 on trunk as soon as other GA was tested runtime with it.

+1 on us just having a [DISCUSS] around a selective backport for CEP-37.

I really do believe cadenced releases + alphas from trunk will give us almost all the same benefits we're chasing with a backports branch w/out adding another branch maintenance burden (merge path + CI). "Qualify a release from backport branch" should be comparable to "Qualify a release from an alpha branch" in terms of exposure to new features and disruption. If we did a quarterly alpha that'd give people some flexibility on checkpoints of where they wanted to take on qualifying and integrating a release on their fleet.

On Fri, Oct 31, 2025, at 9:11 AM, Aleksey Yeshchenko wrote:
> Regarding JDK 21: it is *already* our policy to backport new JDK LTS support to all supported GA branches. 
> 
> We do not need to cut 5.1 for that. We are *expected* to add support for JDK 21 to 5.0 once it’s landed in trunk:
> **
> *[New LTS JDK Adoption]*
>  • When a new JDK goes LTS, we prioritize:
>  •    • Moving trunk to build, run, pass CI, and support language level of that JDK, dropping others
>    • Adding support to *run* on that JDK to all supported GA releases, passing all CI using that JDK
>  
> (via https://cwiki.apache.org/confluence/display/CASSANDRA/JDK+Version+Support+Policy)
> 
> In fact, since JDK 25 is now the latest LTS release, *per our policy* we should now prioritise moving trunk to 25 and adding support for LDK 25 to 5.0 (and 4.1).
> 
> That leaves just CEP-37 as something folks seem to want to backport. If we do that, I would prefer the backport land in 5.0 rather than an in-between 5.1 branch with just the CEP-37 in it (which seems like overkill to me).
> 
>> On 30 Oct 2025, at 16:32, Štefan Miklošovič <sm...@apache.org> wrote:
>> 
>> I would just reiterate what I wrote here (1).
>> 
>> While we are not running forks as already described / explained above,
>> that does not mean that just because of that I will be against some
>> kind of a solution which makes people's life easier. Sure, have your
>> branch if you want and if you have people to release it and so on ...
>> Who am I to forbid that ...
>> 
>> The response of Jaydeep in this thread is very reasonable and
>> resonates with me the most, everybody in this thread is from a company
>> who has capacity to have forks and manage them etc. but what about the
>> folks who would just have to run this and they are genuinely afraid /
>> stuck? We should look beyond our immediate interests here, IMHO.
>> 
>> But on the other hand, and that is what I think I did not get a
>> satisfactory answer to, is what will be the scope of that branch you
>> are proposing to create? I want to meet you somewhere in the middle,
>> sure make 5.1, make it supporting Java 21 and sure put CEP-37 there,
>> but only that!
>> 
>> I think that if we had just these two things in plus bug fixes from
>> 5.0 that would make people in general way more acceptable to this
>> idea. But so far it seems to me that once we create 5.1, over time it
>> will be just a branch to backport this and that and I don't want that
>> for the sake of some basic predicatiblity and I do not want myself to
>> suddenly find deep down in backport business.
>> 
>> Just make 5.1 to fix the pain points Jaydeep was talking about if you
>> want but please let's keep it somehow manageable.
>> 
>> If somebody strongly opposes the creation of any additional branches,
>> that is fine and that is their opinion I respect. I just want to say
>> that I will not be the one who will vehemently and ultimately block it
>> AS LONG AS we will keep it strongly about Java 21 + CEP 37 + bugfixes
>> from 5.0.
>> 
>> (1) https://lists.apache.org/thread/mgb8y66wdwq0w5s6hl10qmxd9fbwswmd
>> 
>> On Thu, Oct 30, 2025 at 4:34 PM Aleksey Yeshchenko <al...@apple.com> wrote:
>>> 
>>> Overall I’m strongly opposed to any solution which introduces additional branches.
>>> 
>>> OTOH I have no problem at all with backporting JDK 21 support to an existing branch where viable.
>>> 
>>> On 30 Oct 2025, at 15:23, Aleksey Yeshchenko <al...@apple.com> wrote:
>>> 
>>> The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.
>>> 
>>> Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.
>>> 
>>> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>>> 
>>> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.
>>> 
>>> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Aleksey Yeshchenko <al...@apple.com>.
Regarding JDK 21: it is *already* our policy to backport new JDK LTS support to all supported GA branches. 

We do not need to cut 5.1 for that. We are *expected* to add support for JDK 21 to 5.0 once it’s landed in trunk:

[New LTS JDK Adoption]
When a new JDK goes LTS, we prioritize:
Moving trunk to build, run, pass CI, and support language level of that JDK, dropping others
Adding support to run on that JDK to all supported GA releases, passing all CI using that JDK
 
(via https://cwiki.apache.org/confluence/display/CASSANDRA/JDK+Version+Support+Policy)

In fact, since JDK 25 is now the latest LTS release, *per our policy* we should now prioritise moving trunk to 25 and adding support for LDK 25 to 5.0 (and 4.1).

That leaves just CEP-37 as something folks seem to want to backport. If we do that, I would prefer the backport land in 5.0 rather than an in-between 5.1 branch with just the CEP-37 in it (which seems like overkill to me).

> On 30 Oct 2025, at 16:32, Štefan Miklošovič <sm...@apache.org> wrote:
> 
> I would just reiterate what I wrote here (1).
> 
> While we are not running forks as already described / explained above,
> that does not mean that just because of that I will be against some
> kind of a solution which makes people's life easier. Sure, have your
> branch if you want and if you have people to release it and so on ...
> Who am I to forbid that ...
> 
> The response of Jaydeep in this thread is very reasonable and
> resonates with me the most, everybody in this thread is from a company
> who has capacity to have forks and manage them etc. but what about the
> folks who would just have to run this and they are genuinely afraid /
> stuck? We should look beyond our immediate interests here, IMHO.
> 
> But on the other hand, and that is what I think I did not get a
> satisfactory answer to, is what will be the scope of that branch you
> are proposing to create? I want to meet you somewhere in the middle,
> sure make 5.1, make it supporting Java 21 and sure put CEP-37 there,
> but only that!
> 
> I think that if we had just these two things in plus bug fixes from
> 5.0 that would make people in general way more acceptable to this
> idea. But so far it seems to me that once we create 5.1, over time it
> will be just a branch to backport this and that and I don't want that
> for the sake of some basic predicatiblity and I do not want myself to
> suddenly find deep down in backport business.
> 
> Just make 5.1 to fix the pain points Jaydeep was talking about if you
> want but please let's keep it somehow manageable.
> 
> If somebody strongly opposes the creation of any additional branches,
> that is fine and that is their opinion I respect. I just want to say
> that I will not be the one who will vehemently and ultimately block it
> AS LONG AS we will keep it strongly about Java 21 + CEP 37 + bugfixes
> from 5.0.
> 
> (1) https://lists.apache.org/thread/mgb8y66wdwq0w5s6hl10qmxd9fbwswmd
> 
> On Thu, Oct 30, 2025 at 4:34 PM Aleksey Yeshchenko <al...@apple.com> wrote:
>> 
>> Overall I’m strongly opposed to any solution which introduces additional branches.
>> 
>> OTOH I have no problem at all with backporting JDK 21 support to an existing branch where viable.
>> 
>> On 30 Oct 2025, at 15:23, Aleksey Yeshchenko <al...@apple.com> wrote:
>> 
>> The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.
>> 
>> Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.
>> 
>> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>> 
>> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.
>> 
>> 
>> 


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Štefan Miklošovič <sm...@apache.org>.
I would just reiterate what I wrote here (1).

While we are not running forks as already described / explained above,
that does not mean that just because of that I will be against some
kind of a solution which makes people's life easier. Sure, have your
branch if you want and if you have people to release it and so on ...
Who am I to forbid that ...

The response of Jaydeep in this thread is very reasonable and
resonates with me the most, everybody in this thread is from a company
who has capacity to have forks and manage them etc. but what about the
folks who would just have to run this and they are genuinely afraid /
stuck? We should look beyond our immediate interests here, IMHO.

But on the other hand, and that is what I think I did not get a
satisfactory answer to, is what will be the scope of that branch you
are proposing to create? I want to meet you somewhere in the middle,
sure make 5.1, make it supporting Java 21 and sure put CEP-37 there,
but only that!

I think that if we had just these two things in plus bug fixes from
5.0 that would make people in general way more acceptable to this
idea. But so far it seems to me that once we create 5.1, over time it
will be just a branch to backport this and that and I don't want that
for the sake of some basic predicatiblity and I do not want myself to
suddenly find deep down in backport business.

Just make 5.1 to fix the pain points Jaydeep was talking about if you
want but please let's keep it somehow manageable.

If somebody strongly opposes the creation of any additional branches,
that is fine and that is their opinion I respect. I just want to say
that I will not be the one who will vehemently and ultimately block it
AS LONG AS we will keep it strongly about Java 21 + CEP 37 + bugfixes
from 5.0.

(1) https://lists.apache.org/thread/mgb8y66wdwq0w5s6hl10qmxd9fbwswmd

On Thu, Oct 30, 2025 at 4:34 PM Aleksey Yeshchenko <al...@apple.com> wrote:
>
> Overall I’m strongly opposed to any solution which introduces additional branches.
>
> OTOH I have no problem at all with backporting JDK 21 support to an existing branch where viable.
>
> On 30 Oct 2025, at 15:23, Aleksey Yeshchenko <al...@apple.com> wrote:
>
> The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.
>
> Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.
>
> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>
> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Aleksey Yeshchenko <al...@apple.com>.
Overall I’m strongly opposed to any solution which introduces additional branches.

OTOH I have no problem at all with backporting JDK 21 support to an existing branch where viable.

> On 30 Oct 2025, at 15:23, Aleksey Yeshchenko <al...@apple.com> wrote:
> 
> The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.
> 
> Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.
> 
>> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
>> 
>> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.
> 


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Aleksey Yeshchenko <al...@apple.com>.
The mandatory extra work would come from having additional branches on the merge path up. In addition to actually merging the code, it’s the hassle of getting green CI results for the backport branches, delaying the merge.

Or these branches are skipped on the regular merge path and it becomes the job of the branch-backport volunteers - now responsible for every single commit that lands in that branch, including the future-ports of bug fixes.

> On 24 Oct 2025, at 07:49, Dinesh Joshi <dj...@apache.org> wrote:
> 
> Committers are not required to backport their features to these branches so I don't see this as 'mandatory' for all committers. Please elaborate if there are aspects of maintenance that I've missed.


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Dinesh Joshi <dj...@apache.org>.
On Thu, Oct 23, 2025 at 10:37 PM <sc...@paradoxica.net> wrote:

> There is a path forward for such backports to be contributed today, and
> it’s pretty well established.
>

> One sends an email to the dev list and proposes intent to backport a
> change or feature to a branch that wouldn’t ordinarily be a target for the
> change. Absent concern, the backport proceeds. In the presence of
> disagreement, discussion and a vote may follow to determine the appropriate
> path. All contributors are welcome to exercise this process, and I think we
> should do this more often. I’m surprised throughout this discussion that no
> one has done so and would encourage them to if they have a patch they’d
> like to backport.
>

This path is not well established. Past discussions around backporting have
raised concerns about 'stability' of backporting changes which is fair but
it leaves contributors who would like to backport patches without a choice.
Isolating backports in a separate branch would allow us to mitigate those
kinds of concern and establish a more liberal criteria to accept backported
patches.

We, as a project, currently lack concrete guidelines on what is and isn't
acceptable to backport. There isn't an objective criteria establishing the
level of risk associated with a proposed backport. It's mostly vibes based
as most other things.

I’m concerned that this message seems to try to soften the proposal to
> establish new branches that are mandatory for all committers to maintain by
> framing it as a “pilot," but does not respond
>

Committers are not required to backport their features to these branches so
I don't see this as 'mandatory' for all committers. Please elaborate if
there are aspects of maintenance that I've missed.


> to past feedback from multiple contributors highlighting the degree of
> that burden or the high cost of undoing such a pilot.
>

Let's address the burden of undoing the cost of this pilot concretely. The
cost as follows -

1. Stop maintaining the backports branch.
2. Stop producing any artifacts from backports branch.
3. Deprecating the released artifacts.
4. Retire CI.

Is there any other cost related to retiring this pilot that you think I
haven't accounted for?

It also seems to suggest that there is consensus, and I don’t see that on
> this thread or the other one.
>

The discussion is continuing because there is no consensus. Could you
elaborate on what makes you say that there is suggestion of a consensus?

A synchronous call at a particular time will exclude many from
> participation either due to time zones or scheduling conflicts. This list
> seems like the best place to have that discussion.
>

Synchronous calls are not intended to exclude anybody. It will simply speed
up the process of building consensus among those who are interested in
joining such a call. The discussion has to ultimately land back on the dev
list.

Dinesh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by sc...@paradoxica.net.
There is a path forward for such backports to be contributed today, and it’s pretty well established.

One sends an email to the dev list and proposes intent to backport a change or feature to a branch that wouldn’t ordinarily be a target for the change. Absent concern, the backport proceeds. In the presence of disagreement, discussion and a vote may follow to determine the appropriate path. All contributors are welcome to exercise this process, and I think we should do this more often. I’m surprised throughout this discussion that no one has done so and would encourage them to if they have a patch they’d like to backport.

I’m concerned that this message seems to try to soften the proposal to establish new branches that are mandatory for all committers to maintain by framing it as a “pilot," but does not respond to past feedback from multiple contributors highlighting the degree of that burden or the high cost of undoing such a pilot. It also seems to suggest that there is consensus, and I don’t see that on this thread or the other one.

A synchronous call at a particular time will exclude many from participation either due to time zones or scheduling conflicts. This list seems like the best place to have that discussion.

– Scott

> On Oct 23, 2025, at 10:09 PM, Dinesh Joshi <dj...@apache.org> wrote:
> 
> On Thu, Oct 23, 2025 at 5:49 PM Jon Haddad <jon@rustyrazorblade.com <ma...@rustyrazorblade.com>> wrote:
>> 
>> I’m opposed to teams solving their technical debt issues by pushing more responsibility onto the project.  
> 
> There are no teams here. There is just the project and contributors. Official backports are not a new or novel concept in open source projects. Whatever is being discussed here needs to be sustainably supported by the project in the longterm.
> 
> We have volunteers who are willing to participate in backporting some features. The project needs to create a path forward for them to contribute. The concerns around sustainability, testing, support are valid and there are suggestions to mitigate those concerns. Assuming all goes well with the pilot, it will help grow the project. If it doesn't go well, it's not a big deal. This is not an irreversible decision – hence the suggestion for a limited time pilot.
> 
> Given that there has been a lot of interest in this conversation, I suggest we organize a call to discuss this. It might help with questions that everybody has. We can then bring it back to the dev list.
> 
> Thoughts?
> 
> Dinesh


Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Dinesh Joshi <dj...@apache.org>.
On Thu, Oct 23, 2025 at 5:49 PM Jon Haddad <jo...@rustyrazorblade.com> wrote:

>
> I’m opposed to teams solving their technical debt issues by pushing more
> responsibility onto the project.
>

There are no teams here. There is just the project and contributors.
Official backports are not a new or novel concept in open source projects.
Whatever is being discussed here needs to be sustainably supported by the
project in the longterm.

We have volunteers who are willing to participate in backporting some
features. The project needs to create a path forward for them to
contribute. The concerns around sustainability, testing, support are valid
and there are suggestions to mitigate those concerns. Assuming all goes
well with the pilot, it will help grow the project. If it doesn't go well,
it's not a big deal. This is not an irreversible decision – hence the
suggestion for a limited time pilot.

Given that there has been a lot of interest in this conversation, I suggest
we organize a call to discuss this. It might help with questions that
everybody has. We can then bring it back to the dev list.

Thoughts?

Dinesh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Jon Haddad <jo...@rustyrazorblade.com>.
I lean pretty strongly in this direction.

I think the only reasonable way to do any custom branch (backport or any
other release that deviates from the primary release cycle) would be
similar to the original aspects of the CEP process where it required a
shepherd. If you want a backport branch, great, but it’s your
responsibility to keep it up to date, apply bug fixes, and handle
releases.  It shouldn’t impact anyone else that hasn’t explicitly
volunteered to help maintain it.

I’m opposed to teams solving their technical debt issues by pushing more
responsibility onto the project.

Jon


On Thu, Oct 23, 2025 at 10:14 AM Josh McKenzie <jm...@apache.org> wrote:

> To your point Stefan, I honestly think if we:
>
>    - Released a new GA once a year like clockwork
>    - Cut alphas from trunk every month or 3 months
>    - Kept CI green (rigorous and pain-free running of pre-commit, git
>    revert on things that break tests)
>    - Had new features have the following properties:
>       - Documented (dev, user, operator, code)
>       - Off by default; feature flagged
>       - Thoroughly tested (unit, property, integration, fuzz, jmh perf at
>       least where appropriate)
>
> then it'd be easier for someone who wanted to add a new feature to their
> fleet to just author it against trunk and qualify the next alpha for their
> specific use-case, adopting it fleet wide when the next major hit.
>
> This would satisfy the "don't want to run a fork" crowd, align with the
> "trunk should be releasable" sentiment Ariel drummed on years ago, and help
> with the "we need more people to qualify and stabilize trunk" sentiment
> Scott rightly expressed.
>
> So far this seems to improve all the pressures people have brought up for
> why they run forks excepting the "need to integrate with my own platform".
>
> On Thu, Oct 23, 2025, at 12:56 PM, Štefan Miklošovič wrote:
>
> Great continuation of the original thread.
>
>
> We do not run forks. Our business model is completely different. What
> Apache Cassandra releases is what you will get. That's it. Vanilla. So
> in some sense when the whole backporting idea was proposed I was kind
> of not understanding all of that but I am quite sympathetic to the
> problems of others and in some way I feel sorry that you have to all
> go through this because we just don't.
>
> When there is a problem to be solved, first of all we look into how it
> might be fixed upstream and be released as part of the official
> release. A lot of customers actually want to run "the official thing"
> and they do not want to run the forks. Forks are hard to maintain,
> each client would be running a different fork, that is hard to track
> over time and so on.
>
> If you are a company which is self-contained and big enough to run
> internal fork I get it, but there are also people who don't want to
> see any forks, they just want to run the release in its purest form.
> Because they trust the community which is driving it more than a
> couple individuals who would fork it.
>
> If we want to make something upstream, there needs to be somebody to
> drive and deliver it (me) and ideally who can release it (me). I don't
> even need a private CI. Why? We have one, pre-ci. So, I can release
> basically whenever I want. Why would I want to have a fork? There is
> no reason for that.
>
> I also think that cooperation in the broader community on your patch
> (or patches of others) is better. It gets rid of a whole class of
> problems. If I fix some bug or feature, I am most probably fixing it
> for somebody else as well and the same holds the other way. Secondly,
> the cummulative knowledge of this community is so big that thinking
> that an individual with a fork "always knows better" is quite a bold
> thinking and I actually want to know what others think about what I am
> doing and constructively criticize me for it.
>
> On Wed, Oct 22, 2025 at 12:34 AM Josh McKenzie <jm...@apache.org>
> wrote:
> >
> > To clarify: I don't think we should try and get rid of all forking and I
> didn't read any of our prior or this discussion as that absolute. I think
> some reasons for forking are healthy, and other reasons for forking are
> redundant and wasteful. We should celebrate the former and try and root out
> the latter.
> >
> > For example: if someone has written a feature to a GA branch and
> upstreamed it, and then we don't cut a release for multiple years and don't
> cut alphas from trunk, I'd contend our processes are encouraging low-value,
> redundant, wasteful fork maintenance. Or forcing people to qualify bespoke
> releases from arbitrary SHAs on trunk and running the database based on
> that which I expect most people wouldn't be too comfortable doing.
> >
> > Hence my desire to try and map out why people are forking. For instance:
> I think most people could agree that we shouldn't target completely getting
> rid of forks for reason #1: "You need bespoke code to integrate with
> internal infrastructure". We could take that as a sign to improve users'
> lives there by making integration points easier to write to, formalize some
> APIs, document them, etc.
> >
> > On Tue, Oct 21, 2025, at 2:07 PM, C. Scott Andreas wrote:
> >
> > There’s a common motivation at the root of any fork: having at least one
> patch that matters to you – perhaps one you’ve written yourself – and
> having complete and total control over your ability to run it. Isaac's
> example of C-20749 is a good example of this.
> >
> > This is the classic story of open source, and for me it’s a positive one.
> >
> > Releases published by the Apache Cassandra project are solid and stable.
> It’s *also* true that many users pretty aggressively editorialize
> distributions of the database they deploy. These can include urgent fixes
> for bugs they’ve identified and patched; removal/disabling of features they
> haven’t qualified; or incubation of patches they intend to contribute
> upstream. These are all positive motivations, and something that open
> source enables.
> >
> > I don’t agree that the existence of “forks” is a negative or that
> eliminating them is a desirable or achievable goal. Folks will always want
> or need to be able to apply a patch that matters to them to solve a problem
> or scratch an itch - and they should.
> >
> > If and as we learn that many users of a particular release have a common
> challenge, our process of DISCUSS + backport provides a path to meet that
> need, and I think we should exercise it more often. I see Isaac's example
> of C-20749 as a good candidate for that as well.
> >
> > – Scott
> >
> > On Oct 21, 2025, at 9:12 AM, Isaac Reath <is...@gmail.com> wrote:
> >
> >
> > I'd say the biggest reasons to me are (1) and (2). For example, we
> recently worked on CASSANDRA-20749 due to an internal need for this
> functionality, and fortunately we’ve been able to bring it upstream. But,
> since we run 4.1 and 5.0, we brought this patch back to these versions so
> that we are able to use this feature today.
> >
> >
> > To your point in (3), I'd say it's easier to qualify a release built off
> of a stable GA than trunk, especially once the GA release has gotten to
> where 4.1 is. I’d love to get to the point where we’re qualifying and
> running trunk builds in production, but even when we get there I still see
> a world where we still need to run the latest GA alongside trunk which
> would still motivate us to bring patches back to the latest GA where we
> need them.
> >
> >
> > On Mon, Oct 20, 2025 at 3:24 PM Josh McKenzie <jm...@apache.org>
> wrote:
> >
> >
> > We had a long conversation about the potential of piloting a supported
> backport release branch here:
> https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
> >
> > When I tried to summarize the thread and identify next steps, one
> observation stood out: I think we did a good job establishing the shape of
> the challenge we'd like to address (people want to work on OSS, not
> maintain private forks), but I don't think we got to the root of why this
> challenge exists. If we take action now we run the risk of having the wrong
> solution to the right problem.
> >
> > So: why are people running forks? Some reasons I've seen brought up:
> >
> > You need bespoke code to integrate with internal infrastructure
> > You've written a new feature targeting your internal version, upstreamed
> the code, and have to wait for the feature to be in a GA release
> > Someone else has contributed a feature to trunk that's attractive and
> it's less work or more palatable to back-port it to your private fork and
> maintain the diff than to qualify a custom release off trunk
> > You have stability concerns with GA releases or running a release based
> off trunk
> >
> > The backport branch we discussed in the previous thread would primarily
> address #4 (stability concerns) and secondarily #2 and #3 (feature
> availability). All four motivations could be addressed in other
> ways—ideally by reducing the pressure to fork in the first place, rather
> than accommodating forks as inevitable.
> >
> > If you're running a fork and open to sharing your experience, do these
> reasons match yours, or is something else at play? The more detail we can
> gather, the better we can target improvements where they'll actually help.
> >
> > I know these conversations take time and can be hard; I appreciate
> everyone taking the time and energy to help us collectively improve.
> >
> > ~Josh
> >
> >
> >
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
To your point Stefan, I honestly think if we:
 • Released a new GA once a year like clockwork
 • Cut alphas from trunk every month or 3 months
 • Kept CI green (rigorous and pain-free running of pre-commit, git revert on things that break tests)
 • Had new features have the following properties:
   • Documented (dev, user, operator, code)
   • Off by default; feature flagged
   • Thoroughly tested (unit, property, integration, fuzz, jmh perf at least where appropriate)
then it'd be easier for someone who wanted to add a new feature to their fleet to just author it against trunk and qualify the next alpha for their specific use-case, adopting it fleet wide when the next major hit.

This would satisfy the "don't want to run a fork" crowd, align with the "trunk should be releasable" sentiment Ariel drummed on years ago, and help with the "we need more people to qualify and stabilize trunk" sentiment Scott rightly expressed.

So far this seems to improve all the pressures people have brought up for why they run forks excepting the "need to integrate with my own platform".

On Thu, Oct 23, 2025, at 12:56 PM, Štefan Miklošovič wrote:
> Great continuation of the original thread.
> 
> 
> We do not run forks. Our business model is completely different. What
> Apache Cassandra releases is what you will get. That's it. Vanilla. So
> in some sense when the whole backporting idea was proposed I was kind
> of not understanding all of that but I am quite sympathetic to the
> problems of others and in some way I feel sorry that you have to all
> go through this because we just don't.
> 
> When there is a problem to be solved, first of all we look into how it
> might be fixed upstream and be released as part of the official
> release. A lot of customers actually want to run "the official thing"
> and they do not want to run the forks. Forks are hard to maintain,
> each client would be running a different fork, that is hard to track
> over time and so on.
> 
> If you are a company which is self-contained and big enough to run
> internal fork I get it, but there are also people who don't want to
> see any forks, they just want to run the release in its purest form.
> Because they trust the community which is driving it more than a
> couple individuals who would fork it.
> 
> If we want to make something upstream, there needs to be somebody to
> drive and deliver it (me) and ideally who can release it (me). I don't
> even need a private CI. Why? We have one, pre-ci. So, I can release
> basically whenever I want. Why would I want to have a fork? There is
> no reason for that.
> 
> I also think that cooperation in the broader community on your patch
> (or patches of others) is better. It gets rid of a whole class of
> problems. If I fix some bug or feature, I am most probably fixing it
> for somebody else as well and the same holds the other way. Secondly,
> the cummulative knowledge of this community is so big that thinking
> that an individual with a fork "always knows better" is quite a bold
> thinking and I actually want to know what others think about what I am
> doing and constructively criticize me for it.
> 
> On Wed, Oct 22, 2025 at 12:34 AM Josh McKenzie <jm...@apache.org> wrote:
> >
> > To clarify: I don't think we should try and get rid of all forking and I didn't read any of our prior or this discussion as that absolute. I think some reasons for forking are healthy, and other reasons for forking are redundant and wasteful. We should celebrate the former and try and root out the latter.
> >
> > For example: if someone has written a feature to a GA branch and upstreamed it, and then we don't cut a release for multiple years and don't cut alphas from trunk, I'd contend our processes are encouraging low-value, redundant, wasteful fork maintenance. Or forcing people to qualify bespoke releases from arbitrary SHAs on trunk and running the database based on that which I expect most people wouldn't be too comfortable doing.
> >
> > Hence my desire to try and map out why people are forking. For instance: I think most people could agree that we shouldn't target completely getting rid of forks for reason #1: "You need bespoke code to integrate with internal infrastructure". We could take that as a sign to improve users' lives there by making integration points easier to write to, formalize some APIs, document them, etc.
> >
> > On Tue, Oct 21, 2025, at 2:07 PM, C. Scott Andreas wrote:
> >
> > There’s a common motivation at the root of any fork: having at least one patch that matters to you – perhaps one you’ve written yourself – and having complete and total control over your ability to run it. Isaac's example of C-20749 is a good example of this.
> >
> > This is the classic story of open source, and for me it’s a positive one.
> >
> > Releases published by the Apache Cassandra project are solid and stable. It’s *also* true that many users pretty aggressively editorialize distributions of the database they deploy. These can include urgent fixes for bugs they’ve identified and patched; removal/disabling of features they haven’t qualified; or incubation of patches they intend to contribute upstream. These are all positive motivations, and something that open source enables.
> >
> > I don’t agree that the existence of “forks” is a negative or that eliminating them is a desirable or achievable goal. Folks will always want or need to be able to apply a patch that matters to them to solve a problem or scratch an itch - and they should.
> >
> > If and as we learn that many users of a particular release have a common challenge, our process of DISCUSS + backport provides a path to meet that need, and I think we should exercise it more often. I see Isaac's example of C-20749 as a good candidate for that as well.
> >
> > – Scott
> >
> > On Oct 21, 2025, at 9:12 AM, Isaac Reath <is...@gmail.com> wrote:
> >
> >
> > I'd say the biggest reasons to me are (1) and (2). For example, we recently worked on CASSANDRA-20749 due to an internal need for this functionality, and fortunately we’ve been able to bring it upstream. But, since we run 4.1 and 5.0, we brought this patch back to these versions so that we are able to use this feature today.
> >
> >
> > To your point in (3), I'd say it's easier to qualify a release built off of a stable GA than trunk, especially once the GA release has gotten to where 4.1 is. I’d love to get to the point where we’re qualifying and running trunk builds in production, but even when we get there I still see a world where we still need to run the latest GA alongside trunk which would still motivate us to bring patches back to the latest GA where we need them.
> >
> >
> > On Mon, Oct 20, 2025 at 3:24 PM Josh McKenzie <jm...@apache.org> wrote:
> >
> >
> > We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
> >
> > When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
> >
> > So: why are people running forks? Some reasons I've seen brought up:
> >
> > You need bespoke code to integrate with internal infrastructure
> > You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
> > Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
> > You have stability concerns with GA releases or running a release based off trunk
> >
> > The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
> >
> > If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
> >
> > I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
> >
> > ~Josh
> >
> >
> >
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Štefan Miklošovič <sm...@apache.org>.
Great continuation of the original thread.


We do not run forks. Our business model is completely different. What
Apache Cassandra releases is what you will get. That's it. Vanilla. So
in some sense when the whole backporting idea was proposed I was kind
of not understanding all of that but I am quite sympathetic to the
problems of others and in some way I feel sorry that you have to all
go through this because we just don't.

When there is a problem to be solved, first of all we look into how it
might be fixed upstream and be released as part of the official
release. A lot of customers actually want to run "the official thing"
and they do not want to run the forks. Forks are hard to maintain,
each client would be running a different fork, that is hard to track
over time and so on.

If you are a company which is self-contained and big enough to run
internal fork I get it, but there are also people who don't want to
see any forks, they just want to run the release in its purest form.
Because they trust the community which is driving it more than a
couple individuals who would fork it.

If we want to make something upstream, there needs to be somebody to
drive and deliver it (me) and ideally who can release it (me). I don't
even need a private CI. Why? We have one, pre-ci. So, I can release
basically whenever I want. Why would I want to have a fork? There is
no reason for that.

I also think that cooperation in the broader community on your patch
(or patches of others) is better. It gets rid of a whole class of
problems. If I fix some bug or feature, I am most probably fixing it
for somebody else as well and the same holds the other way. Secondly,
the cummulative knowledge of this community is so big that thinking
that an individual with a fork "always knows better" is quite a bold
thinking and I actually want to know what others think about what I am
doing and constructively criticize me for it.

On Wed, Oct 22, 2025 at 12:34 AM Josh McKenzie <jm...@apache.org> wrote:
>
> To clarify: I don't think we should try and get rid of all forking and I didn't read any of our prior or this discussion as that absolute. I think some reasons for forking are healthy, and other reasons for forking are redundant and wasteful. We should celebrate the former and try and root out the latter.
>
> For example: if someone has written a feature to a GA branch and upstreamed it, and then we don't cut a release for multiple years and don't cut alphas from trunk, I'd contend our processes are encouraging low-value, redundant, wasteful fork maintenance. Or forcing people to qualify bespoke releases from arbitrary SHAs on trunk and running the database based on that which I expect most people wouldn't be too comfortable doing.
>
> Hence my desire to try and map out why people are forking. For instance: I think most people could agree that we shouldn't target completely getting rid of forks for reason #1: "You need bespoke code to integrate with internal infrastructure". We could take that as a sign to improve users' lives there by making integration points easier to write to, formalize some APIs, document them, etc.
>
> On Tue, Oct 21, 2025, at 2:07 PM, C. Scott Andreas wrote:
>
> There’s a common motivation at the root of any fork: having at least one patch that matters to you – perhaps one you’ve written yourself – and having complete and total control over your ability to run it. Isaac's example of C-20749 is a good example of this.
>
> This is the classic story of open source, and for me it’s a positive one.
>
> Releases published by the Apache Cassandra project are solid and stable. It’s *also* true that many users pretty aggressively editorialize distributions of the database they deploy. These can include urgent fixes for bugs they’ve identified and patched; removal/disabling of features they haven’t qualified; or incubation of patches they intend to contribute upstream. These are all positive motivations, and something that open source enables.
>
> I don’t agree that the existence of “forks” is a negative or that eliminating them is a desirable or achievable goal. Folks will always want or need to be able to apply a patch that matters to them to solve a problem or scratch an itch - and they should.
>
> If and as we learn that many users of a particular release have a common challenge, our process of DISCUSS + backport provides a path to meet that need, and I think we should exercise it more often. I see Isaac's example of C-20749 as a good candidate for that as well.
>
> – Scott
>
> On Oct 21, 2025, at 9:12 AM, Isaac Reath <is...@gmail.com> wrote:
>
>
> I'd say the biggest reasons to me are (1) and (2). For example, we recently worked on CASSANDRA-20749 due to an internal need for this functionality, and fortunately we’ve been able to bring it upstream. But, since we run 4.1 and 5.0, we brought this patch back to these versions so that we are able to use this feature today.
>
>
> To your point in (3), I'd say it's easier to qualify a release built off of a stable GA than trunk, especially once the GA release has gotten to where 4.1 is. I’d love to get to the point where we’re qualifying and running trunk builds in production, but even when we get there I still see a world where we still need to run the latest GA alongside trunk which would still motivate us to bring patches back to the latest GA where we need them.
>
>
> On Mon, Oct 20, 2025 at 3:24 PM Josh McKenzie <jm...@apache.org> wrote:
>
>
> We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>
> When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
>
> So: why are people running forks? Some reasons I've seen brought up:
>
> You need bespoke code to integrate with internal infrastructure
> You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
> Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
> You have stability concerns with GA releases or running a release based off trunk
>
> The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
>
> If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
>
> I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
>
> ~Josh
>
>
>

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Josh McKenzie <jm...@apache.org>.
To clarify: I don't think we should try and get rid of all forking and I didn't read any of our prior or this discussion as that absolute. I think some reasons for forking are healthy, and other reasons for forking are redundant and wasteful. We should celebrate the former and try and root out the latter.

For example: if someone has written a feature to a GA branch and upstreamed it, and then we don't cut a release for multiple years and don't cut alphas from trunk, I'd contend our processes are encouraging low-value, redundant, wasteful fork maintenance. Or forcing people to qualify bespoke releases from arbitrary SHAs on trunk and running the database based on that which I expect most people wouldn't be too comfortable doing.

Hence my desire to try and map out why people are forking. For instance: I think most people could agree that we shouldn't target completely getting rid of forks for reason #1: "You need bespoke code to integrate with internal infrastructure". We could take that as a sign to improve users' lives there by making integration points easier to write to, formalize some APIs, document them, etc.

On Tue, Oct 21, 2025, at 2:07 PM, C. Scott Andreas wrote:
> There’s a common motivation at the root of any fork: having at least one patch that matters to you – perhaps one you’ve written yourself – and having complete and total control over your ability to run it. Isaac's example of C-20749 is a good example of this.
> 
> This is the classic story of open source, and for me it’s a positive one.
> 
> Releases published by the Apache Cassandra project are solid and stable. It’s *also* true that many users pretty aggressively editorialize distributions of the database they deploy. These can include urgent fixes for bugs they’ve identified and patched; removal/disabling of features they haven’t qualified; or incubation of patches they intend to contribute upstream. These are all positive motivations, and something that open source enables.
> 
> I don’t agree that the existence of “forks” is a negative or that eliminating them is a desirable or achievable goal. Folks will always want or need to be able to apply a patch that matters to them to solve a problem or scratch an itch - and they should.
> 
> If and as we learn that many users of a particular release have a common challenge, our process of DISCUSS + backport provides a path to meet that need, and I think we should exercise it more often. I see Isaac's example of C-20749 as a good candidate for that as well.
> 
> – Scott
> 
>> On Oct 21, 2025, at 9:12 AM, Isaac Reath <is...@gmail.com> wrote:
>> 
>> 
>> I'd say the biggest reasons to me are (1) and (2). For example, we recently worked on _CASSANDRA-20749_ <https://issues.apache.org/jira/browse/CASSANDRA-20749> due to an internal need for this functionality, and fortunately we’ve been able to bring it upstream. But, since we run 4.1 and 5.0, we brought this patch back to these versions so that we are able to use this feature today. 
>> 
>> 
>> To your point in (3), I'd say it's easier to qualify a release built off of a stable GA than trunk, especially once the GA release has gotten to where 4.1 is. I’d love to get to the point where we’re qualifying and running trunk builds in production, but even when we get there I still see a world where we still need to run the latest GA alongside trunk which would still motivate us to bring patches back to the latest GA where we need them. 
>> 
>> 
>> On Mon, Oct 20, 2025 at 3:24 PM Josh McKenzie <jm...@apache.org> wrote:
>>> __
>>> We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>>> 
>>> When I tried to summarize the thread and identify next steps, one observation stood out: I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem.
>>> 
>>> So: why are people running forks? Some reasons I've seen brought up:
>>>  1. You need bespoke code to integrate with internal infrastructure
>>>  2. You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release
>>>  3. Someone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk
>>>  4. You have stability concerns with GA releases or running a release based off trunk
>>> The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable.
>>> 
>>> If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help.
>>> 
>>> I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve.
>>> 
>>> ~Josh
>>> 
> 

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by "C. Scott Andreas" <sc...@paradoxica.net>.
There’s a common motivation at the root of any fork: having at least one patch that matters to you – perhaps one you’ve written yourself – and having complete and total control over your ability to run it. Isaac's example of C-20749 is a good example of this. This is the classic story of open source, and for me it’s a positive one. Releases published by the Apache Cassandra project are solid and stable. It’s *also* true that many users pretty aggressively editorialize distributions of the database they deploy. These can include urgent fixes for bugs they’ve identified and patched; removal/disabling of features they haven’t qualified; or incubation of patches they intend to contribute upstream. These are all positive motivations, and something that open source enables. I don’t agree that the existence of “forks” is a negative or that eliminating them is a desirable or achievable goal. Folks will always want or need to be able to apply a patch that matters to them to solve a problem or scratch an itch - and they should. If and as we learn that many users of a particular release have a common challenge, our process of DISCUSS + backport provides a path to meet that need, and I think we should exercise it more often. I see Isaac's example of C-20749 as a good candidate for that as well. – Scott On Oct 21, 2025, at 9:12 AM, Isaac Reath <is...@gmail.com> wrote: I'd say the biggest reasons to me are (1) and (2). For example, we recently worked on CASSANDRA-20749 due to an internal need for this functionality, and fortunately we’ve been able to bring it upstream. But, since we run 4.1 and 5.0, we brought this patch back to these versions so that we are able to use this feature today. To your point in (3), I'd say it's easier to qualify a release built off of a stable GA than trunk, especially once the GA release has gotten to where 4.1 is. I’d love to get to the point where we’re qualifying and running trunk builds in production, but even when we get there I still see a world where we still need to run the latest GA alongside trunk which would still motivate us to bring patches back to the latest GA where we need them. On Mon, Oct 20, 2025 at 3:24 PM Josh McKenzie < jmckenzie@apache.org > wrote: We had a long conversation about the potential of piloting a supported backport release branch here: https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k When I tried to summarize the thread and identify next steps, one observation stood out : I think we did a good job establishing the shape of the challenge we'd like to address (people want to work on OSS, not maintain private forks), but I don't think we got to the root of why this challenge exists. If we take action now we run the risk of having the wrong solution to the right problem. So: why are people running forks? Some reasons I've seen brought up: You need bespoke code to integrate with internal infrastructure You've written a new feature targeting your internal version, upstreamed the code, and have to wait for the feature to be in a GA release S omeone else has contributed a feature to trunk that's attractive and it's less work or more palatable to back-port it to your private fork and maintain the diff than to qualify a custom release off trunk You have stability concerns with GA releases or running a release based off trunk The backport branch we discussed in the previous thread would primarily address #4 (stability concerns) and secondarily #2 and #3 (feature availability). All four motivations could be addressed in other ways—ideally by reducing the pressure to fork in the first place, rather than accommodating forks as inevitable. If you're running a fork and open to sharing your experience, do these reasons match yours, or is something else at play? The more detail we can gather, the better we can target improvements where they'll actually help. I know these conversations take time and can be hard; I appreciate everyone taking the time and energy to help us collectively improve. ~Josh

Re: [DISCUSS] Understanding fork motivations (backport branch follow-up)

Posted by Isaac Reath <is...@gmail.com>.
I'd say the biggest reasons to me are (1) and (2). For example, we recently
worked on CASSANDRA-20749
<https://issues.apache.org/jira/browse/CASSANDRA-20749> due to an internal
need for this functionality, and fortunately we’ve been able to bring it
upstream. But, since we run 4.1 and 5.0, we brought this patch back to
these versions so that we are able to use this feature today.

To your point in (3), I'd say it's easier to qualify a release built off of
a stable GA than trunk, especially once the GA release has gotten to where
4.1 is. I’d love to get to the point where we’re qualifying and running
trunk builds in production, but even when we get there I still see a world
where we still need to run the latest GA alongside trunk which would still
motivate us to bring patches back to the latest GA where we need them.

On Mon, Oct 20, 2025 at 3:24 PM Josh McKenzie <jm...@apache.org> wrote:

> We had a long conversation about the potential of piloting a supported
> backport release branch here:
> https://lists.apache.org/thread/xbxt21rttsqvhmh8ds9vs2cr7fx27w3k
>
> When I tried to summarize the thread and identify next steps, one
> observation stood out: I think we did a good job establishing the shape
> of the challenge we'd like to address (people want to work on OSS, not
> maintain private forks), but I don't think we got to the root of why this
> challenge exists. If we take action now we run the risk of having the wrong
> solution to the right problem.
>
> So: why are people running forks? Some reasons I've seen brought up:
>
>    1. You need bespoke code to integrate with internal infrastructure
>    2. You've written a new feature targeting your internal version,
>    upstreamed the code, and have to wait for the feature to be in a GA release
>    3. Someone else has contributed a feature to trunk that's attractive
>    and it's less work or more palatable to back-port it to your private fork
>    and maintain the diff than to qualify a custom release off trunk
>    4. You have stability concerns with GA releases or running a release
>    based off trunk
>
> The backport branch we discussed in the previous thread would primarily
> address #4 (stability concerns) and secondarily #2 and #3 (feature
> availability). All four motivations could be addressed in other
> ways—ideally by reducing the pressure to fork in the first place, rather
> than accommodating forks as inevitable.
>
> If you're running a fork and open to sharing your experience, do these
> reasons match yours, or is something else at play? The more detail we can
> gather, the better we can target improvements where they'll actually help.
>
> I know these conversations take time and can be hard; I appreciate
> everyone taking the time and energy to help us collectively improve.
>
> ~Josh
>
>