flakes

Potentially, for now I can get away with my custom filter list :)

I generally try to limit the total amount of extensions I have on my browser, to a list of tools I feel that I can trust. I apply the same mentality for dependencies in my software. Limits the surface area for supply chain attacks.

Seems to be not hitting every user the same way. I also did not have any direct message about ad blockers, but I did notice videos not loading correctly and requiring a page refresh to work. Updating uBlock seemed to fix that issue. It was only afterwards that I heard of others having problems.

One thing which seriously improves my experience is using the "Block element" feature on non-ads as well. Suggested videos, youtube shorts, banners, etc, all get blocked. Leaves the site much more lean and leaves less distracting visual clutter.

I use this strategy on a lot of sites (which sadly includes stackoverflow lately).

I've been using uBlock since shortly after it launched, and I'd rather lose access to all Google services than not have an ad blocker. I seriously question how people use a browser without one. Completely changes how the web feels.

I would call that a micro-service architecture using a mono-repo.

I think a lot of people here are conflating mono-repo/poly-repo with a mono-deployment. You can easily add in extra entrypoint executables to a single mono-repo. That allows initiating parts of the system on different machines, allowing scaling for skewed API rates across your different request handlers.

Similarly, you can create a monolith application building from a poly-repo set of dependencies. This can be easier depending on you version control system, as I find git starts to perform really poorly when you enter multi-million SLOC.

At my job we have a custom build system for poly-repos that analyzes dependencies and rebuilds higher level leaf packages for lower level changes. Failing a dependency rebuild gets your version rejected, keeping the overall set of packages green.

See the postmortem https://about.gitlab.com/blog/2017/02/10/postmortem-of-datab...

That was an amazing video, thanks for sharing! I really appreciate that there's a link to the shader code as well. Makes me want to dive into graphics again!

I started using Kotlin in Java 8 before the "record" keyword existed to be able to use "data class" instances. This provided very nice semantics for defining immutable structures, and the resulting classes could be imported into the existing Java codebase.

As the project progressed we started adding more in Kotlin and it massively improved developer experience.

Agreed. The more non-intrusive your APIs are, the better the overall experience is going to be for developers. Diverging from official/standard APIs means higher chance framework lock-in, which has kept me away from a lot of tooling.

Always try to ask myself when adding tooling: What's the chance I'll want to remove this later, and how painful is that going to be?

I feel like this was a trend. Windows Movie Maker from XP was tremendously better than all of their replacements. I remember using that heavily when I was in middle-school, making stop motions and stupid videos with my friends.

I know this is a meme, but after writing a lot of Go, and now finally trying out Rust for a new project, I’m quickly coming to this conclusion.

https://docs.python.org/3/whatsnew/3.12.html#whatsnew312-pep... "PEP 692: Using TypedDict for more precise *kwargs typing" seems pretty great.

That'll be really helpful for nested method calls which proxy a lot of their arguments along. I can also see that helping out when creating stub libraries.

Does God write in Perl 5 or 6?

Thank you. This was much more approachable for someone like myself that has little background (a few undergrad courses) in both machine learning and computer vision concepts.

Yep, I'm tired of fighting the arms race with twitch ads, so I just mute the video now and do something else for a few minutes.

I would honestly be perfectly happy with a black screen for 30 seconds as a compromise to ads. I only leave the twitch webpage because the visuals bother me almost just as much as hearing the stupid sales pitch or the goofy "lol we're so cheeky and random" jokes made non-stop by insurance company ads.

I very much dislike import side effects in any language. Im a lot happier where thing.Register() is still forced to happen in the main function.

Still, I can understand it for some components like loggers to not add boiler plate to every library. However, I was very uneasy to see that enabling gzip decompression in a gRPC server is done through a magic _ import. You have to initialize the server anyways, so why not just make it an explicit function argument?

This 100%. Once the client becomes too hostile, I'll just stop using the service. I've been clear of Reddit since Apollo shut down, and if ad blocks stop working on youtube, I'll just find something else to do.

