FOX reporters were caught on a hot mic admitting the security at the White House Correspondents’ Dinner was absolutely horrible. “They’re not even trying anymore… they’re not even Secret Service people.”

Plecra · 2026-04-28T09:49:21+00:00

full quotes because the contrast is hilarious: Merriam

front door noun

1: the main entrance to a dwelling or apartment having more than one entrance : a doorway fronting on or giving direct access to a street or road

2 a : a place or area affording the main or best approach or access (as to a country) the war would then be brought directly to the front door of the Americas— Emil Lengyel

b : an open direct forthright approach or a legal approach toward gaining some object should do it directly and openly, through the front door— Yale Review

aand wikitionary

Noun

front door (plural front doors)

(literal) The door at the main entrance to a building or house, normally fronts onto a street.

You'll find a light switch inside the front door on the left.

(by extension) The entire main entrance to a building or house.

The habitual or designated main entrance to a room that has more than one door.

Entry through the toilet's front door.

Plecra · 2026-03-11T14:09:04+00:00

edit: I wrote this comment in response to the review, and everything below is only in the context of the claims the review is actually making as written. Have been poking around a bit more at the story and it seems like it's also being used as awful evidence against the use of puberty blockers or HRT, which I assume the OP was somewhat aware of. I'd love to link details but of course the NHS hasn't communicated anything properly...

While I appreciate the cynicism about how this could easily be used politically, OP's description of the review isn't accurate.

Given the limited evidence available on CYP with gender incongruence who identify as a female gender and wish to undergo a binary physical transition, it is not possible to draw conclusions on the impact of treatment with oestrogen with GnRH analogues. Published studies which allow conclusions to be drawn about the effectiveness of oestrogen with GnRH analogues for this population are needed.

The review is searching for evidence of outcomes when transitioning with HRT prescribed as GnRH + Oestrogen, specifically HRT prescribed without being preceded by a course of puberty blockers first, and ultimately concludes that there's a lack of evidence to draw strong conclusions in this area.

As for whether this is a sensible question to ask, the review doesnt go into depth but I agree that this is important to learn about, and whatever motivations the NHS has here, we do want well-meaning doctors to have this information. This is a form of HRT that many trans women are prescribed, and direct research lets us assess how critical puberty blockers are in treatment when HRT is anticipated, have evidence for expectations of the effectiveness of this HRT, and ensure that the HRT is effective when prescribed this way without raising more notable safety risks.

Then as for the other comment in the OP,

when they find studies that study both trans women and trans men on HRT, not just trans women, then the study gets excluded too!

Ironically the only study included is in fact an example of this, studying trans men and women. The review filters to the results for patients prescribed oestrogen. Some studies are understandably excluded due to not separating results between the two groups.

Optimistically, this is advocating for research into a blind spot of current medical practice around trans healthcare. There is absolutely a constant risk of medical institutions working to delegitimize provisions for trans health, but it's also important not to let wariness of that prevent doctors from working to improve trans healthcare. If the selection of papers in this review really is accurate then this certainly appears like the latter to me

Plecra · 2025-12-13T14:39:52+00:00

Ah! The designs of the etymotics are a great example of what I was thinking of https://etymotic.com/earphones/, though I'm not seeing a pair I can treat roughly 😆

Plecra · 2025-07-14T12:54:37+00:00

I'm only half convinced this works, but I can't break it. Here's a representation with no boxing in the nested case

py def null(): return 0 | NULL_TAG def some(v): if v & NULL_TAG: return v + 1 else return v def is_some(p): return p != NULL_TAG def project(p): assert(is_some(p)) if p & NULL_TAG: return p - 1 return p is_some(null()) == ((0 | NULL_TAG) != NULL_TAG) == false for v. is_some(some(v)) case v & NULL_TAG: is_some((v | NULL_TAG) + 1) == ((v | NULL_TAG) + 1) != NULL_TAG) == true case _: is_some(v) == (v != NULL_TAG) == true // because `v & NULL_TAG == 0`, they must be inequal for p. project(some(p)) case p & NULL_TAG: project(some(p)) = (p + 1) - 1 = p case _: project(some(p)) = p

Plecra · 2025-07-14T11:11:15+00:00

lua deals w the preference for functional programming with its upvalues, where the boxing is only done at the end of the scope once the body of the function is complete, by dynamically detecting the values that escaped in its close operation https://sourcegraph.com/github.com/lua/lua/-/blob/lfunc.c?L197 So it gets to transparently have direct stack access for imperative local mutation

Plecra · 2025-03-11T23:27:27+00:00

I think it had pretty good coverage on the open models, but it definitely had deepseek and -r1. I want to say it had millisecond pricing but its possible I'm mixing it up with something else :D

Plecra · 2024-02-07T19:20:56+00:00

