Geoff Goodman

There is some pretty wild stuff out there that I do not understand but believe might be part of one kind of solution: differentiable data flows.

For example: docs.rs/differential...

I don't know that a social network is the kind of problem best (currently) suited for sync engines.

I think that is among the hard problems. I don't have an answer I'd feel confident saying.

There are a few spins on where the reducers live, I think.

In one spin, a kind of reducer needs to live near where data is persisted. Another kind lives on the clients. The events and actions they reduce may be different but are coordinated to propagate eventually-consistent state.

Distributed redux.

Here's a demo of two aspects of MCP Auth.

1. Authenticating to an MCP Server in coordination with the MCP Host (VS Code Insiders).

2. Authenticating to a downstream service (Confluence) on demand for a tool, `confluence_search`.

The MCP Host provides (1) but is oblivious to (2).

@superhackers.bsky.social what's up with the repeated likes on the same posts over time?

Go Habs Go!!

Society at large would benefit from a PID controller.

Excellent job on the release and blog post.

Does the team plan to offer some of the component packages as public, stable-ish modules?

That could create quite an inflection point for the go JS tooling ecosystem.

Really just the browser (monaco).

Do you have plans to continue to support runtime environments that can't run native binaries? WASM build and bindings maybe?

What does this mean for use-cases that run in browser-like environments where we can't run native binaries? Will a WASM build and wrapper be created?

Geoff Goodman on X: "Listening to your (@schickling) interview with @jlongster that lament about Promises really resonated. I've been mulling over some minor new syntax to give power users the tools to escape micro task hell. I call it asyncish and awaitish, denoted by `async?` and `await?`. 1/" / X Listening to your (@schickling) interview with @jlongster that lament about Promises really resonated. I've been mulling over some minor new syntax to give power users the tools to escape micro task hell. I call it asyncish and awaitish, denoted by `async?` and `await?`. 1/

On X, I had explored this space with an asyncish/awaitish syntax: x.com/filearts/sta...

These would be opt-in graph colour-buster syntax that a sufficiently good compiler could down level. But runtime support would be needed to really unlock the perf potential.

It has "A Tale of Two Cities" vibe building.

Sending unsolicited AI-generated email to the address scraped from my GitHub profile is not a growth hack, it's in violation of the CAN-SPAM act.

I think it's the same phenomenon that explains certain framework flame wars. Folks sometimes associate themselves emotionally with projects, VC funded or not.

It seems like that provides everything needed to hack arrays and maps into css 😁

Some critical projects like @typescriptlang.org don't (or can't) follow SemVer. They suggest users pin versions in package.json.

But what if npm package versions could explicitly *declare* their compatibility range.

Clients could further constrain ranges for upon opt in.

Best of both worlds.

I've seen folks looking to use AsyncLocalStorage as a way to propagate identity across async boundaries in server logic.

That seems very scary to me because AFAIK it relies on 3rd party libs opting into AsyncResource or risking confusion in some edge cases.

WDYT?

They're feeling the years for sure but maybe they've got a few more in them 😅

WinterTC is here 🎉

TC55 is a new Ecma Technical Committee for Web-interoperable Server Runtimes, originating from the existing W3C WinterCG group.

This means the group is now able to publish standards, with the first effort being the Minimum Common API.

I've been rocking the same slippers all day every day for almost 20 years. They were swag for a college sports team I was on. Came from somewhere in Slovenia that I've never been able to track down. Leather and cork.

Might these let me move on?

Tools: Common Conventions · Issue #49 · tc39/js-outreach-groups There's a variety of behaviors in authored JavaScript that (web) developers may depend on that aren't described in any officially published spec. This is an attempt to collect them and link to the ...

What are some useful pattern you’d expect to work across bundlers? We’re collecting a list here: github.com/tc39/js-outr...

I still haven't figured out WTF nitro is and hope I never have to.

🤦‍♂️ thanks

@zachleat.com fascinating interview on @syntax.fm. Very inspiring.

It sounds like many of the product velocity benefits of federation could also accrue on the backend. Do you have thoughts / observations? Worthwhile pursuit?

This seems like a fascinating innovation in load balancing but I feel like I didn't get a full picture from the talk:

1. Do the use the latency of the Probes or some aggregate of the Queries as predictors?
2. What if Queries are very heterogenous?
3. How do they derive predicted latency for RIF(n)?

Do you think it is a compelling design?

I think that I would be able to get more done straight from within Slack if I had access to tooling akin to Copilot.