Jovi 🐨

Yes, that's more the kind of take I follow you in. It really sucks at async, it can't really reason like we do about the permutations of ordering that could occur. As long as it's synchronous it's pretty good and the prototypes rock. Or bootstrap an accessible component

Adjust usage by JoviDeCroock · Pull Request #368 · 0no-co/GraphQLSP

Example of a more complex piece, the pr it came up with github.com/0no-co/Graph...

The context: we've added a bunch of helpers in github.com/0no-co/Graph... - analyze the codebase where we use typescript methods in the helpers, refactor function by function and run the tests after each change.

Tasks I've had a lot of success with:

- Prototype x, then you make the prototype great
- Iterate on this performance (include command to test perf)
- Convert from library x to y
- Write tests, need a lot of guardrails here in context

For code however, you can't just rely on a plain LLM, you kind of need to try claude-code or the CoPilot agent mode for it to actually be meaningful.

I really disagree with this honestly, it's been really great for me. I agree with the junior aspect of it but if you provide context and anticipate the footguns it will run into it's pretty accurate in what it does.

Ensure we rerender after a suspensefully hydrating boundary throws an… by JoviDeCroock · Pull Request #4856 · preactjs/preact Consider the following scenario, we have an application with a shell: App Header Suspense ErrorBoundary Body --> Async Footer We server-side render the HTML, send it to the clie...

github.com/preactjs/pre... is the solution pull request which links back to github.com/preactjs/pre... where we had the conversation

I've been chasing a bug for a while now in Preact where there is a very rare but deterministic case where we'd crash. Thanks to a contributor we got to the bottom of this and I'm forever grateful to people like this that take the time to talk through issues with me

It's remarkable how well Claude can analyze pictures and how little tokens it produces compared to me describing what's on the picture.

Took a screenshot, pasted it into claude code and it did the correct thing😅

And... that's another part of the ecosystem to support it github.com/0no-co/gql.t... your GraphQL types will keep working even when your documents get descriptions

Imagine a system where we ingest all of our queries and when we analyze the query done by users we use the descriptions to derive the intent of a journey/query/... We can now query the operations being dispatched in natural language and so on.

Soon GraphQL.Web and Bluejay will support parsing Executable descriptions on Fragment/Variable/Operation Definition nodes. This means that we can now share the use for an operation/variable/fragment over the GraphQL AST. This might look small but...

Man, I just love modeling state in @svelte.dev 🧡

- State vars are just properties on a class
- Complex values, like this cursor position, can be $derived from other state. Svelte figures out when to recompute
- Go-to definition shows all the usages of that state too

fusedata.dev

YES! State models with observable atoms like signals/runes/... are great. I talked about this on the LearnWithJason show as well, it's so ergonomic and doesn't make your components littered with all the logic.

We need a European Sovereign Tech Fund With a new feasibility study, GitHub’s developer policy team is building a coalition of policymakers and industry to close the maintenance funding gap.

We need a European Sovereign Tech Fund
github.blog/open-source/... "Open source software is critical infrastructure, but it’s underfunded. With a new feasibility study, GitHub’s developer policy team is building a coalition of policymakers and industry to close the maintenance funding gap."

Revisit our gql.tada panel from London GraphQL last year: www.youtube.com/watch?v=ZmRw...

Fuse may not have taken off but it had a pretty amazing video showing the power of gql.tada gql-tada.0no.co

Fuse: TypeScript API Framework Aggregate all your data sources and transform them into a great GraphQL API for your clients with many best practices built-in for you—fully typesafe.

fusedata.dev for those unfamiliar with the prior version

Maybe I should do another attempt at something like fuse where we have opinions on

- Schema authoring
- Ensure types are done well
- Persisted operations out of the box

Might just be great if it's CloudFlare first class as we could even have infrastructure opinions then.

Sometimes I hear that it was a mistake to build
@vendure.io on top of GraphQL.

"Too complex", "Can't be cached", "Poor performance", "It was all hype"

Yes, every technology has its tradeoffs. I'm keenly aware. There *are* some aspects you need to be mindful of when working with GraphQL.

Awesome! If you'd use `turbo` you could save some battery for every time you boot up the project. Then only the documents changed in your branch need to be parsed/calculated.

gql-tada.0no.co/reference/gq...

would love to peek into that? Did you use gql.tada?

Look, I've been around a while & remember when we used to bundle with Grunt, then Gulp, then Webpack. So isn't Vite just an incremental take on what has gone before?

No - Vite has something that makes it magical. An absolutely sublime plugin API that feel like you can build *anything* with it.

Preact is ready: stackblitz.com/edit/formisc...

In light of my recent episode on @learnwithjason.dev, I decided to write a blog post about State models and signals.

It's kind of chicken and egg, either you risk sending a useless fetch, which you can work around github.com/urql-graphql...

Or You can delay the fetch until the component mounts and risk flashing content when it is actually cached....

A lot of this suspense behavior really sounds ill-thought through, we need to cache promises but then again we aren't assured of the component lifecycle if it needs to initially mount... Oh and there are lanes as well

Oh gotcha, in our case that would mean we'd need to add a .catch github.com/urql-graphql... and dispose it there as well I reckon

So you add it to reclaim and when the unmount (teardown for us) fully triggers you actually remove the promise github.com/urql-graphql...

When the component fully unmounts you should be safe to remove it github.com/urql-graphql...