Say you want to contribute to a project and find out the only way to do so is by discussing the issue on IRC or the mailing list, then submitting the patch per email.
To anyone interested, there is a comprehensive tutorial about how to use Git with email to contribute to projects like these.
https://git-send-email.io/
I spent a lot of time and energy doing that years ago and don't want to do it anymore. Mailing lists suck because you're subscribed to a billion things you don't want to hear about. IRC...honestly...the world has just moved past it.
I’m sad the world moved past IRC. It was always chock full of tech geniuses and underground nerd shit. The normies can have discord
This is my sentiment too and I asked the question because I was surprised that some new projects were actually being started with exactly these 2 dinosaurs. It felt offputting - as if they were trying to keep people away.
Lemmy doesn't support questionnaires, but it wouldn't surprise me if the majority of those who like those 2 technologies were 40+, maybe even 50+.
Agree with many of the other comments here saying that they'd be very wary of such a project based on what these choices say about the project's maintainers. Something else is that while I have real affection for email and particularly IRC based on past experience, I don't think these two are without problems. Email is so asynchronous that many folks feel obligated to treat writing messages to a list more formally. This is not totally misguided since everyone subscribed gets this message delivered to them. IRC, on the other hand, is so synchronous that you should reasonably worry if anyone will be there to talk with, and about whether or not there are searchable archives.
Something (like GitHub) that can be quick but is also perfectly serviceable for asynchronous communication really does have advantages, imho.
Mailing lists intimidate me but I haven't ever tried to communicate by one. IRC is probably fine.
I'll be honest though, I'm not going to submit a patch to a mailing list unless there are pretty clear and easy instructions. Forking a project and opening a pull request on whatever forge (like GitHub, GitLab, and others) is easy. I probably do it once every three months or so when I find a bug I know I can fix. Mailing lists are just enough trouble (with my current level of understanding) that I'm probably not going to do it.
I'll give an example. I found a bug in the JDK that was fixed in 17 but not in 11 and I was trying to figure out how to report it or backport it myself. It was crazy the amount of hoops I needed to jump through and I gave up. I'm not saying the project should be different so it fits my needs or anything, I'm just using this as an example of hurdles discouraging me from contributing. I think the vast majority of devs are probably at the same place and don't want to fool with mailing lists. (I'm not saying projects should stop using them.)
IRC is fine for almost synchronous communication - but dealing with things that work on the timescale of days or weeks, IRC becomes difficult to maintain a discussion about a fix or feature over that timeframe that includes all the interested participants.
Mailing lists often come with an archive and a sufficiently large project will have multiple lists for different aspects of the project. Consider gcc ( https://gcc.gnu.org/lists.html )and you'll see that bugs and patches are their own lists. Going into there you can also see the archives for the project... and if the mailing list software has support for it, viable by thread https://gcc.gnu.org/pipermail/gcc-bugs/
https://lkml.org/lkml/2013/11/25/519 is another fun read (that entire thread).
git has support for (and was originally used via) email.
git send-email(docs) andgit am(docs) are part of its original functionality and that workflow can make use if it.I'm personally most comfortable with GitHub or GitLab, followed by email. An IRC or discord project lacks the ability to properly research the "why was this done that way back in 2016"... unless the project doesn't aspire to be a long lived open source project.
Managing email is something that should be considered as part of this. Setting up a separate email address for that project, or using the + addressing as part of the email to make it so that your email filters can operate on them better (Exchange, gmail). This may require deeper familiarity with email clients than is common today - smart mailboxes in Mac Mail, client side rules in Exchange, or old school procmail with a shell account.
I totally agree longterm projects are better off using github or email.
Here is the crux for lively discussions using discord/IRC comes more natural. But whilst it facilitates easier flowing communication it fails to preserve it.
Same. Presented with those options, I just don't contribute 🤷
I never really used IRC, but in my experience contributing to projects which use mailing lists is very easy - you just send a mail with some code.
Of course you could use git-send-email, and you could create diffs and patches, but I actually think for a new contributor the mailing list workflow is the simplest since it doesn’t actually require knowledge of the various tools experienced developers use.
I write this from personal experience BTW - the first projects I contributed to used mailing lists, which allowed me to contribute even as a self taught programmer who had no experience with any VCS yet.
Do you find mailing lists easier to use than pull requests / merge requests? And how do you find following a discussion in a mailing list?
From a contributor point of view, mailing lists are definitely easier than pull/merge requests - you just send a patch which you can create in any way you want to an email address.
Following a discussion is easy - it’s just a list of messages. In fact, it is easier for me since I use Gnus as my email client, which gives me a threaded view of discussions on the list.
Yes and it depends to both questions.
I participate in projects being developed on Github that have 5k+ open pull requests and the same amount of issues. At that volume of communication, the Github workflow of "clicking through stuff" is way inferior to an efficient email workflow. Essentially, your workflow turns into email anyways because its the only sane way to consume based on push, and yes, I know, you can reply to Github using email, but its not nearly as good as something made for email.
So, in my opinion, email is simpler to use that pull request. It is not easiser because it is not close to what people are used to.
At that volume of communication, the Github workflow of “clicking through stuff” is way inferior to an efficient email workflow. Essentially, your workflow turns into email anyways because its the only sane way to consume based on push (...)
I don't agree. Any conversation on pull requests happens through issues/tickets, which already aggregate all related events and are trivially referenced through their permanent links, including through the Git repo's history.
It would have to be a pretty niche project with an involved and dedicated community to get away with that these days.
I agree with those saying mailing lists are intimidating. I don't know if others are using dedicated tools or something but I find web based mailing list UIs just incomprehensibly bad and difficult to navigate.
Most web-based mailing list UIs are honestly incredibly bad, but you don’t need to use them, you can choose any email client you want.
The problem with mailing lists is that no mailing list provider ever supports "subscribe to this message tree".
As a result, either you get constant spam, or you don't get half the replies.
I sort messages from mailing lists into different mail folders, and my client (Gnus) supports a threaded view of messages (and I can press ‘k’ on a message to mark the entire thread as read), so this isn’t a big issue for me.
If mailing lists had a view like reddit / lemmy / slashdot / hackernews, I might be more willing to use them, but that wouldn't solve contributions for me. I have no idea how to format emails to comment on code and then follow ensuing discussions. And how would CI work?
If you feel like learning more about it, there is a great tutorial available:
https://discuss.tchncs.de/comment/3347883
I like IRC and still use it daily to keep up with other hobbyists. Then again, vintage computers are my main hobby horse and of course those circles are gonna lean towards platforms that remain usable on a VIC-20.
I never really got used to IRC myself, but it's usually fine when connecting to IRC via Matrix.
BTW, what other communication channels would you have expected?
Primarily an issue tracker on codeberg, gitlab, github, or something with support for pull requests / merge requests for contributions. Direct communication is secondary for most projects, IMO unless it's big/used enough that users require direct support - in which case: Matrix.
I wouldn't want a new project to be run that way, but contributing to older existing projects really isn't that bad.
Projects like that make me want to create a uucp network and so I can email a bang path address to get my patch.
I'm still trying to figure out github. I am at the beginning of my computer learning journey.
