shabble

there's also usage: https://usage.jdx.dev/spec/

the double questionmark `foo??` is sometimes also useful, since it'll show full source for the function/method/thing if you do it to a function.

"ratio of open/total issues" can definitely be gamed by autoclosing anything that isn't an easy fix.

"average time to resolution" is also susceptible.

Both of these are pretty common all over the place, including OSS e.g. https://isitmaintained.com/#metrics

I suspect this sort of thing is one of the major motivations for the (as a user/reporter) infuriating rise in automated "this bug hasn't been touched in NN days, autoclosing for staleness" bots on various issue trackers.

"People keep saying Macos is better than iOS..."

"There are two ways we can fix this problem: we could make iOS better?"

"..."

After being annoyed by this (and a handful of persistent others) a few too many times, I ended up with the following ublock rules:

    www.youtube.com##ytd-rich-grid-media.ytd-rich-item-renderer:has(a[href='/@MrBeast'])
    www.youtube.com##ytd-rich-grid-media.ytd-rich-item-renderer:has(a[href='/@BeastReacts'])
    www.youtube.com##ytd-rich-grid-media.ytd-rich-item-renderer:has(a[href='/@BeastPhilanthropy'])

I don't think some sort of vaguely granular "last edited by XXX at YYY" annotations/tooltips/whatever would be too outrageous a feature to confuse everyone.

If necessary, could treat tables or other complicated compound entries as a single editable item, although given the mysterious passion everyone I've ever worked with seems to have for putting just about everything into a table regardless of need, I'd hope it could be granular to a cell-level, at least.

Trying to collaboratively write complicated documents with a bunch of inter-relations between sections, from different people (in my case, documentation & regulatory paperwork for medical devices) is a massive pain, and I feel like it's too obvious a problem to be confined to my particular niche.

I vaguely recall Word is widely used for preparing huge legal documents, where the content and stakes are probably similar, so maybe there are some solutions, unless they're just "throw interns at it".

I've not really seen much actually using it in the wild, but I came across CriticMarkup[1] at some point in the past and had some idea of using it in some sort of copyediting workflows.

[1] https://github.com/CriticMarkup/CriticMarkup-toolkit

maybe I'm just doing it wrong, but having looked at these capabilities occasionally, they seem pretty weak.

- There's no equivalent of "git blame" that I can find to see who/when a particular line/paragraph/section changed.

- I can't see if there's a way to view my changes separate from other edits to the document, or isolate changes by single authors generally.

- "diffing" via the "compare documents" action seems to want to generate a new document with track-changes edits for changes from old/new, but mangles the histories to present all changes as by the invoker of the diff, at that time, which isn't all that useful.

It's definitely better than nothing at all, but a long way short of where I'd hoped we'd be regarding collaborative document authoring at this point.

Scratch Monkey may have some vague notions along those lines, if I remember rightly: https://www.antipope.org/charlie/fiction/monkey/index.html

and to squash a little further:

    perl -ne '/^(?=([abc].*){3})(?!.*([abc]).*\2).{8}k.$/&&print' /usr/share/dict/words

mitmproxy[1] in transparent mode, with a self-signed root cert added to whatever trust stores on devices/browsers/OSes you need to intercept, is where I'd start.

I'm not sure how well that copes with modern security features like cert pinning, but it's closest I can think of.

[1] https://docs.mitmproxy.org/stable/concepts-modes/#transparen...

The last time I actively looked into it (granted, some months ago), it was somewhat hindered by https://github.com/python/mypy/issues/9309 causing it to re-evaluate sources quite a lot during editing even with mypyd.

I just had a quick check and can't obviously see if that has been fixed/worked around in pylsp-mypy, on the off-chance that you might know :)

A more specialised variant that's also quite common is the "window watchdog" peripheral, which is similar to the timer version, but will also trigger a reset if the keep-alive signal arrives too early, as well as too late.

It can be useful where you've got a mainloop doing some very predictably timed activities, and allows detection of faults which cause your watchdog servicing to occur too frequently.

I think it's quite common in DSP and things like motor control, where you often have hard realtime requirements and things happening too soon is just as bad as too late.

At least some STM32s do, see page 89 of the STM32F4xx reference manual[1], the option bits 5:7 at 0x1fffc000 let you activate the hardware watchdog immediately following reset if you wish.

[1] https://www.st.com/resource/en/reference_manual/rm0090-stm32...

I have a ublock rule like:

    www.youtube.com##div.ytd-rich-item-renderer:has(ytd-channel-name a[href="/c/SOME_CHANNEL_HERE"])

if you have a common base system it might be possible to copy/rsync/untar the tools you need and then use them. Ideally you'd want to restart the container/pod once you're done to ensure the tools aren't left around, or their presence causes other weird issues.

you might be (unintentionally) conflating CLI tools with TUI ones.

CLI by and large treat the terminal as something to read/write lines to, with maybe some rudimentary interaction support like redrawing the same line for a progress bar etc.

