1,267 karma · joined November 4, 2017
But fonts with good CJK support have wider Latin letter-forms, even when not in `font-variant-east-asian: 'full-width'` mode. I write about this here: https://maxbo.me/subordinate-latin.html (and cite "the peculiar case of Japanese web design")
I recently caught a glimpse of her Facebook and I was shocked to discover a version of the website that seemed to be the platonic ideal of exactly what all the Facebook PMs intended. Her feed was filled with the photos of her friends and coworkers international trips and holidays, posts in groups for planning activities in her most frequented cities. But I discovered that my mum was also a frequent "poster" of the photos of her various trips around the world, and the comments sections were filled with with some beautiful messages from her many many friends and family.
From this I learned that there is a subset of the population that Facebook works perfectly for and meaningfully improves their real-world social relationships. And perhaps Facebook has been hyper-optimized for that kind of use case through relentless A/B testing. But I fear my mum is quite privileged to have this kind of experience.
> A deploy pipeline that queries your orchestrator for running image tags, checks your migration history against the schema registry, diffs your GraphQL schema against collected client operations, and runs Buf’s compatibility checks: this is buildable today, with off-the-shelf parts.
that was largely successful at eliminating interservice compatibility errors, but it felt like we were scrambling around in a dark and dusty corner of software engineering that not many people really cared about. Good to see that there's a body of academic work that I was not entirely aware about that is looking into this.
The article successfully identifies that, yes, there are ways, with sufficient effort, to statically verify that a schema change is (mostly) safe or unsafe before deployment. But even with that determination, a lot of IDLs make it still very hard to evolve types! The compatibility checker will successfully identify that strengthening a type from `optional` to `required` isn't backwards compatible: _now what_. There isn't a safe pathway for schema evolution, and you need to reach for something like Cambria (https://www.inkandswitch.com/cambria/, cited in the article) to handle the evolution.
I've only seen one IDL try to do this properly by baking evolution semantics directly into its type model, typical (https://github.com/stepchowfun/typical) with it's `asymmetric` type label: it makes a field required in the constructor but not the deserialiser. I would like to see these "asymmetric" types find their ways into IDLs like Protocol Buffers such that their compatibility checkers, like Buf's `buf breaking` (https://buf.build/docs/reference/cli/buf/breaking/), can formally reason about them. I feel like there is a rich design space of asymmetric types that are poorly described (enum values that can only be compared against but never constructed, paired validations, fallback values sent over the wire, etc.)
Another one that I think makes a pretty good attempt is the config language CUE and its type system (https://cuelang.org/docs/concept/the-logic-of-cue/), which allows you to do first-class version compatibility modelling. But I have yet to investigate whether CUE is fit for purpose for modelling compatibility over the wire / between service deploys.
I would not be surprised if this is intentional. The Are.na REST API is extremely permissive too.
To cut to the chase, I think local councils are really upset that Telstra has the right to put these anywhere they want.
So the proposal is to... put the permissions grant flow _below_ the line of death? Permissions grants _should_ break out of the untrusted context! It's a privilege escalation that only the browser (and its associated UI) should be able to grant!
[0] https://textslashplain.com/2017/01/14/the-line-of-death/
Do you foresee this project getting a Web Components API like A-Frame and Google's <model-viewer> component (https://modelviewer.dev/)?
An artist page: https://rateyourmusic.com/artist/stereolab
An album page: https://rateyourmusic.com/release/album/stereolab/dots-and-l...
I personally adore it - RYM is permanently open on my 3rd monitor throughout the work day as I churn through new music.
In my case, I have, in the pursuit of my engineering goals, had to dig into a Python component that I did not normally work on or intend to work on. I am thankful it had type hints.
Do I have Stockholm syndrome or is the code here completely fine?
Author: Nothing stopping you from forcing a Jupyter notebook to self-host itself: https://hello-notebook-http-mode.fly.dev/ . Then you can just use HTTP to send messages back and forth between the browser and the notebook.
The article is documenting me trying to do that replication. What's it used for? @celine/celine (https://maxbo.me/celine) is the packaged product that I now use for some private articles that I've been writing.
Thanks for the heads up about SliderServer btw, was experimenting with something similar with Jupyter: https://hello-notebook-http-mode.fly.dev/
It's still not quite there as a platform for exploratory data analysis - you don't have the instant reactivity of either a fully-fledged web code editor from Observable Notebooks or the hot-reloading file-watching Observable Framework. And the new Jupyter Kernel for Deno + VSCode is a pretty smooth experience too.
So while I agree that the ergonomics for exploratory analysis is uhhhh bad, I don't think the _publishing_ ergonomics is that bad. In fact, they're good. It's just a single file! I don't need to maintain some massive toolchain or pay some 3rd party service to just send someone a graph and some data munging - I just lob a HTML file at someone over Slack or host it somewhere. And the flexibility to style the analysis means that you can publish in environments where styling is important (blogs, or as a research paper).