samhh

I’ve set up a monorepo before that subpath exported plain TS across packages and it just worked (pnpm). You may want to try again.

FYI there is now an extension for TODO highlighting. Not at my machine but it’s something like “comments highlighter”.

It may be economically effective but such heartless, buggy software is a drain to use. I care about that delta, and yes this can be extrapolated to other industries.

You’re right not to trust it, it’s wrongly calling sibling-index() widely available. And that’s the first example I checked.

It’s already available behind a flag IIRC.

There’s also jj-stack. I don’t know how they compare.

This is something GitHub should be investing time in, it’s so frustrating.

I was surprised to learn that Depot runners, which are much faster, are also much cheaper. Would highly recommend them for anyone trapped on GitHub.

I’ll die on the hill that the tacit pipe operator would have been the right choice. IIRC the main objections came from engine implementors.

For a start I wouldn’t trust brands that by default market mesh over wired backhaul.

Those semantics make it more accessible for free.

It’s cryptographically bound to the domain.

Passkeys already solve for this, we just have to get past the FUD.

It could support it as a progressive enhancement.

In terms of task running specifically it does generally stay that simple for the likes of just.

The only complexity there is getting it installed on everyone's machine, but that's true of most tooling, even the common stuff given versions won't match. I solve that with Nix.

Static types are documentative, and language servers often also show you things like JSDoc alongside the type signature. Nix has neither of these, hence I have to check the source code or run a build and see what happens.

I really like Nix but in this particular way it feels like taking a big step backwards from the other languages I frequently use, particularly for a language in which you'll necessarily be constantly interacting with bespoke interfaces.

I agree that the documentation story could be better. I also think it's a great shame that the language isn't statically-typed, so to understand how to use something I have to inspect its source code.

I've found it to be quite flexible though. For example, here's a commit in which I apply a patch to a tool to solve a problem that the derivation hadn't taken into account (and absent a home-manager solution): https://github.com/samhh/dotfiles/commit/867dd3b4d4b3942a0aa...

They're also platforms without Game Pass i.e. with much less competition.

Anecdotal but everywhere I've worked on JS codebases has used lockfiles. It might be this isn't affecting that many but those it is affecting are loud.

That's not an issue, that assists in quickly viewing wanted package upgrades. The problem is in not using a lockfile.

If you interpret "spirituality" this broadly then the word is useless. This is why you'll receive some dismissive answers.

I drink espresso every morning. I challenge you to find a way to link that to this thread that isn't as useless as defining a synonym for the word "habit", or "preference", or similar.

Reality doesn't have to be interesting, nor do the results of self-examination. As best I can tell I'm a biological entity with a false sense of self and free will on a rock in the middle of an unfathomably large universe, the existence of which I will never understand. That's it. That's actually already quite interesting. Why do so many feel the need to try and force the elevation of the everyday and the mundane into that same plane? And worse yet, to speak condescendingly of others as you do so.

I'm not familiar with Python, but if those are traditional enums and not sum types then you're missing out on a lot in terms of domain modelling.

Yes, impurity (or rather the representation thereof) is contagious. This is where the common "functional core, imperative shell" comes into play. You generally try to push side effects to the edge.

There are other approaches you can take too, like encoding your effects in a monad which has a different runtime representation in tests. It's like mocking on steroids with type safety.

It's called Mu. It's strict and has a few other quirks. There are a few different teams using it for different projects.

Source: Used to work there.

fp-ts is hard to learn. Its docs, whilst improving, aren't great and it's applying pure functional concepts to a language which isn't designed for it. The outcome is surprisingly good but it's hard to understand as a newcomer why certain design decisions have been made, or what patterns are and are not idiomatic.

I'd recommend learning Haskell in your free time. It's a major paradigm shift but once it clicks you'll find it a lot easier to translate those concepts into fp-ts.

I went through this journey a couple of years ago, and now write heavy fp-ts code full-time - including maintaining fp-ts-std[1] - as well as some paid Haskell gigs on the side. Do feel free to reach out if you want any guidance at all, you'll find my email on my personal site[2]. The FP Slack is also a great place to ask for help with anything FP, including fp-ts - if you send me an email I can have an invitation sent to you.

[1]: https://github.com/samhh/fp-ts-std [2]: https://samhh.com

Most of those don't sacrifice S75 protection in the UK. PayPal is unique.

On macOS for example I'd use Spotlight.

You're just replacing an elected government with more unelected power.

Readability is largely subjective. I think this sentiment is better described as optimising readability for the lowest common denominator in terms of both ability/experience and the most common style of code, that being imperative. That's not an unreasonable choice to make but there are other criterion by which to judge how easy or hard code is to read.

It comes up a lot in discussions about Go. A simple, "readable" language in which I can't tell you at a glance what a block of code does or is responsible for.

I've noticed no such problem with my "Lightspeed" Logitech mouse and I'm very perceptive to slowdowns and stutters.

A high refresh rate monitor will cut down latency by 10-15ms. It'll also look/feel much smoother. You won't notice the 1ms added by a good wireless mouse in my experience. (I'm happy with my wireless Logitech G305 mouse on Linux, it's supported by the kernel so it's plug and play. Also surprisingly good battery life.)