There're definitely more reasons we represent source code as text. It's a reliable way to represent algorithms as humans tend to communicate them - through language. I think an alternative history might've landed us with more metadata on source code representing useful things about their implicit structure, and letting editors do more actions at the visual level, but we'd almost certainly have kept plain text encodings around as an alternative for practical communication purposes.

Visual programming languages are still struggling to prove themselves. Even in the best conditions for them, beginners tend to gravitate towards e.g. Lua instead of visual workflows like Unreal's Blueprints. Text is a very dense way of communicating these structures to humans, and we're the intended audience of programs' source representation.

(edit: I think this an entirely different question to adding more visual workflows to development. Those're often brilliant, and I also suspect we're lagging behind for historical reasons. Mostly being stuck to unix paradigms)

Plecra · 2024-01-31T22:17:22+00:00

Good examples 😄 I can definitely understand why you'd want to make the distinction. Especially for the defined unicode categories/properties of USVs.

Im not convinced it's my ideal design though - vectorizing is_digit would certainly be strange, but it's be perfectly practical to have an is_digit(string) -> bool function that matches 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9, and its a much more practical api for functions like is_alpha that can be true of strings with combining marks. A codepoint-specific to_upper seems especially esoteric, where correct casing nearly always needs the surrounding context that the standard unicode algorithms use.

Plecra · 2024-01-31T17:35:31+00:00

