That's a great idea, thanks! I'll do that tomorrow or so.

As a preview, two specific cases I've seen:

1) In PRs, some companies like to have semi-structured metadata, like a link to a related ticket under a heading "Ticket". In mdq, you could find that using `# Ticket | [](^https://issues.acme.com/)`

2) Many projects ask people who submit bugs to check off whether they've searched for existing bugs. `- [x] I've looked in the bug tracker for existing bugs`

The Markdown parsing library I'm using supports MDX, so it shouldn't be too difficult to come up with syntax for those components. I haven't done that yet, but mostly because I didn't want to go down that path until I knew there was interest and had a concrete use case or two to inform the query syntax.

If you want to open an enhancement request issue, I'm happy to take a look (PRs also welcome, but not required). If you're not on GitHub, let me know and we can figure out some other way to get the request tracked.

Thanks for taking a look at the project!

I don't write rust and already have an MDX toolbox that fits my needs. Browser, GH, and IDE search / TOC are good enough for me.

I'm currently in a phase of trying to shed tools and added complexity, rather than add them

Fair enough!

For the markdown, I'm using https://github.com/wooorm/markdown-rs, which is a formal parser that produces an AST. For the query language, I have a very simple hand-rolled parser.

I'm curious how ergonomic you find that? I did look at the pandoc JSON initially, and found it fairly awkward to work with. It's a great interchange format, but doesn't seem optimized for either human interaction or scripting. (It's definitely possible to use it for scripting, it just felt cumbersome to me, personally.)

Aren’t you supposed to have your personal Bitwarden account and get work passwords shared to your account? I thought that’s how Bitwarden for organisations worked.

Ideally I'd want to keep my _personal_ personal stuff separate from my "work personal" (ie my personal logins, but the one for work accounts) separate from my shared work stuff. So I'd want two accounts, one for my truly personal accounts, and then one for my work-personal and have the work-shared connected to that.

There doesn't seem to be a security benefit of doing this if you encounter having to swap between personal-personal and work-personal.

It doesn't take me many seconds to swap accounts. LastPass allows you to be signed into two accounts at the same time in the same browser?

Lastpass allows you to link your personal-personal account into your work account, so that you can access your personal-personal data while logged into a work account. Work-personal accounts should be stored in a personal folder in your work account, then work-work accounts are in shared folders that cross multiple users.

I forget if LastPass does — 1Password does (though I haven't actually used it in practice, because my work doesn't use 1Password). Idk, maybe it's not actually a problem, but it's how I like to organize things. ::shrug::

I don't know how well this works across business and personal accounts, but you can use "collections" to share passwords between accounts.

I'm using that on my VaultWarden server to share data between different accounts and it works well for me. This may not work in your specific situation if your company manages your Bitwarden account, though.

Bitwarden's mobile app allows you to log in with multiple accounts. I think the desktop client does as well.

Not sure why the web extension doesn't. Might have something to do with autofilling or adding credentials to HTTP Basic Auth?

I'll keep it on my radar, because at an intellectual level it seems pretty interesting. But this smells a bit of "fun computer science, not terribly useful software engineering."

Firstly, my experience with Haskell left me pretty skeptical of pure programming languages. They're just that much harder to grok; debugging becomes harder (though it looks like this language has log functions, so it's not totally pure FP?), `for` loops are just easier to think about than folding, etc.

But beyond that, the problems this language tries to address just don't seem like the real problems I face. Let's take a few:

• distributed programming: shipping bits of opcode (whether it's machine code, Java bytecode, etc) is easy. The hard part is knowing which bits to distribute where, especially when they have to operate on shared state. I don't see how hashing ASTs helps with that.

• no builds: I mean sure, that's nice I guess. But tbh, I spend very little of my day or mental energy waiting for compilation.

• dependency conflicts: The bad ones of these don't arise from name conflicts — those are easy to get around. The bigger problems are things like two dependencies that each depend on different versions of the same library, and you want them to communicate: you want DepA to talk to DepB via some object defined in DepC that they both use, but DepA and DepB use different and incompatible versions of DepC. Hashing doesn't seem to fix this.

Now, that doesn't mean people shouldn't learn this, especially if they find it interesting. I don't use Haskell at all, but I think I'm a better programmer for having learned it, because it made me think of things in a new way. This language could well be similar — but I don't see it replacing mainstream languages.

And it contains its own tldr, in the form of "<h2>No. Just No.</h2>".

We need a new acronym: tl;dc: "too lazy; didn't click"

"Education" maybe the worst of them. One of the what-to-do steps is... learn what to do? Talk about drawing the rest of the freaking owl.

Yes this one is comically bad. The description is even worse: "Your body knows best. Avoid unnecessary passive treatments and medical investigations and let nature play its role."

So really this is preaching anti-education. Do not seek out information about your injury.

They certainly worded it poorly, but what they meant was "voodoo doesn't work". As in, educate your patient about their wacky home remedies, and try to get them to engage with realistic recovery outcomes.

From the paper:

> E for educate

> Therapists should educate patients on the benefits of an active approach to recovery. Passive modalities, such as electrotherapy, manual therapy or acupuncture, early after injury have insignificant effects on pain and function compared with an active approach, and may even be counterproductive in the long term. Indeed, nurturing an external locus of control or the ‘need to be fixed’ can lead to therapy- dependent behaviour. Better education on the condition and load management will help avoid overtreatment. This in turn reduces the likelihood of unnecessary injections or surgery, and supports a reduction in the cost of healthcare (eg, due to disability compensation associated with low back pain). In an era of hi- tech therapeutic options, we strongly advocate for setting realistic expectations with patients about recovery times instead of chasing the ‘magic cure’ approach.

It seems like a lot of folks have responded to conspiracy idiocy by going all-out anti-learning in favor of blind deferral to experts. Even if I thought that was wise, telling people not to research their injuries is like telling the tide not to come in. Better to focus on identifying trustworthy information.

Seriously. It's a trend I've noticed with a lot of anti-misinformation people, including with my friends and family, where they skip the learning and critical thinking part and just buy straight into whatever is said by someone who calls themselves an expert.

These are guidelines for medical practitioners, who are well-placed to educate their patients.

Read them again. Where the guidelines say "you", they are clearly addressing the injured party.

Does "Education" lead to recursion?

I don't know if shameless plugs are allowed here (sorry if not!), but I have an open source project for Mac that's aimed at exactly this problem. Every ~10 minutes (configurable), it pops up an unobtrusive prompt to ask you what you're working on right now. It then has some basic reporting and aggregating functionality. It's not specifically targeted for consulting / invoicing (I made it because I often ended my day wondering what the heck I'd done all day), and it's sometimes a tad rough around the edges, but it could help. https://whatdid.yuvalshavit.com / https://github.com/yshavit/whatdid

(I'm newish to HN, so please let me know if this message is inappropriate!)

For my specific work flow I was actually thinking of scraping all my git repos to see my activity. Because I'm always working in a git repo, or mostly.

I actually already did try using some sort of recursive git status/log viewer that I can't remember the name of now. Didn't keep it up but I think a program that scrapes my git repos, and perhaps aggregates with other activity logs, would be the best fit.

Ah, gotcha — my app won't help with that, then, sorry! :-)

I only use Swift for a side project, but I found myself splitting my time between AppCode and XCode. AppCode is nicer in terms of feature set (both in completeness and in my familiarity with the shortcuts), but I find XCode is much faster. If I'm working on something with a bunch of renaming/refactoring/etc, I'll do it in AppCode; if I'm more or less just typing and running tests, I'll do it in XCode.

So, while this announcement is sad, I can't say it's shocking. In other languages I know, IntelliJ products are significantly better than the competitors. For Swift, it's a bit more... meh.

AppCode used to be way better than Xcode in the early days of Swift. And IME has been better at least up to 2020. Did Xcode fix its performance and reliability issues in the last 2 years?

Not entirely, but mostly. The Swift tooling is far more reliable, 3 years ago I was getting noticeable code intelligence failures on hobby projects, 1 year ago I wasn’t noticing it during nearly full time professional iOS engineering. SwiftUI previews were still a little dodgy but getting better every release.

As for performance, it’s basically like any other major macOS app now in my experience. Only caveat might be the git committing which was a bit crap still last time I checked.

IntelliJ software still feels like everything takes 100ms longer than I expect, which makes it feel sluggish even if the heavy lifting is relatively fast.