Apart from just Ads, I use the "Block Element" feature of uBlock to cut down on a lot of other visual noise within sites. For youtube I block the giant rows of "related" video suggestions (which I guess you could consider as ads), and youtube shorts from showing up in my subscription feed.

I call that weaponized dogmas. It’s at least better than people who insist on being DRY by writing an inscrutable generic helper function which will only save 3 or 4 lines of code duplication.

On the note of our acronym: After being a territory of Brittan, Newfoundland was its own country for a brief period of time. Much earlier before this point, Brittan conquered Labrador from the french (which used to be called "New France"), and the ownership over the land was disputed between Quebec and the self-governing colony of Newfoundland for quite some time. The dispute lasted into the mid 1920's, leaving the upper portion of the land in Newfoundland control. Some islands remain to this day under French governance, such as Saint Pierre & Miquelon. When we joined Canada in 1949, we retained Labrador, but were still named Newfoundland, having the acronym NFLD. In the early 2000's we decided to change the name to Newfoundland and Labrador to better reflect our province, and as part of this change, redefined the acronym as NL.

Not quite of the same caliber. A checked exception has the form `R func(T t) throws Err`. A concrete result type (like Rust has) would look like `Result<R, Err> func(T t)`.

The later fits nicely into the `Function<,>` interface, `Function<T, Result<R, Err>>` vs the former requires a different interface entirely, something like `FuncE<T, R, Err>` where `Err` breaks out into an argument for the throws value of the signature.

Because most of the functional libraries in Java work with Function, BiFunction, etc, we end up with incompatible arguments for common patterns such as `map`, `filter`, etc.

Newfie here. Newfoundland dropped the NLFD abbreviation for just NL about 20 years or so ago.

I’ve always heard that we painted the houses with whatever paint was on hand because the wind is strong that it strips away every couple of years. And we’re not a rich group of people, so whatever paint you have is the right paint!

My grandfather used to remark on the houses “they were crap when the went up, but somehow lasted 50 years, so I guess they’re heritage now”.

But, they do look pretty in the summer!

Very true. Checked exceptions in Java are a form of function coloring problem for modern libraries.

Especially painful when using any of the functional style stream operations, like `map`, `filter`, etc, or any other higher order function library. Most take in the standard `Function` or `BiFunction` interface arguments, which will not support method referencing for anything which includes a checked exception as part of its signature.

Final only protects the variable from being assigned a new reference (similar to a const pointer). It doesn’t protect any of the underlying data held by the object from being changed, unless the entire hierarchy has every field declared final as well. I still use final heavily in all of my Java code, but it doesnt convey the full intent I would like it to.

Ive been increasingly disliking ORMs in general lately. After a few days of trying to identify connection leaks and poorly optimized queries in a SQLAlchemy application, I’m starting to lose my hair.

I think this actually speaks well to the point of the article. We can simplify the logic a lot by using boring tech, in this case, separating the query builder logic from the connection/transaction logic. Switching from one very complex ORM, to two more understandable simple systems, and getting back to more grass roots with querying.

Funny enough, I do actually find that interesting. Certainly not fixing your broken project, but, definitely designing package managers in general!

My issue had nothing to do with morals. If I cant use Apollo, then I wont use reddit. All of the other clients are awful, and I dont miss the content enough to justify using the official app, or finding other ways to circumvent the restrictions.

I think the key difference here is to consider toleration vs adoption. Old code is able to tolerate the changes and still work in new ecosystems. There is still work on maintainers if they want to actually adopt the features themselves. Allowing these two concepts to work together is what allows iteratively updating the world, rather than requiring big bang introduction of features.

As for validating your software, the answer is the same as its always been… tests, tests and more tests.

Wait, really? I had no idea you could do that. Might have to try that next time Im tempted to break out python or node for a bash script.

You can write the proxy/decorator to preserve typing info using a typevar.

    F = TypeVar(“F”, bound=Callable)
    def wrapper(f: F) -> F: …

The image in my head of you bashing the harddrive gave me a good laugh!