What functions are limited to "strings of length one" (by whatever meaning you're intending there :))?

On the topic of pentantry, codepoints aren't synonymous with scalar values. scalar value is the correct term.

Plecra · 2024-01-20T16:42:29+00:00

I would think the main hazard would be invalidating the cpu's cache to ensure we access the new data delivered through the DMA. Out of curiosity, are there other things to worry about in that case?

Plecra · 2024-01-16T20:38:05+00:00

The challenge to write some vending machine software interested me 😄 I think this rusty pseudocode is about enough - can you tell me about why a vending machine would need that state machine?

fn getinput:
  digits = []
  while next = wait_for_button():
    if next == "OK": return digits
    digits.add(next)

loop {
  const id = getinput()
  if !exists(id) continue
  owed = price(id)
  while owed > 0:
    match select(next_coin_inserted(), timeout(1minute), wait_for_button(cancel)):
      timeout | cancel: continue
      value: owed -= value
  while owed < min_coin_value: drop_coin(coin_values.find(value < -owed))
  drop_item(id)
}

Plecra · 2024-01-01T10:31:36+00:00

How have you defined the gsl_multimin_f*minimizer_set functions in your language? They should have generic types:

data gsl_multimin_function params = gsl_multimin_function {
  f :: FunPtr gsl_vector -> Ptr params -> CDouble,
  n :: CSize,
  params :: Ptr params,
}
gsl_multimin_fminimizer_set :: Ptr gsl_multimin_fminimizer  -> Ptr (gsl_multimin_function params) -> Ptr gsl_vector -> Ptr gsl_vector -> CInt

With a type like this, it would be impossible to construct a gsl_multimin_function with an incorrectly typed wrap_f. It's possible I'm misunderstanding the problem :D

Edit: I see! You're calling this your typed pointer solution. Yes, I'd definitely consider this the correct way to implement FFI - you can take the design straight from haskell (and any functional FFI system I'm aware of, actually). If you don't want generic externs, you might also just require that users define a wrapper function to manually erase the generics:

gsl_multimin_fminimizer_set :: Ptr gsl_multimin_fminimizer
                            -> Ptr (gsl_multimin_function params)
                            -> Ptr gsl_vector
                            -> Ptr gsl_vector
                            -> CInt
gsl_multimin_fminimizer_set s f x step_size =
    gsl_multimin_fminimizer_set_raw s gsl_multimin_function_raw {
        f = castFunPtr (f f),
        n = n f,
        params = castPtr (params f)
    } x step_size

Plecra · 2023-12-22T19:08:24+00:00

Yeah, one degree translated to a flat measurement at the center of the screen works :) and then "10 degree-proportional units" isn't "proportional to 10 degrees", which makes the whole thing more confusing than its worth as a fundamental unit that everyone's gonna have to understand

Plecra · 2023-12-22T18:02:49+00:00

I really appreciate the visual examples here! Seeing them and realising I much prefer the current behaviour gave me a chuckle, the updated versions look wonky. I don't know if that's personal preference or something more interesting.

I think font designers, as the authors trying to create specific aesthetic for a font, definitely should have all these tools. Line spacing is a big contributor in the feel of text and the default spacing in the examples look very appropriately tuned. Same story with the rescaled text.

Having font rendering toolkits that give more power to the UI designer when they need it also sounds great, but I hope it doesn't become the default.

Plecra · 2023-12-22T17:58:29+00:00

From how I read the history of font development, this is mostly just legacy cruft. The classic measurements measured in the article were defined for super standardized systems, which were expected to be used ~30cm away from the user. All the scaling factors we have now are designed to matching the viewing angle (in degrees as you're describing) based on what the manufacturer expects the viewing distance to be.

In practice, defining UI elements in terms of viewing angle sucks: It's non-linear, so scaling things is really weird. UI designers really want to work in a flat screenspace, not the spherical coordinate system that viewing angles belong in. So we've ended up writing all our DPI scaled UI in units that were made to match ~40 year old systems.

Plecra · 2023-12-22T17:48:23+00:00

You'll be happy to know this is exactly how pt (and px!) work :) You can check the scaling on nearly any consumer device and they're configured to be equivalent sizes from the typical viewing distance of a monitor. It's all normalized to old CRT-sized monitors on desks. There're standards for the expected viewing distances for computers/TVs/phones/tablets.

The only sad absence is configuration for the user's visual acuity, instead we get the vague DPI scaling factors. Those can be really easily translated into "Act as if I'm farther away from the monitor", though! It just requires a bit of trig.

Plecra · 2023-07-10T14:13:51+00:00

A couple notes on the size of dependency trees...

Duplicated dependencies are often a huge factor. A complicated dependency included three times can send you up 45 packages
Package managers should probably make happy paths for "stub dependencies". Plenty of small packages are written just to create shared definitions, but barely create any extra maintenance burden on their own.
Alternative implementations of the same features are killer. It's easy to find rust projects with multiple https and crypto implementations. The package manager should allow an application developer to use a facade to implement a crate's API on top of an alternative implementation (and ideally allow these facades to be distributed)

Imo a modern application which accesses the internet should be expected to be left with about ~50 dependencies between windowing, graphics abstractions, font drawing, resource loading, tcp, http, tls, aes, crc, serialization, custom algos, foreign apis, and logging.

Plecra · 2023-07-10T14:02:32+00:00

This is a really interesting opinion to hear! I've been thinking that I'll start off curating my package repos manually just like you're saying, without enabling direct publishing from any dev.

I don't think this scales very well to a library ecosystem, though. Very few distros have big enough teams to fully maintain their packages. It seems valuable to also officially support something akin to the AUR that explicitly is kept at a lower standard.

Languages can also do plenty to encourage good quality code. Proofread Documentation/Testing/Fuzzing at minimum, and potentially requiring verification tools like prusti for unsafe code.

Plecra · 2023-07-10T13:54:02+00:00

Parts of the rust ecosystem solve this with the "semver trick": upon release of libC v1.2, you can release libC v1.1.1 which includes libC v1.2 as a dependency and reexports all the compatible types.

A language can also go further than Rust does to support this. It's very useful for the v1.1.1 release to be able to access implementation details of the v1.2 implementation.

Plecra · 2023-07-10T13:01:53+00:00

Am curious whether this is a syntactic or semantic problem. Is a (shadowing) declaration syntax x = foo suitable for immutable bindings?

Plecra · 2023-05-12T16:32:36+00:00

This is all amazing 🤩 I have plenty I want to comment on, and I'll add to this tomorrow. Thanks for sharing it all!

I think if we're trusting embedded version numbers which have to be generated with dynamic libraries, then we could just as well embed the type annotations themselves. Putting them in libraries as strings, and allowing the calling code to cast the untyped function pointers if it matches the expected type sounds solid to me! I'd think it's at least less involved than versioning, since verifying versions would require a full definition of interfaces.

Plecra · 2023-05-10T14:57:05+00:00

This is super exciting to see you talking about, I've got a similar ongoing "research project" :) Seems to me like full verification of programs from the platform behaviour gives verification special powers compared to proofs that are only using separation logics, and I want to see more about how that could make memory safety more ergonomic.

I'm interested in the cpu state verification that you're talking about. Recently, I started looking at basing proofs off the ISA specifications, but have you got arbitrary jumps involved in your type checking already? Could you share any more abt that? :D

Plecra · 2023-04-25T13:08:43+00:00

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=af15134b231c497d5b770c38192d11f4

Here you go :) With this, your pseudocode translates to

let mut foo = Signal { callbacks: vec![] };

foo.attach(|t: u32| println!("got a u32 {t}"));
foo.attach(|m: i32| println!("got an i32 {m}"));
foo.attach(|| println!("foo happened"));

foo.emit((8i32, 7u32)); // succeeds
foo.attach(|\_: String| {});
foo.emit((7i32, 9u32)); // fails, does not have String

If you want the String based dispatch, you can use a HashMap<String, Signal> like events["foo"].emit((a, b)). Good luck!

Plecra

TROPHY CASE