mfsch

From [1]: “Like other SSH clients, Tailscale will only use user accounts that already exist on the host, not create new accounts.”

[1]: https://tailscale.com/kb/1193/tailscale-ssh/#ensure-tailscal...

Looks interesting, but it seems that this doesn’t work well for servers where every user has a personal account. It appears that this use case would require a separate ACL entry for every user, which a) can get slightly annoying to manage and b) requires a business plan. It would be nice if something like `"users": ["autogroup:emailuser"]` was supported to allow `alice@example.com` to connect as the user `alice`, but that would probably cause issues with e.g. Github organizations, where email addresses can have different TLDs.

What isn’t explained in the article is how this was made possible. While carefully adjusting departure times is certainly part of it, there were also a range of construction projects that shaved minutes off the travel times between major hubs to bring them just below multiples of 30 minutes (and 15 minutes in some cases). This makes it much easier to coordinate arrivals and departures and minimize transfer times.

https://en.wikipedia.org/wiki/Rail_2000

Release notes are in the manual: https://nixos.org/manual/nixos/stable/release-notes.html#sec...

It seems to me that much of the difficulty with interfaces, whether they are made explicit or kept implicit, lies in defining the semantics that the functions are supposed to have.

As we expand the types our generic code can handle, we have to refine the semantics it relies on. For a long time, Base.length(::AbstractArray) could mean “the largest one-based index of the array”, but then we started using the same code that handles regular Arrays for OffsetArrays and this interpretation was no longer valid. I guess the alternative would have been to leave length(::OffsetArray) unimplemented and block the valid use of OffsetArrays for all generic code that understands Base.length as “the number of values”.

It can still be difficult to tell what a function like Base.length should mean if I implement it for my types. For example, should it return the number of local values or the global length for an array that is distributed between multiple processes (e.g. in an MPI program)? Perhaps some generic code will use it to allocate a buffer for intermediate values, in which case it should be the local length. Or some generic code computes an average by dividing the (global) sum by the global length.

It seems impossible to come up with a precise definition of all the semantics your generic code assumes a priori, so we can either restrict our usage of generics to a small number of concrete types that were considered when the code was written, or we have to accept that we occasionally run into these sorts of issues while we refine the semantics.

Anecdotally, it has been my experience that packages that have been made to work in many generic contexts (such as the ODE packages) are likely to work flawlessly with my custom types, while packages that have seen less such effort (e.g. iterative solvers) are more likely to cause issues. This makes me hopeful that it is possible to converge towards very general generic implementations.

It is also worth mentioning that it is very possible to use Julia without ambitious use of cross-package generic functionality, and use it “merely” as a better Fortran or Matlab.

The spiky shape of the n-cube can be used as an illustration of the “myth of averages”, i.e. the observation that basically no person can be considered “average” or “typical” as soon as you consider a number of dimensions (famously observed by the US Air Force when trying to adjust fighter jet cockpits to the average dimensions of pilots [1]). If you consider n variables along which people and their experience can vary, the space that is “reasonably close” to the average (e.g. an n-ball or even an n-cube with side length 1−ε) becomes vanishingly small compared to the full space.

I find this is an important concept to keep in mind when designing systems and products. When you reach a certain complexity, most cases are edge cases and designing only for the “typical” case serves almost nobody.

[1]: https://99percentinvisible.org/episode/on-average/

Does anyone know how those compare to regular Netlify Functions, other than running on the edge nodes? The main difference I’ve found is that they have much stricter CPU time budgets, but it seems to me that the use cases overlap quite a bit.

The accompanying blog entry has a somewhat friendlier overview of the major changes:

https://www.darktable.org/2021/12/darktable-3-8/

The release notes give an overview of the changes and highlights:

https://nixos.org/manual/nixos/stable/release-notes.html#sec...

The release notes are also published in the news section of the website [1] and there’s a separate blog entry [2], though I’m never quite sure what’s supposed to be the difference between the two.

[1]: https://www.darktable.org/2021/07/darktable-360-released/ [2]: https://www.darktable.org/2021/07/darktable-3-6/

As a Migadu customer, that’s not my understanding. From their website: “When reaching incoming messages limits, we will warn you and allow for some tolerance of up to 25% over the plan limit. If even the higher tolerance level gets reached, we will start deferring messages until either the following day or the plan is upgraded. […] When reaching outgoing messages limits, we will warn you and allow for some tolerance of up to 25% over the plan limit. After the tolerance we will start rejecting outgoing messages.”

I’ve come to the same conclusion, especially since I often end up using the same equations for both web and LaTeX documents, so it’s nice to have the same rendering engine everywhere, especially once you start making small tweaks to spacing etc.

One issue I’ve run into is that it’s not always that easy to get the style of the SVG images right, especially when it comes to sizing & placement. Did you find a good way to e.g. ensure that inline equations have the correct baseline alignment? Or a good method to ensure that equation sizes always match the font size of the paragraph they’re in?

