|
|
Subscribe / Log in / New account

Reducing kernel-maintainer burnout

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 16:27 UTC (Sat) by wtarreau (subscriber, #51152)
In reply to: Reducing kernel-maintainer burnout by karim
Parent article: Reducing kernel-maintainer burnout

It's important to consider the maintainer side more than the contributor's side. Patches and contributors are not missing, maintainers are. For occasionally having to discuss patches in a browser on github for example, I can't say how much I hate doing this. Having to suggest code examples in text areas which do not even support vertical selection, indent, text replace etc, the difficulty to get the patch locally and apply it to a tree etc, all of this is totally deterring. Not to mention the mess it becomes once multiple people start to discuss and nobody knows anymore who responds to whom because of the linear format. Also when contributors send updated versions I find it even more complicated to keep everything in context or compare comments etc. I'm not saying this is necessarily the case for gerrit but I don't see how it would work around all these browser limitations.

Browser-based tools are extremely inefficient for intensive use and try hard to compensate for the UI deficiencies by implementing features that are supposed to make your life a bit easier, but in practice they only ease contributors' lives at the expense of the person in charge of the final merge. Ah and when you want to perform minor edits before merging a patch, it becomes so difficult compared to just clicking on a merge button that it's not surprising to see the abysmal quality of commit messages on projects mostly developed through browsers like many of those hosted on github/gitlab for example.

One particularity of the linux kernel project that I think makes it unique is that it has thousands of maintainers. All of them regularly need to interact with others because changes often step on other areas, and they can't always be authoritative when responding to a contributor because of this. There's a very long people dependency chain that's often visible in discussions where developers discuss what part should go through which tree for example. What is needed there is lower latency in exchanges and/or a lower number of exchanges (i.e. more rights to many maintainers). If more maintainers were able to push their changes instead of imploring someone else to queue them for the next 3 months without being able to count on them, it would certainly change a lot of things for their activities!


to post comments

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 16:45 UTC (Sat) by laurent.pinchart (subscriber, #71290) [Link] (6 responses)

> Having to suggest code examples in text areas which do not even support vertical selection, indent, text replace etc, the difficulty to get the patch locally and apply it to a tree etc, all of this is totally deterring.

This is also one of my major pain points with web-based UIs *for reviews*. They are all terrible compared to real text editors.

When discussing e-mail vs. web-based UIs, two separate discussions seem to always be mixed together. I believe the vast majority of developers, including kernel developers and maintainers, don't claim that mail clients are good for *tracking* the status of patches. That why we have patchwork and other similar tools, and git forges do a reasonable job there too compared to mail clients. When it comes to *reviewing* code, however, web-based UIs are just terrible.

> it's not surprising to see the abysmal quality of commit messages on projects mostly developed through browsers like many of those hosted on github/gitlab for example

I'm appalled that after so many years neither github nor gitlab has implemented the ability to comment on a commit message. I agree this is likely one of the factors that explain why so many projects have terrible commit message hygiene. Surely this can't be that complex to implement compared to the zillions of features that those forges provide, which makes me wonder if they have consciously decided not to provide the feature, have never tried their own dog good, or if github/gitlab are also developed with bad commit message hygiene.

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 18:49 UTC (Sat) by Sesse (subscriber, #53779) [Link] (3 responses)

> When it comes to *reviewing* code, however, web-based UIs are just terrible.

I used to feel the same. But web-based UIs have a huge advantage over email: It's easy to see which comments have been addressed, and which ones still need your attention. It's like having one little email thread per comment, which is really nice—so it's the advantage of something like Patchworks, but on a much finer scale.

(I've mainly used some Google-internal tools and Gerrit; both are fine by me. But I'm not a kernel maintainer.)

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 9:58 UTC (Sun) by adobriyan (subscriber, #30858) [Link] (2 responses)

> But web-based UIs have a huge advantage over email: It's easy to see which comments have been addressed, and which ones still need your attention.

Yes! The ability to point specific line and write comment near it (in a monospace font!) is what's needed.
Deleting unused lines in email client before reply is waste of time after all.

> (I've mainly used some Google-internal tools and Gerrit; both are fine by me. But I'm not a kernel maintainer.)

Gerrit is cool (unless coworkers are slacking on reviewing your diffs and then it is not cool anymore).

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 17:13 UTC (Sun) by khim (subscriber, #9252) [Link] (1 responses)

> The ability to point specific line and write comment near it (in a monospace font!) is what's needed.

Gerrit uses Markdown so you write in a monospace font like this:

Here is how I would do that:
```
if (foo) {
  ...
} else {
  ...
}
```

Here's just some random example. Where, ironically, enough, you may see discussion about commit message with embedded code snippets in a monospaced font.

I haven't looked for that, just clicked on some change with large number of unadressed comments.

Not sure how well Gerrit would scale to the Linux kernel scale, but if there are limited number of reviewers it works very nicely: each “subdiscussion” is attached to some piece of code and there's status to know if it's addressed or not, you may easily see how many complains are not addressed.

The biggest issue is that often when you address the comment and rewrite the code gerrit couldn't find the point to attach it in the new version of patch and then it just shows it at the top of the file. Then you open the previous version of patch and look on comments on the left and code on the right.

Not ideal, but not sure that part is handled by e-mail any better.

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 17:40 UTC (Sun) by excors (subscriber, #95769) [Link]

I think your example is a non-public link, but the same review is public here instead.

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 16:59 UTC (Sun) by khim (subscriber, #9252) [Link]

> I'm appalled that after so many years neither github nor gitlab has implemented the ability to comment on a commit message.

In Gerrit one may add comments to the commit message using the same approach used for code: select the piece and add inline comment.

> or if github/gitlab are also developed with bad commit message hygiene.

Most likely that. The assumption is that you would only used Git for code snapshots and all the metadata goes into Web interface instead.

I suspect that's even conscious decision to cause lock-in effect.

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 10:13 UTC (Mon) by fschrempf (subscriber, #160781) [Link]

> I'm appalled that after so many years neither github nor gitlab has implemented the ability to comment on a commit message. I agree this is likely one of the factors that explain why so many projects have terrible commit message hygiene. Surely this can't be that complex to implement compared to the zillions of features that those forges provide, which makes me wonder if they have consciously decided not to provide the feature, have never tried their own dog good, or if github/gitlab are also developed with bad commit message hygiene.

GitLab being an open-source project one could argue that simply no one ever cared enough to step up and implement the feature. The same argument kernel maintainers would use for some kernel related feature requests. Looking at the 6-year-old issue at https://gitlab.com/gitlab-org/gitlab/-/issues/19691 it looks like there has been some interest over the years but not enough for someone to actually do the necessary work.

And yes, a lot of projects developed on GitLab/GitHub suffer from bad commit message hygiene which is a pity in most cases, but some project development workflows are designed a lot differently than the kernel one and don't even really allow (or care?) to have a clean Git history (e. g. due to a lot of merge commit and bot commit noise).

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 18:21 UTC (Sat) by laf0rge (subscriber, #6469) [Link]

It's been ages since my active days as kernel developer or even subsystem maintainer. So I used to be very much used to / indoctrinated in the way how the Linux kernel development works.

I still maintan a number of open source software projects these days within the osmocom (open source mobile communications) project. Given my kernel background, we've originally started with a email + patch based system in 2008, added patchwork slightly later and have migated over to gerrit a number of years ago.

I have to say to me as a maintainer, reviewing and processing patches in gerrit is making my life much easier than an e-mail based workflow. Don't get me wrong, I am an e-mail person, I dislike GUIs, work all day on command line interfaces and I do read/write my e-mail in mutt. But still, gerrit is in my opinion a big benefit for the maintainer, unlike it was claimed earlier that it is a benefit for the patch submitter. I'd actually argue the other way around: For a random developer it's much easier to send a patch by e-mail than to install the git hooks for inserting the Change-ID and learning how to push stuff to gerrit.

I also don't get the comments made about "comments not being in-line with the code" or "linear comments". In gerrit, you are placing your comments right at the specific line[s] of code that you are commenting on, and the entire thread of comments is attached to that line of code.

I think a lot of the opinions against code review tools comes from the fact that most people have only seen github/gitlab/gitea style pull requests, which I as a maintainer consider a significantly inferiror tool the way how gerrit works. Gerrit doesn't know "pull requests", it knows individual patches. It tracks a single patch over any number of revisions. It can show you easily not just the current version of the patch, but the changes compared to any of the previous versions of it. It keeps code review at the specific location within the code. It allows you to track if a given comment raised in review is considered resolved or not. It warns you if you try to apply a patch that still has unresolved comments, etc.

For people who want to review / comment from the command line, there's a command line tool called "gerrit review" (see https://gerrit-documentation.storage.googleapis.com/Documentation/2.8/cmd-review.html) so you don't have to open your browser if you don't want to. I'm personaly not using it, but several of the osmocom developers do use it.

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 20:07 UTC (Sat) by roc (subscriber, #30627) [Link] (16 responses)

For people coming from outside the kernel community the email-based workflow is just horrible.

Github PRs exist as branches you can pull, which makes applying them to a tree very easy. The branch is named right at the top of the PR! On the other hand, it is not obvious how to apply patches from a pile of email messages to a tree, although I take your word for it that those "in the know" have some way to do it.

Likewise, most people's email clients make very poor code editors, but I take your word for it that those "in the know" have all developed email-based workflows that do incorporate good code editors for when you want to include code in review comments.

It makes sense to prioritize maintainer needs over contributor needs in a project like the kernel, where many people *have* to contribute to the kernel to get their work done so there's little downside to making that process arbitrarily difficult to get started with. And therefore it makes sense that you would never want to change processes that all the maintainers already know. But the gap between what most people use and how the kernel process works keeps growing.

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 20:33 UTC (Sat) by viro (subscriber, #7872) [Link] (15 responses)

Save the email in question into a (local) mailblox, then git am -s mailbox_file_name and you are done. If you want it as a merge, start a new branch, git am into it, then git merge. Or, if you are asked to pull from <branch name> in <repo>, you just say git pull <repo> <branch name>, assuming you can manage a cut and paste between your mail reader and your shell...

In any case, you are supposed to read and review the stuff in the branch; that's, er, somewhat more mentally taxing effort than any of the above.

As for the editors, I'm yet to find one in a browser that wouldn't be atrocious; used to be possible to have the damn thing start xterm and a sane editor in it, but that got broken. And yes, I'm using a browser to type that comment in - and hating every minute of it. For anything that requires minimally non-trivial manipulations of text (like, you know, search and replace with regular expressions, or pipe a block of text through a filter - trivial things like that) it would be extremely painful.

Reducing kernel-maintainer burnout

Posted Nov 25, 2023 22:47 UTC (Sat) by laurent.pinchart (subscriber, #71290) [Link] (2 responses)

> As for the editors, I'm yet to find one in a browser that wouldn't be atrocious;

I stopped counting the number of times I pressed ctrl-w to delete the word I had just typed in a browser-based text editor. Just thinking about it makes me want to scream.

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 2:59 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link] (1 responses)

There are several extensions for FF (and probably Chrome) that override the hotkeys.

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 17:13 UTC (Sun) by gray_-_wolf (subscriber, #131074) [Link]

> There are several extensions for FF (and probably Chrome) that override the hotkeys.

But those (as far as I know) do not (and cannot) work on privileged pages (about:config, addons.mozzila.org, ...). Which is annoying.

What did work for me is to just build my own firefox with modified key bindings: https://git.sr.ht/~graywolf/gecko-dev/commit/7648188f9751... . I assume it is possible without the compilation, but I found now documentation for it. And I am rebuilding anyway...

It can be combined with following in .config/gtk-3.0/gtk.css to get actual C-w working everywhere:

@binding-set text-entry
{
bind "<Control>w"
{
"delete-from-cursor" (word-ends, -1)
};
}

entry { -gtk-key-bindings: text-entry; }
textview { -gtk-key-bindings: text-entry; }

Offtopic: I also prefer SHIFT+INSERT to paste PRIMARY instead of CLIPBOARD, so https://git.sr.ht/~graywolf/gecko-dev/commit/46b121a7a550... is nice as well (albeit bit hackish).

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 13:03 UTC (Sun) by kleptog (subscriber, #1183) [Link] (8 responses)

> Save the email in question into a (local) mailblox, then git am -s mailbox_file_name and you are done. If you want it as a merge, start a new branch, git am into it, then git merge.

Maybe it's just me, but the idea I actually need to apply a patch to a local branch to review it seems, well, suboptimal. After all, I may be managing several projects, and many patches and having to manage all those branches just seems like unnecessary work. Compared to something like Gerrit where the patch is already applied, I can simply view the change and move through the diff and make comments directly just seems much easier. Patches that don't apply cleanly, or fail the build step are already filtered out for you.

With email patches, rebase failures are made the problem of the maintainer rather than the submitter, and that just seems wrong. If I actually want to try out the patch, I can just pull the version from Gerrit directly.

> For anything that requires minimally non-trivial manipulations of text (like, you know, search and replace with regular expressions, or pipe a block of text through a filter - trivial things like that) it would be extremely painful.

Why on earth would you want search/replace while entering a comment? If you're actually want to propose a change to the patch itself, you can edit it within the browser itself (VSCode can be embedded anywhere AIUI)

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 4:58 UTC (Mon) by viro (subscriber, #7872) [Link]

git am is when you are sent patches over email; if you are given a branch + repo (in the same email) - use git pull.

If patches are trivial and don't need me to look outside of context diff, sure, I can reply directly to email. What's the benefit of web-based anything in that respect, anyway? For anything more involved I very much prefer to be able to do it in a real editor, where I can poke around the tree, etc. Can you do the same in browser? As in, something in the patch gets me to look for the places where this field of this structure is ever accessed, to verify that their locking is, indeed, sufficient. Or something like "their change seems to remove a bunch of calls of that primitive; how many are left afterwards? If there's none, this and that could've been done much simpler and cut down the complexity of patch series big way... <greps> Umm... only two callers left; let's look around and see if they can be massaged out of existence as a preliminary step - looks like that might be a serious win overall". Or writing an explanation that would be longer than a few lines, with e.g. pseudo-code snippets in it. Or any number of other things, really...

As for rebase failures - huh? If I don't know which version the series is based on, how the hell could I review it in the first place, not to mention pulling it in? If the patches do not apply, you ask the submitter what are they supposed to be against; if they can't tell that, you don't want to deal with the series anyway. Oh, and throwaway branches are not a problem to remove, you know...

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 12:19 UTC (Mon) by farnz (subscriber, #17727) [Link]

FWIW, I use local branches for review all the time with web-based review systems like Gerrit and GitHub PRs. It's just convenient to have the full power of my local setup available for reviewing the code, looking at what things outside the change are doing (which in turn allows me to suggest helpful follow-ups). git makes it trivial to check out a branch or commit and look at it, to try out changes I'm going to suggest (complete with building and/or testing them).

And git worktree add makes it trivial to create a new working copy for the duration of one review, which I can then delete after I'm done.

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 18:43 UTC (Mon) by wtarreau (subscriber, #51152) [Link] (5 responses)

> Why on earth would you want search/replace while entering a comment?

This question is funny! This happens to be all the time: just because your ideas develop as you review while you're commenting. You start by suggesting something and you change your mind in the middle for something better, so you just want to s/foo/bar/g to replace all the variables prefixes. And similarly, wanting to just indent a block to put an "if" clause around is super frequent when reviewing. All things that browsers make impossible to do without having to press space 100 times (since tab will get you out of the box and if you're unlucky you'll even press "Post" while touching the space bar). I, too, despise every single minute I type in a browser. These tools are entirely designed to make you consume contents, not produce them.

Reducing kernel-maintainer burnout

Posted Nov 29, 2023 12:26 UTC (Wed) by kleptog (subscriber, #1183) [Link] (4 responses)

> You start by suggesting something and you change your mind in the middle for something better, so you just want to s/foo/bar/g to replace all the variables prefixes.

I guess we mean different things by reviewing. Reviewing for me does not involve writing any code, the idea is to provide the submitter enough information to fix it themselves and resubmit.

Reducing kernel-maintainer burnout

Posted Nov 29, 2023 14:42 UTC (Wed) by wtarreau (subscriber, #51152) [Link]

> Reviewing for me does not involve writing any code, the idea is to provide the submitter enough information to fix it themselves and resubmit.

It's often much more efficient (and friendly) to write "I think maybe a better approach could be something around this:" and give the start of an example, than "no, still not what I'm expecting, try again". Look at reviews done on LKML, a non-negligible number of them suggest code snippets to discuss around. This is particularly true for bug fixes, where it's often a tradeoff and multiple approaches need to be explorated. That's precisely one of the reasons some tools are quite bad at this, when they don't allow the reviewer to express what they're thinking about, and cause many round trips.

Reducing kernel-maintainer burnout

Posted Nov 29, 2023 20:34 UTC (Wed) by viro (subscriber, #7872) [Link]

Alas, some of us just can't aspire to such heights of managerial Tao and feel an occasional urge to explain things, even at the expense of sullying the proper forms with actual details. Or believe that Lao Tzu had been taking the piss and those who take his teachings too seriously are utter wankers....

Reducing kernel-maintainer burnout

Posted Nov 30, 2023 11:48 UTC (Thu) by farnz (subscriber, #17727) [Link]

I often find myself wanting to quickly confirm that a suggestion I have is workable before I make it - I'm not infallible, but I can quickly write a small amount of code (ignoring error checking, ripple effects outside the area I'm changing, good style etc) to see what my suggestion will do to the code I'm reviewing. If I like what I see, I'll make the suggestion, while if I see that it's actually obfuscating the code, I'll not suggest it.

Reducing kernel-maintainer burnout

Posted Dec 4, 2023 14:02 UTC (Mon) by Hattifnattar (subscriber, #93737) [Link]

I would hate to get a review that just said "this line is wrong" without giving any reason, or "this function can be made more efficient" without any suggestion. Do you expect me to read your mind?

And a reason or a suggestion often involve, surprise-surprise, code.

Reviewing is just a conversation on a specific topic. The topic being code, it's entirely reasonable that the conversation will include code fragments...

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 13:41 UTC (Sun) by nevets (subscriber, #11875) [Link] (1 responses)

I usually just cut and paste text out of a browser and into an editor, make my changes, then cut and paste it back into the browser.

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 5:08 UTC (Mon) by viro (subscriber, #7872) [Link]

Cut'n'paste of more than a screenful tends to be unpleasant, and there's whitespace/tab/etc. damage to deal with. It's all survivable, of course, but really unpleasant.

Reducing kernel-maintainer burnout

Posted Dec 26, 2024 12:00 UTC (Thu) by alx.manpages (subscriber, #145117) [Link]

> Save the email in question into a (local) mailblox, then git am -s mailbox_file_name and you are done.

Actually, you can optimize that a little bit:

In neomutt(1)/mutt(1), you can press '|' within a message to pipe it to a command, which can be 'git am -s'. So, when reviewing patches for a project, I cd(1) into the worktree where I apply patches from contributors, then read mail, and from mail directly `|git am -s`, omitting the "save" step. You can even do that with encrypted mail (with a configuration line to tell it to decrypt while piping).

I expect other MUAs should have similar abilities.

BTW, another advantage of email:

You can use PGP to sign and/or encrypt the email.

Reducing kernel-maintainer burnout

Posted Nov 26, 2023 16:28 UTC (Sun) by johannbg (guest, #65743) [Link] (1 responses)

"It's important to consider the maintainer side more than the contributor's side. Patches and contributors are not missing, maintainers are."

Well you first have to become a contributor prior to becoming a maintainer, which is often the path which existing maintainers use to evaluate contributors and then later if approved offer/ack them as fellow maintainers right so my question to you is...

During your career as a kernel maintainer how many contributors have you approached and asked if they want to become a maintainer? When doing so what did you use as an incentive for that person to become a maintainer and what was the contributors response to that?

The thing is either existing maintainers aren't reaching out to prospects and offer them to become maintainers or existing contributors see no value in becoming maintainers in the first place.

If there is no value in the role of a maintainer then that role is effectively becoming obsolete ( some sort of structural change is needed ).

Reducing kernel-maintainer burnout

Posted Nov 28, 2023 16:17 UTC (Tue) by wtarreau (subscriber, #51152) [Link]

For the kernel, I remember about 4 of them over the last 25 years, with the last one being the freshest one in my memory. Each time it's being the same: may (lack of) availability was the bottleneck and I was hindering more than I was helping. For some time it's acceptable, but at one point when you're figuring the same contributor gets it right all the time and even corrects you because by lack of time you say rubish, it's time to offer them to become a co-maintainer or even the only maintainer. Last time it was clearly much welcome and helped a lot.

Accepting a co-maintainer is nice for everyone. Less stress for both, particularly for the person, knowing that you're still there for complicated stuff, and it allows that person to start to take some liberties they wouldn't otherwise have attempted to take. *this* factor is important because there is not a single way to do things, and your way might have been good in the past and no more suitable. A fresh mind can come with a different approach, and being a maintainer, feel a bit more legitimate (or at least feel like there's less risk their work gets rejected).

If I had to do it again, I would definitely do it. The most stressful for me is to know I'm on a critical path and slowing someone else down. This is negative participation and is not acceptable. Sometimes it's better to have other people with a bit less experience of certain points and more availability than just rely on experts that are never available. Then experts can say in the background and appear only when needed.

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 23:12 UTC (Mon) by pj (subscriber, #4506) [Link] (7 responses)

>Having to suggest code examples in text areas which do not even support vertical selection, indent, text replace etc, the difficulty to get the patch locally and apply it to a tree etc, all of this is totally deterring.

Have you considered finding an external editor plugin for your browser? I'm fairly sure they're available for most browsers, and generally let you right-click on a textarea and send it to an editor... and then replace the existing text when you save from the editor.

Reducing kernel-maintainer burnout

Posted Nov 27, 2023 23:42 UTC (Mon) by viro (subscriber, #7872) [Link] (4 responses)

Used to exist; these days it seems that chromium, at least, considers running an external program as a security hole. The best I'd been able to find had been along the lines of "well, you can run a local httpd with something magical plugged into it", which is... considerably more fishy-looking wrt security.

If anyone could share pointers towards a working setup that would allow e.g. to launch an xterm with vi in it, the contents of the area copied there and copied back after you are done editing it, I would be really grateful.

Reducing kernel-maintainer burnout

Posted Nov 28, 2023 5:48 UTC (Tue) by Cyberax (✭ supporter ✭, #52523) [Link] (2 responses)

> Used to exist; these days it seems that chromium, at least, considers running an external program as a security hole.

Well, it kinda is.

Your only solution right now is to use a localhost-bound HTTP server, which is not such a bad idea. Chrome might also gain support for UNIX domain sockets, WHATWG has approved an RFC for it last year.

You also can try to create a fake service using Chrome debug API, but it's even _worse_.

Reducing kernel-maintainer burnout

Posted Nov 30, 2023 21:35 UTC (Thu) by comex (subscriber, #71521) [Link] (1 responses)

Since we are talking about browser extensions, can’t you just use the native messaging API? In short, the user installs a JSON file into a specific directory containing an arbitrary path to an executable and the ID of a browser extension which is allowed to talk to it. The browser launches that binary, unsandboxed, and it can communicate with the extension over stdin/stdout. No local HTTP server needed. The main drawback is that for security reasons, the user has to install the JSON file themselves rather than having it be built into the browser extension. But that’s not a big deal.

https://developer.chrome.com/docs/extensions/mv3/nativeMe...

Reducing kernel-maintainer burnout

Posted Dec 1, 2023 6:13 UTC (Fri) by Cyberax (✭ supporter ✭, #52523) [Link]

Yes, that's actually a pretty good solution. And it would work perfectly with something like VIM integration.

Reducing kernel-maintainer burnout

Posted Dec 6, 2023 16:42 UTC (Wed) by lacos (guest, #70616) [Link]

"textern" for firefox <https://github.com/jlebon/textern>.

"external editor revived" <https://github.com/Frederick888/external-editor-revived> and "toggle line wrap" <https://git.kiszka.org/togglelinewrap.git> for thunderbird.

Reducing kernel-maintainer burnout

Posted Dec 2, 2023 0:15 UTC (Sat) by jschrod (subscriber, #1646) [Link] (1 responses)

Could you please point me to a plug-in that does this for Firefox and Emacs?

I'm using Emacs server already, that part is covered.

I didn't find such a plug-in - but maybe my search foo is not good enough and I used the wrong search terms.

Reducing kernel-maintainer burnout

Posted Dec 2, 2023 9:22 UTC (Sat) by mchapman (subscriber, #66589) [Link]

I have been very happy with Textern.


Copyright © 2025, Eklektix, Inc.
Comments and public postings are copyrighted by their creators.
Linux is a registered trademark of Linus Torvalds