benley

awful Rendezvous with Rama sequels.

Were those so awful? I remember rather enjoying them when I read them many years ago - though the last book got pretty weird, as 4th-book-in-trilogy installments tend to do.

Mailman 3 is acceptable, imho. It's been a few years since I worked with it, but I was able to design a reliable public instance of it (https://mailman.haskell.org) with a few days of effort, including the migration from mailman v2.

Interesting - this could actually be good functionality to add to tailscale-manager (https://github.com/singlestore-labs/tailscale-manager), which currently just handles AWS prefix lists and DNS lookups.

Khat will wreck your teeth if you chew the leaves. And it's about on par with caffeine as far as stimulants go, so personally I'd stick with coffee or tea instead of khat.

There are indeed nvidia drivers for Linux and they're reasonably good for gaming, but the feature set sometimes lags far behind windows. There is no DLSS 3 for Linux, for instance. (as of a few months ago anyway - I haven't checked recently)

How does that compare to the typical cost of electricity to power a 3090 for a month? I honestly have no idea, this isn't a gotcha question.

I posted a reply to another subthread with some of this: https://news.ycombinator.com/item?id=43647368

* Does it work well?

Very well! There are some limitations (see link above), but what's implemented is reliable.

* Do you recommend it?

Yes, provided your requirements fit headscale's capabilities. If you need things like device trust attestation (e.g. Kandji MDM or Crowdstrike Falcon integration), SCIM provisioning, or various other enterprise features you may find it inadequate. If you can afford to pay for Tailscale, you should just use Tailscale because it's really good.

* Do your users care?

They like it way better than our previous OpenVPN setup, that's for sure. I don't think they care about Headscale vs commercial Tailscale - the backend implementation is largely invisible to them.

* Is it difficult? Do you have to maintain it or is it basically set it and forget it?

Not hard at all to set up, and it requires little maintenance attention. I have barely had to touch the control plane (other than version upgrades) since setting it up a year ago.

* What was memorable about setting it up?

