nawgz

> people know it is a problem but ideologically they really disagree about what to do about it

Can we really say this is true about individuals in the US?

I think it's pretty clear the propaganda machine has successfully privatized health care to the great detriment of the populace and have the clamps on it.

After all, if you told everyone you had a solution where insurance rates would be cheaper, their healthcare system would cost less overall, and the health outcomes would be superior, they would all be like "sounds great". Then, when you reveal this solution is the complete destruction of the insurance "industry", insurance payments are "tax", and the health provider is the government, they would balk, scream about socialized healthcare, and say how they don't trust the government.

That's a trained response, not a real thought.

Can you give some examples? I feel like React is still pretty much just React, having developed with it for a decade now. Hooks was the only meaningful API (surface) change, no?

No. Browser dev tools are available, and make it pretty easy to do performance profiling, and get a flamegraph etc..

Just seems like the reality of things is that the number of extensions or widgets or whatever has remained low enough that this extra sorting isn't actually that punitive in most real-world use cases. As a long-time developer working mainly in VSCode, I notice no difference between performance/snappiness in VSCode compared to JetBrains Rider, which is the main other IDE I have meaningful experience with these days.

A bit sloppy but easily resolved - surprised it took so long to notice, or maybe it was new?

It just contrasts expectations of the unwashed masses with more professional writing.

If most people are used to reading social media and texts from their friends and maybe subtitles for movies, an em dash is practically never going to appear, and so when everyone and their dog start using them, well, it’s obvious something is up.

Whereas the more literate individual used to consuming writing for pleasure will have seen them regularly, and may even have employed them while writing.

> If I code a var blah = 5*5; I know the answer is always 35

I greatly enjoy the irony here.

For instance, while I work in small teams, I’ve relied on Hasura GraphQL-Engine a lot for my api. This is a full GQL API automatically generated from your SQL schema, Postgres being the best supported DB. GQL relations are available across foreign keys (or manual joins which I never use), so a well defined normalized schema can have deeply nested queries executed easily with full type safety for the consumer.

Taking an HR example, you could query for an employee, their PTO status and accrual history, their manager, and their reports all in one nice easy query that no one has to write any business logic for, just a schema set up with employees, manager, reports, and PTO tables joined on ID keys.

And in such a case, what abstraction does the backend team need to put in front of the schema? I can’t motivate what this means myself. A well designed DB schema is truly a beautiful contract, and with table and column comments you can even get intellisense docs in the IDE for the front end team building the client.

On the flip side, I agree the write operation should be done thru an API when there is complexity and requirements beyond just writing one row to one table, but read operations are much more graceful and speedier to define in GQL than REST.

Re: GQL - Explain to me what abstraction layer should exist between the data model and what data is loaded into the client? I’ve never understood why injecting arbitrary complexity on top of the data model is wise.

Perhaps unfettered write access has its problems, and GQL has permissions that handle this issue plenty gracefully, but I don’t see why your data model should be obfuscated from your clients which rely on that data.

I mean, Canada has had a tepid response to the implosion of their neighbour and relations - I think they have done little outside some retaliatory tariffs and “committing” to a 10 year plan to double trade with non American partners.

Is that really such a bold set of accomplishments that Ford should be shutting his mouth and falling in line behind? Trump could change his mind because Putin or Miller or Vought tell him to, no need to act like precarious progress is precious from my perspective

Interesting callouts! Thanks

I think the title undersold it. I would call it "a nonexhaustive set of abuses of casting in TypeScript"

I actually thought that calling out the `is` operator was useful, I have a generic utility method I call `filterFalsy` which takes `T | undefined | null` and returns `arg is T`, which seems decently safe, but it's interesting how it would fail when asserting between two types.

Unconvention 2 made me vomit, inlining a function like that would never pass code review, indeed if you remove the mutator from being declared inline it restores type soundness as you would expect

Unconvention 3 is important to learn, TS "duck typing" is not resilient to usage of spread/Object.(keys|values|entries)

Unconvention 4 is why I argue to use `callback: () => unknown` whenever you won't use the return type, it is the least restrictive and also implies to stay the hell away from that return value.

Fun article.

Please, bundling React with Next is completely foolish. React is open, battle-hardened, type safe, and well-documented, while Next is... a vendor lock-in trojan horse targeting low-knowledge developers with concepts that seem beginner-friendly.

I can understand making legit criticisms of React, no doubt the hooks transition had some issues and the library has a high level of complexity without a clear winner in the state management domain, but pretending React is peddling shit like "use workflow" is frankly low effort.

Docs seem really underbaked.

- where does the state and telemetry get stored?

- if something is sleeping for 7 days, and you release a new version in that time, what is invoked?

- how do you configure retries? Looks like it retries forever

And I echo the hatred of the magic strings. Terrible dx

Sounds interesting. Why wouldn’t the OS itself default to this behavior? Could it fall apart under load, or is it just not important enough to replace the legacy code relying on it?

> ... then you've known someone who has struggled to eat enough to maintain and build weight.

I'm not trying to strawman here, but I've never met a person like that who was ever overweight at any point in their life.

It seems pretty obvious to me that saying "some people can't eat enough to put on weight / get fat" is a distinct thing from saying "someone who cannot stop putting on weight / getting fatter will almost never be able to lose the weight without adjusting their diet". Do you agree or am I missing something?

Have you considered if you have ADHD?

I see now, those “decode” and “eval” are huge red flags that are downplayed heavily by the author. Cheers for the response

Well, for anyone using Vue you get automatic observability baked in, right? And reactive programming state management libraries within react are plenty popular, not to mention the built in state management being quite literally UI = f(state).

