esprehn

That's also possible in JS with __proto__. The prototypes of the classes in the chain can be mutated at runtime too. How to handle these cases is well understood for JITs though and python could do the same.

See also the warning here:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

And this related article:

https://mathiasbynens.be/notes/prototypes

What are the two cities? You'd need to control for a lot of factors to figure out if the competition is the reason or the local market rate is just lower.

The policy has existed for quite a while, but strict enforcement didn't come about until the great Paris outage of 2023.

That won't work with trusted types enabled.

That's not how html works. The html parser is by definition streaming.

The lithium battery used in a Pacemaker is entirely different than the one used in phone.

https://www.pacemakerclub.com/message/33435/pacemaker-batter...

Very cool idea, though I think we're a long way away from this. Hopefully they file bugs on the specs when they find ambiguities.

Also the specs are written to define observable behavior, and there's a fair bit of ambiguity that's UA defined, but to be actually compatible with the Web requires doing what Chrome does.

The good news is that you can look at the source of the 3 major engines (and Ladybird!) and your AI agent can do comparisons and figure out optimizations.

Have you tried something like "Always consult the utils/ package before writing helper functions. When adding a new generic helper function justify it in your design or PR description."

I have better luck telling it positive things rather than lots of "never do X" style things.

The implementation of the Web APIs look very broken and incomplete: https://github.com/h4ckf0r0day/obscura/blob/main/crates/obsc...

This might be faster in some benchmarks, but it's not really implementing the web.

I'm more optimistic about AI browsers based on Ladybird or Servo which are actually trying to pass WPTs.

Larry designed the algorithm and Brin implemented it. Not so different than what we saw with transformers and LLMs. The people who came up wit the ideas and the algorithms were joined by others who implemented them. Together they made it all work.

You can animate it now. There's no default though which is a bit annoying. I wish we had made it animate open/closed smoothly.

https://austingil.com/animating-details-element-with-only-cs...

https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/S...

Script attributes are very often disabled for security reasons.

The declarative actions API is currently only used for popover, but it's been discussed for over a decade to allow SSR of rich content that's interactive before script loading. See also https://developer.chrome.com/blog/command-and-commandfor

For a long time I also pushed back on these interactive APIs because script is a better primitive and every site seems to have quirky requirements. I've come around on it though because there's huge demand for SSR again and businesses are seeing the value in very fast TTI.

I do still think the date picker API is a disaster. Everyone actually needs something much richer than the system date picker. Travel websites want ranges. People want to put dots and day highlights. I wish they'd fix that next.

As opposed to what? Not sure what the alternative you're picturing is.

There were a lot of factors that led to the dart decision. It's also important to note that Flutter is very old, we were designing it in 2014.

- we wanted hot reload

- it was supposed to feel familiar to web developers and reasonable to native developers

- iOS needed AOT compilation for speed since we couldn't use a JIT

- TypeScript had literally just reached 1.0

- Swift looked promising, but the Oracle lawsuit made the idea of using it tenuous

- Kotlin was not even 1.0 yet, that wouldn't happen for 2 more years

- Go made huge binaries. The language was also lacking features like generics and Go was unwilling to add them (remember this is 2014).

- v8 was not interested in AOT, but Dart was willing to dramatically invest in flutter

There were probably other reasons too I'm forgetting.

Dart was a really pragmatic choice to ship quickly. I have mixed feels about how the decision has aged over time, and wish we had things like Hermes and WASM back then, and a willingness to build a TypeScript compiler like other native frameworks (ex. Valdi)... But for the time I think the choice was reasonable.

The frustration with the Gmail triager is typical unfortunately. Google teams have outsourced almost all user issue triage to contractors and the actual engineers don't interact with the community or users. Hopefully some Googler sees this and can get the Gmail team to fix it. The image proxy is useless if emails can trivially work around it.

Airbnb has a version of this internally that was pretty awesome called Evergreen, based on the Uber paper as well.

I wish more companies would open source their monorepo infra. A well done monorepo is a huge force multiplier on a large organization, but the OSS world is lacking a lot of the infra so everyone starts from a painful place and works up or has a bad impression of monorepos. Google's Piper is another example where open sourcing or selling it would have done wonders for the industry. In an age of agents landing code very quickly piper has scaled very well since it was already at unimaginable commit velocity, meanwhile everyone else is trying to rebuild source control to keep up.

Servo is 14 years old, it's hardly a new project. Ladybird has come much farther in a shorter amount of time. The issue has always been Mozilla not being focused.

Not supporting comments will be a mistake that haunts this API. They give an example of replacing properties files but those do have standardized comments! The proposed pre-processing step means all the comments are lost during round tripping, and the single line comments they suggest are not enough to even match JSONC. By the time those issues have userland workarounds you might as well use another library instead of the built-in one.

This seems to repeat the same mistakes of Go's built in JSON library where the ecosystem is full of workarounds and other libraries that are faster or have better features.

GKE uses spanner (with an etcd API layer) per the docs.

https://docs.cloud.google.com/kubernetes-engine/docs/concept...

https://cloud.google.com/blog/products/containers-kubernetes...

GitHub and LinkedIn both appear to be pretty successful businesses.

Is Xbox really worse than Play-Station?

It's a pretty good name actually because it's unique, easy to Google, and is never ambiguous in conversation. It's all the suffixes that made a mess of it.

Yahoo. They very nearly bought Google too, but refused the initial $1m offer and then bid too low the second time. Kind of hilarious to see how that played out over time.

  Yahoo had two failed attempts to acquire Google; in 1998, Larry Page and Sergey Brin approached Yahoo to sell their nascent search engine for $1 million, but Yahoo declined the offer.[37][38]

  In 2002, when Terry Semel entered into negotiations to purchase Google. Google was reportedly seeking a price of $5 billion. After weeks of negotiation, Yahoo's final offer was $3 billion, a figure that Google's leadership rejected, leading them to terminate the deal.

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

The good part about a language runtime is there's a massive corpus of tests that are in that language and agnostic to the implementation language.

For a JS engine that's Test 262: https://github.com/tc39/test262

For node that's its unit tests which are mostly JS: https://github.com/nodejs/node/tree/main/test

Node also runs the web platform tests too: https://web-platform-tests.org/

Bun has a similar large corpus of JS/TS tests: https://github.com/oven-sh/bun/tree/main/test

You're right about general purpose rewrites, but language runtimes are a lot easier.

Apple was doing effectively everything on that list, though the self driving car was cancelled and the AI is now gemini.

Is the simpler thing not Lambda/Cloud Run (with terraform)?

On the application developer side k8s is awesome fo, but the you look inside the box and it melts your face off.

I'm not sure a middle ground exists unfortunately. It's either full service like Lambda or bag of knives like k8s.

I assume they meant the Attention process in LLMs, not the human concept of paying attention:

https://en.wikipedia.org/wiki/Attention_(machine_learning)

One big difference seems to be Mastra has tests and this project doesn't.

It also can't inherit css variables which is unfortunate since it means the image doesn't respect the theme.

They totally could sanitize it, just like they did with the gadget proxy, they just choose not to fix this ancient request.

It's like my ticket to add data url support to sheets. It just gets punted year after year.

There's a whole movie about a snail that's super fast (Turbo). An adult version of that isn't so far fetched.