TUI use the various positioning and mode configuration escape sequences of the terminal to (typically) display "full-screen" applications within a terminal.

Vim/Emacs would be obvious examples, or any of the Curses-based menu-ish systems.

Try piping vim (not in batch mode) to a pager, and it doesn't really know what to do.

There is some middle-ground, Github's `gh' command will use a TUI-lite interactive menu prompts for various parameters if omitted, but can run non-interactively and be piped / folded / mutilated etc if the appropriate args are given.

is there a backend in particular you've found to work?

I've looked periodically for something in this vein, but the only one I can see right now is https://pypi.org/project/matplotlib-terminal/ which I haven't had much luck getting running.

what form of USB-C PD is suitable for powering my 2.4kW electric kettle though?

bonus fun if you're in a regulated industry and any BoM change is going to be, at the minimum, an external test-lab redoing all your certifications, and in the worst case, a brand new product you need to submit to your regulating authority.

No wonder there are some $5 MCUs going for $500+ each (and apparently selling well at those prices, even)

I get very distracted by continuous animation on a page/app that I'm trying to interact with, to the point of just having to abandon meme-heavy articles or posts if every chunk of content is bookended by great flashy looping gifs or similar internet spew.

Even technical or otherwise useful animated gifs showing the evolution of some system or progression through states or whatever, can be both helpful and absolutely obnoxious if it's autoloop forever with no control.

SuperStop for firefox used to at least allow the halting of gif animation in a heavy-handed nuclear option sort of way, as does uBlock 'element zapper' tools, but if the content isn't immediately good enough to warrant those sorts of readability interventions, I'll probably just bounce.

Electron and other native apps are even worse - good luck if you want a more nuanced control of your animation (including things like animated emoji/stickers/whathaveyou) than LOOP FOREVER or OFF.

IMO, just another reason that things like chat services (Slack, say) that force you via TOS to not make your client usage experience less uncomfortable are a blight on the modern computing ecosystem.

I'd be interested to hear more about what sort of challenges you have faced, and if/how you responded to them, if you have the time.

Regardless of the upthread "well, just switch [your company/government/entire friend network] to an open/permissive service" non-answer, I think there's going to be ever-more need for unofficial clients for some of these services, and a big part of that is going to be how to avoid having them shut down immediately by service providers...

even if I don't, I probably need to be able to understand and recognise them when other people do, in libraries/snippets etc that I depend on.

Not specifically a new feature, but I remember wasting a good bit of time when coming across a line that was essentially:

    return headers.get('x-foo') == settings.FOO_KEY is not None

and being extremely confused until discovering it was a use of comparison chaining[1] and was actually doing the right thing.

[1] https://docs.python.org/3.10/reference/expressions.html#comp...

That's a good point, if you have a fairly small set of structures and you're mostly just adding/removing connections and changing labels, I can definitely see that working well.

How are you generating the templates/base topology structures for that?

There's absolutely value in being able to partially generate (maybe just the nodes/edges, but without final layout), or possibly even just validate that a given diagram does actually match a given schema/definition, without necessarily solving the extremely hard problem of a good looking auto-layout.

I've dabbled in the past with trying to do auto-layout of new items while preserving explicit changes by hacking at some of the Cytoscape.js layout providers to heavily penalise moves to manually positioned nodes, but I've never managed to make anything close to what I'd call acceptable for general use.

I love the idea of autogenerating diagrams from either a schema or from some sort of actual definitions (terraform/cloud inspection/etc), but I've generally found that the layout can be pretty poor for any semi-complex system.

Even worse, a small change to the structure will typically cause a full re-layout, and place nodes completely differently to the previous output, making visual/mental comparisons between versions quite taxing.

Given that autolayout is likely never going to be as good as someone doing some amount of manual layout or at least hinting, it'd be nice if there was some way to allow explicit placement of items and track it as metadata independently of the model changes.

I think Structurizr[1] has some capabilities along these lines, but the editor wasn't great the last time I tried it, and I think largely requires their SaaS for tracking that layout info.

Another option might be to feed it all into some flavour of graph DB with interactive querying/filtering and layout, and let users produce just the diffs / bits that they care about, if practical.

[1] https://structurizr.com/

if you liked that, you'll love Plumbum[1] :)

[1] https://github.com/tomerfiliba/plumbum

ttyrec[1] would be an alternative format that's been around for a while.

Would be an interesting feature to see here for recording, and can then be played back/analysed by various other tools.

[1] https://en.wikipedia.org/wiki/Ttyrec

and purely by coincidence, it provides a solution to the ever-increasing use of VPNs for sidestepping geofenced services like TV Streaming.

I'm sure it's definitely just to weed out those bad actors and their dirty DDoS ways though.

Hadn't seen it before, and my first thought was "wow, that's a lot nicer than trying to read via twitter"

Have you considered a HN/generic forum display output format? :)