Many people do use GitHub for this. There are even Android app stores hinged around searching and installing release APKs.

The social connectivity and discoverability in github is a big reason many people use it. Can't say how many, but it is.

I don't think I've ever searched for anything on github. I always follow a link.

that's something you tell your interviewer

Seems silly. I sure wouldn't not hire someone because of that. Might as well be concerned they have a green toothbrush instead of a blue.

This is likely one of the many pains of App Store subscription configuration issues. Once anyone has subscribed you will have to migrate those yourself and even those details I'm not sure what restrictions there are. The latest seems to be one-time purchase, but historical cleanup is probably necessary on their part

Agreed, but this isn't always bad. Optimizing early with unclear requirements can kill time, which at an early stage is just delaying product launch.

Migrate/optimize later when you're actually reaching scale is a perfectly reasonable approach.

In fact, if you have a decent abstraction or standard in place (e.g. S3 API or repository pattern) you can swap it out in place.

I absolutely have used AI to scaffold reproduction scenarios, but I'm still validating everything is actually reproducing the bug I ran into before submitting.

It's 90% AI, but that 90% was almost entirely boilerplate and would have taken me a good chunk of time to do for little gain other than the fact I did it.

I have usually explained to my teams that you only should be doing this at the boundaries of the system. User input, raw files, request bodies, etc. are places where you would _need_ to determine an actual type for an otherwise unknown value.

Even then, a solid validation/parsing library like Zod is a better choice than casting, it is much less error prone at ensuring you have the right type applied.

Beyond that boundary, casting with `as unknown` is a massive code smell and often introduces any further use of that data to invalid type errors. I'll refer to this as "force casting", because simply casting "x as T" with sufficient strictness configured will still fail type checking if x is not compatible with T, and that can be fine for certain cases like reducing a complex type or giving an inferred parser type a form that fits your domain types.

Developers that force cast too readily can end up creating hundreds or even thousands of type errors in the codebase over time, and they are pretty quickly revealed once you peel away the casting. The same is true when starting from an `any`, where every reference thereon is equivalent to a force cast.

There can be some complex typing scenarios that do require it, but even then a good type guard works better even if certain cases can be semantically equivalent, you can write tests around guards as they're just functions, ensuring some logical correctness to the typing.

The simplest but maybe odd way to judge whether a casting is used the wrong way is to ask "are you lying to the type system?". If so, how can you better portray that type correctly (validation that determines a correct type for you (e g. Zod) or type guards).

Yes, using something like zod at boundaries is the right approach.

(Personally, I'm not convinced zod itself is the way to go -- I'm suspicious of its lack of stability. The last thing I want to do is redevelop the boundaries of my system in a few years because zod 4 has been killed off in favor of zod 5, and then again in a few more years for zod 6, etc.)

It definitely would be interesting to have proposed alternatives and even examples included as part of this piece.

As far as I can tell, people who are paying for support contracts were also impacted by this. It was explicitly called out in that thread

Their example in the README is extremely misleading then. It indicates your stream output is

name: A name: Al name: Ale name: Alex

Which would suggest you are getting unfinished strings out in the stream.

How is it misleading? It shows that it gives back unfinished values but finished keys.

Based on this thread that's called NDJSON

Newline Delimited JSON

TIL

It's also known as JSONL (JSON Lines).

I'm pretty sure jsonl was a bit earlier as a term, but ndjson is now the more prominent term used for this... been using this approach for years though, when I first started using Mongo/Elastic for denormalized data, I'd also backup that same data to S3 as .jsonl.gz Leaps and bounds better than XMl at least.

This approach couples together everything though, in such a way there's no standard manner of wiping cache but not your app, configuration, etc.

XDG may not be perfect but wiping related data for apps following it is straightforward. There are a few directories to delete instead of 1, but still consistently structured at least.