We had to do some custom coding to have automatic user offboarding when employees leave the company, and to emulate app connectors / dynamic routing (this is now OSS! https://github.com/singlestore-labs/tailscale-manager).

And I've been contributing to the headscale codebase to smooth out some quirks that affected our SSO integration. The headscale authors have been pretty flexible in welcoming outside contributors.

* Why did you go for Headscale vs Tailscale or Netbird or some other solution?

vs Tailscale: It was way easier to build this myself than to get funding to use the commercial solution. I'm not good navigating corporate politics, but I am pretty good at building infrastructure and writing code.

vs Netbird: Mostly because I already liked Tailscale from using it at home, I like its implementation, and I like the way Tailscale (the company) have behaved. The handful of folks I know who work there are people I deeply respect.

there are a bunch of them: https://headscale.net/stable/ref/integration/web-ui/?h=web

The one I've deployed is https://github.com/gurucomputing/headscale-ui, which is basic but does what I need.

- How much effort do you put into key management compared to plain WireGuard?

Less effort than plain wireguard; the only key management I do is for non-human clients

- How automated is the onboarding process; do you generate and hand over keys?

Fully automated. Auth is done via OIDC to my company's SSO provider, so users can enroll their own machines without IT involvement.

- How do you cope without the commercial Tailscale dashboard?

I don't really miss it. The headscale CLI tool is pretty good, and I use one of the headscale web UI projects (three are several: https://headscale.net/stable/ref/integration/web-ui/?h=web) for quick access to a few features (https://github.com/gurucomputing/headscale-ui)

- Do you run some kind of dashboard or metrics system?

Yes, I scrape headscale's Prometheus metrics endpoint and have put together a simple Grafana dashboard. The metrics it emits are somewhat limited, but enough to keep an eye on its health.

- How long did it take to set up?

I had a prototype up and running on Kubernetes with OIDC integration and a web UI in about 1 day of hacking. Going into full production took a few months, but the majority of that time was about planning the migration of all the existing users from OpenVPN.

Come to think of it, maybe I should share my terraform modules for deploying it.

- Were there any gotchas?

A few, yeah:

- Setting up mobile clients is a bit fiddly, because they hide the "connect to a non-default control plane URL" under a debug menu. The mac and windows apps are similar - it's too easy for users to accidentally try to connect to tailscale.com instead of your headscale instance. If you have the ability to deploy MDM profiles (mac) or windows registry tweaks this is easy to fix, and the headscale server will even generate the configs for you.

- The headscale control plane doesn't support any kind of HA or replication. This doesn't disqualify it since tailscale can handle brief control plane outages without breaking the network, but it's likely to be a concern for serious enterprise users. It's possible to use an external Postgres database, so you can at least replicate data that way, but only one headscale server replica can be active at a time because they don't share runtime state.

- The tailscale API is not fully implemented, so you can't use things like the tailscale Kubernetes operator.

- Some features are missing: tailscale funnel, tailscale serve, app connectors, `autogroup:self` ACLs, SCIM provisioning, SSO group membership sync, and I forget what else. These may or may not be important to you.

For app connectors, I wrote an app to emulate the core functionality: https://github.com/singlestore-labs/tailscale-manager (it's in Haskell, but deployers don't need to care about that)

It's possible to implement group sync with some custom scripting - a python app to scrape your LDAP (or whatever) and generate tailscale ACLs isn't hard to write. But you do have to write it.

`autogroup:self` might be a big deal - you would need this if you want to stop users from seeing or connecting directly to each other's devices. I think there is an implementation of this coming in the next release of headscale.

Summary: headscale is great if you have relatively simple needs and can't afford to pay for Tailscale. You will probably outgrow it if you're running a serious business and need to comply with fancy audit requirements.

I've done exactly that: headscale in production at work, a few hundred client devices, infrastructure mostly powered by nix. What would you want to hear about it?

Thanks for the response. Is there much hope for this to change at some point? I would love to eventually use Haiku on actual hardware, and the lack of video acceleration is the main thing that discourages me from giving it a go.

Does that mean they have some accelerated video drivers now? Last I checked (maybe a year ago) there were none at all.

It's not easy to find from the linked website, but this appears to be the most recent code on github: https://github.com/rayarachelian/lisaem

There is also this repo which was last updated in 2018: https://github.com/rayarachelian/lisaem-1.2.x

I was about to be like "surely you mean the S/390 series" but nope, you are correct! Apparently 3090 came in between the S/370 and S/390 series: https://en.wikipedia.org/wiki/IBM_3090

Click the home button in the lower right of the frame, it will reset your position!

We're looking into this, but I'm not sure how easy it will be to fix. You probably ought to use Safari/Firefox/Chrome for now, sorry.

I'd recommend checking out some of the "smart relay" devices that let you reuse your existing light switches.

e.g. https://www.amazon.com/Compatible-SmartThings-Philips-ZBBrid... - this one says "2 way" but I'm pretty sure you can wire it up with two physical lightswitches to get the 3-way behavior that you're after. The wiring diagram on the amazon product page suggests as much.

I've personally used this Aeotec z-wave variant and it has worked well for me: https://www.amazon.com/gp/product/B06XC4CH98

You're welcome <3

Here's hoping Google doesn't get mad about it - though after 12(ish) years there's really nothing secret in that video.

Regarding the phrase "I don't know how to count that low", here's the video where it originated. Frankly I'm astonished this hasn't been shared before, and I hope I don't get in trouble for posting it (it's like 11 years old, surely nobody cares at this point, right?)

https://www.youtube.com/watch?v=3t6L-FlfeaI

These days people most frequently seem to mean "without a hypervisor" when they say bare-metal. In this case I guess it's "without containers", which isn't far off. Since it's not a formally defined term I'm happy as long as it's clear what the question means, and this one is explained clearly enough imo.

I'm finding that I like using Nord theme for much of my system UI where low-contrast reduces distractions (window decorations, buttons and other widgets, terminals, etc), but for my code editor I want something with slightly more contrast, and more saturated colors. doom-palenight fits that bill, and it compliments Nord fairly well on the rest of the screen imho.

nord: https://i.imgur.com/dsiX8Ow.png vs doom-palenight: https://i.imgur.com/8GYzIvW.png

in context: https://i.imgur.com/DQxha9r.png

This is an excellent metaphor but now I am curious, is it literally true?

Can you elaborate on this? I thought Metafilter was alive and doing just fine - in fact I still visit it regularly

Sure, but I think a more apt comparison in this context would be to Windows NT, given that Android and Fuchsia are both made by the same company: the ability to run win16 apps was crucial to its initial success. If every existing Windows 3.1 app had to be rewritten and rebuilt to work on NT at all, it would have been a much more difficult migration.

I can't speak to bugginess in general, but they're not supposed to be slow. I've used emacs with lsp modes for Haskell, Elm, Bash, and Python and they've all seemed very quick and responsive to me; if your setup is sluggish there is probably something amiss that can be fixed!

- find definition

- find usages

- rename

Emacs has these covered, especially when using LSP modes

- extract method

I don't know what this is, sorry

- detect code duplication

- highlight unused symbols(vars or functions)

This is what linters and static analysis tools are for, and emacs integrates with them nicely via flycheck.

- understand frameworks and libraries

not sure what this implies, sorry

- can suggest useful transformation or code simplification

- Intellij can understand type documentation like JSDoc and PHPDoc and use it in completion and highlight errors if using the wrong type or object member

More static analysis tooling, doesn't need to be built-in to the IDE, just hooked in with something like flycheck.

- smart spellchecking, spellchecking that understand when it is in a comment or if it is a symbol name

emacs can kinda do this via flyspell but it's not perfect. You're right, this is a good idea.

- good VCS support(diff, commit, push)

magit!

- good debugging support

I'm mostly clueless here, sorry.

- IDEs have by default a lot of linting and code analyzing tools setup, trying to go from Intellij to VS Code defaults is a big downgrade , maybe it could be partially fixed by installing many plugins but I personally want to pay for a good program made by professionals and keep them profitable(and not have JetBrains fail or get bought by Google or Microsoft)

aye, there's the rub. I suppose the "I" in IDE is the real value: the package deal with all the linters and analysis tools already hooked in. Various LSP modes have made it vastly easier to reach feature parity with this stuff in emacs with minimal effort, but I also definitely understand why things like Intellij are desirable and useful.

Antidepressant medications do not "cause happiness". They make it somewhat more possible (when they work at all, which is not a guarantee for a given drug in any individual) for a person to find ways of becoming less depressed. These are not performance-enhancing drugs; it is wildly inaccurate to compare antidepressant meds to steroids or stimulants (both of which _also_ have legitimate medical uses, but that's another topic). Taking an antidepressant when you are clinically depressed is much more comparable to taking anti-seizure medication if you are epileptic.

you want to get an older version of one particular dotfile, you'll also be getting older versions of other dotfiles as well.

That doesn't really follow; it is easy to check out old versions of a single file with git:

    git checkout <revision> <filename>

    git checkout HEAD~2 .bashrc

Just to throw a few possibilities out there: Correctness? Ease of writing? Portability?

You could go down the route of outputting each compiled object file as a derivation...

You could, but I believe you would find that Nix becomes pretty inefficient in that scenario. There is a surprising amount of overhead involved in setup/teardown of network namespaces and the other various sandbox features, and that cost is incurred for each individual derivation. It's a reasonable tradeoff for Nix when used as a package-level build sandbox, but (assuming my understanding is correct and still current) for Nix to work well as a file-level incremental build system it would require some strategic changes.

Here's the github issue with a bunch of related discussion and details: https://github.com/NixOS/nix/issues/179