I think the 100% number comes from the fact that the one vaccinated severe case in the original study just was just barely below the threshold of oxygen saturation they had defined but the person required no medical care, so it wouldn’t be classified as severe by “regular people’s standards”.

They actually had a table on the efficacy for severe cases in the supplemental material of the original Pfizer study (table S5 in [1]), but all it shows is that the study doesn’t really give any information on this. The 95% confidence interval given for severe cases after the first vaccine is 20.1–99.7%.

From what I understand, it’s really a trade-off between waiting for proper data about the efficacy you’re most interested in, or starting to vaccinate people as soon as you have efficacy data for an endpoint that’s still meaningful but easier to reach. Having much fewer symptomatic cases is already a pretty good result, and I think it was expected that the protection would also extend to severe cases.

[1]: https://www.nejm.org/doi/suppl/10.1056/NEJMoa2034577/suppl_f...

The main problem is that you need a lot more data to make confident statements about severe cases than just about symptomatic cases. That 100% number of the Pfizer trial had a huge uncertainty interval. So even though severe cases are what you care most about, you usually don’t want to wait for a study that gives you good data on those and measure (and compare) symptomatic cases instead. Zeynep Tufekci discussed this issue of study endpoints in one of her recent articles: https://www.theinsight.org/p/vaccine-efficacy-statistical-po...

Not sure what techniques exactly you’re referring to, but the commonly used techniques for GPS enhancement (e.g. RTK [1]) are not simple distance measurements between GPS receivers and base stations but rather both stations measuring the satellite signal and using the difference of the signal in both locations to improve position estimates.

I imagine it’s possible to set up a ground-based network, but you would need a high density to cover large surfaces (you want to see at least four stations from every position). I also imagine that it would be difficult to get accurate vertical positions if the stations are all in the same horizontal plane.

[1]: https://en.wikipedia.org/wiki/Real-time_kinematic_positionin...

Just be aware that they require a phone number to sign up (can’t remember if it’s Swiss numbers only) and if their security systems trigger, they ask you to upload your government-issued ID.

Announcement: https://discourse.nixos.org/t/21-05-release-schedule/12528/1...

Looks like the website should soon be updated as well.

For what it’s worth, the hosts of NPR’s Planet Money regularly disclose their union memberships when talking about the topic.

The article says “Marlinspike has served as a paid technical adviser for the project since its inception” in the same paragraph, so I would say the article is quite clear on the financial relationship.

Post Mortem of the incident discussed here: https://news.ycombinator.com/item?id=26581027

Careful about creating mirrors, the Unsplash license [1] explicitly disallows “compiling photos from Unsplash to replicate a similar or competing service”.

[1]: https://unsplash.com/license

What can help in Switzerland (and potentially in other countries in Europe) is to complain through a consumer protection office. SRF has a TV and radio show (Kassensturz/Espresso) where they regularly solve consumer issues by threatening bad publicity.

Another option that can work is to send a bill for the owed amount and if they fail to respond start the process of debt collection (Betreibung). It’s a pain and doesn’t work well for people who actually cannot pay, but for regular businesses where you’re stuck somewhere in their bureaucracy it’s a way to force them to respond to your claims that’s a bit less involved than straight-out suing them.

> "if it's in the AGB (terms of service) good luck arguing/defending"

It might be hard to argue without suing, but legally there are provisions that if the AGB contain “surprising” terms, you have to be made specifically aware of them or they are invalid. There is currently a high-stakes case building because of this: Some of the epidemics insurances for restaurants had a provision that “pandemics” are excluded and won’t pay out for COVID-19, now restaurants are suing.

https://www.srf.ch/news/schweiz/epidemie-versicherer-kein-ge...

They even ask you to download their proprietary app and send them a picture of your actual ID:

https://www.infomaniak.com/en/support/faq/2144/blocked-order

I think the most consequential difference is that sourcehut is built on top of existing tools for distributed development with the goal of avoiding lock-in. Instead of replacing the distributed tools traditionally used in FLOSS development (mailing lists, patches) with centralized ones (issue tracker, pull requests), the goal is to provide an interface that makes it easier to use the tools of the distributed model.

It’s not just that the image is transparent though, because the color of the text changes too. I thought perhaps it’s using the site CSS to style SVG elements (which appears to be possible, though I haven’t tried it), but it turns out it’s just a CSS filter `invert(83%) hue-rotate(180deg)`. Still, it looks great and I’m impressed by the attention to detail.

What’s really neat is that when you switch to dark mode in the bottom left corner, the image flips to dark mode too!

This has also been my only use of the sidebar. It looks like the new design takes this into account and moves the language selection to a more prominent location at the top right next to the title.

Related: There was a recent discussion on HN [1] of an article in which someone described their process for designing a new home, and the author recommended “The Timeless Way of Building” by Christopher Alexander as one of their inspirations. I’ve since started reading the book and found it very inspiring so far. I haven’t read “A Pattern Language” yet, but my impression is that “The Timeless Way” is focusing a bit more on the “why” rather than the “how”.

[1]: https://news.ycombinator.com/item?id=23881363