The fact people use the tortured disaster that is redux isn’t really a knock on react in any sane person’s view, we all know the JS community is full of beginners who don’t know better

Well, I think that it’s obvious on the face of it that managing human sewage instead of throwing it into the streets would be a better alternative, given that our own waste is toxic to us. The claim about “otherwise” should be sourced.

Sure, the dog is dirty.

But our animal bodies evolved to live in the dirt, no? I believe it to be true that babies who grow up with dogs and are exposed to their "dirtiness" actually develop stronger immune systems.

Here's the first study I could find on the topic: https://www.sciencedirect.com/science/article/pii/S088915912...

Anyways, not to criticize your hygiene, but I find it interesting how human constructs are often not actually that good for humans.

Cool write-up. Seems pretty unintuitive to me that Unicode would allow someone to serialize normal code as invisible characters and that something like an IDE or a git diff has never been hardened against that at all.

In my mind it's one thing to let a string control whitespace a bit versus having the ability to write any string in a non-renderable format. Can anyone point me to some more information about why this capability even exists?

Honestly, if you’re getting thru life with this attitude, good for you, but you might want to consider if it’s the only way

This type of dismissive attitude is so strange to me. The only reason "lifecycles magic + probably global_state" would be causing your app to behave unpredictably is - this is going to shock you - because you closed your mind to a tool by dismissing it as garbage before you used it, and then failed to use it properly because you think its popularity boils down to PR.

For instance, you could entirely forgo the influence of lifecycles and global state by putting everything in a top-level Context with 1 state object that you only ever update by calling `setState`.

After that, you might find reasons to optimize your app, which could lead you to more interesting approaches like reducers or state management libraries or memoization, but I'm guessing you would never get that far and just go back to what you were doing before, since YOUR preferences are battle hardened and reliable software, while things you don't know about are only popular because of Facebook. Obviously.

Surely you’re not saying the frameworks famous for ui = f(state) actually suck at managing state…

Yes, it is open source, and Docker containers are freely accessible too

https://github.com/hasura/graphql-engine

https://hub.docker.com/r/hasura/graphql-engine

I run v2.x images myself, not sure what v3 and DDN are, besides monetization efforts for the company*.

Also the migrations are just `up.sql` and `down.sql` files, there is nothing coupling you to a proprietary migration format, the value Hasura offers is generating them for you and tracking their application thru their CLI.

Sorry for the late response. I appreciate the perspective you are offering.

I totally agree JS can be surprising, and actually I think the greatest skill a JS developer needs is to understand what things are powerful reliable and composable as opposed to hacky, where you can understand hacky things lead to surprising behavior.

For instance, I too have used Sequelize, and it is a painfully bad library. I can only see that network effects have lead the community here, there is no merit. Instead, I think the scrutinizing JS developer - the one who can write reliable JS - needs to just throw Sequelize out. It sucks.

I happily did this, and so I looked elsewhere at what the community was trying in terms of data paradigms. An obviously interesting invention of the JS community at the time was GraphQL. After some time, I decided writing my own resolvers in JS was an exercise in futility, but I found it incredibly attractive to use the tool Hasura to give a free GraphQL API over a DB.

PostgreSQL, Hasura GraphQL Engine, GraphQL, graphql-codegen, and typescript combine to make this amazing chain where you can normalize your DB and rely on the foreign keys to make up the GraphQL relationships, get automatic knowledge in the GQL you author of whether the relationship is nullable or represents an object or array relationship, and then load deeply nested (i.e. semantically rich) queries to author a type-safe UI in. All of this requires 0 packages to be published, I just use a monorepo with `pnpm` and my client can talk to Hasura safely with the generated code from Hasura GraphQL Engine, or to my TS backend via tRPC and tsconfig.json "references".

Now when it comes to migrations, Hasura has first class support, it's really incredible how you can use `hasura console`, click in a GUI to make all your database changes, and have a migration written to source code ready for you to use after this.

So, take it this way: Sequelize sucks, TS can't polish a turd, and the job in JS is to discover something powerful and useful.

In Python, you would never have touched a garbage library like Sequelize because Django is amazing and the community recognized that.

And now, let me show you my personal bias

> Everything in JS feels like a hack job, built on a pile of someone else's hackjobs.

Nah, you have it exactly backwards. How are type hints not meaningful in Python in the year 2025? Sure, named args and some other things are useful, but Python is the king of the untyped dynamic happy-cast do whatever BS. The code is insanely terse but that's directly a bad thing in this day and age when that terseness is directly achieved at the cost of meaningful typing.

I for sure recognize this partially stems from the activities one performs in the language, but having to run your Python to know if it works is objectively hilarious. Well crafted TypeScript and ESLint recommended catches virtually all my programming errors, such that I would never run into this problem

>if you miss an `await` in your controller, the entire server can crash if that call fails

My IDE calls that out! As it should! As Python refuses to!

Podcasts are horrible content slop that are appealing more because one can enjoy the parasocial relationship it offers rather than because the podcasters are insightful or informative.

As a Canadian... Canada is weak, poor, and corrupted by the same plague that has lead America to where it sits.

The rule of law is holding on a bit tighter, and quality of life isn't as bleak as the States, but Canada needs some serious reforms to break the hold of the elite class.

Seriously, look at how the temporary foreign worker program enriched the elites and then is used by their centralized media machines to radicalize the population against immigrants. It's a bad joke, and this exact regulatory capture runs deep and wide.

This is quite a large set of things to hand wave away with no additional justification. Makes it sound more like personal bias than meaningful insight

Care to give some examples of those trivial things you’re fighting?