jeeyoungk

First one is definitely AI-ese, but the rest, I cannot tell if they are just business platitudes or AI. Sigh.

If you want "3x3 colored image", you would need 6x6 of the bayer filter pixels.

Each RGB pixel would be 2x2 grid of

``` G R B G ```

So G appears twice as many as other colors (this is mostly the same for both the screen and sensor technology).

There are different ways to do the color filter layouts for screens and sensors (Fuji X-Trans have different layout, for example).

Some high profile news; yahoo altaba spinoff, Magic Leap (what are they up to now?), ...

yes that is easiest; or just be a 100% owned subsidiary. (that's what say, waymo is).

the good thing is that you afterwards the cap table of the subsidiary or the spunoff can evolve (ex: waymo / amp can raise money independent of the parent company).

As a user, you may not appreciate six, but popular libraries like Django would've never made the jump without six.py;

I think this is really unfair, in the current day and age, especially when there are "Open Weight Models" that are bending the definition of the FOSS.

I don't have a skin in the game, but I personally think that the definition of FOSS is too rigid and strict and is not evolving. There has been many challenges over time (LGPL's linking exception, tivoization, AGPL trying to fight against SaaS, Open Core business models, ...); and we are really bestowing very harsh moral standards for people who are trying to do the right thing.

For me, Sentry, being 10+ years in its existence (I used it ever since its logo was a Starcraft II unit), never participated in the usual enshitification of the software, being labeled as "NOPE" is disingenuous. I would gladly pay for Sentry because I love the software, and I also know that if shit hits the fan, I can self-host it (though the configuration for self-hosting got progressively difficult over time, but that's the complexity of modern SaaS stack). I can make similar arguments to other tools in this site that I'm familiar with.

why go for 9's when you can go for 8s? you can aim for 88.8888888!

I like `gevent` but I think it may have been too hacky of a solution to be incorporated to the main runtime.

"creating the first ever first-class language with green-threading at its core."

... isn't that what Go is? I think out of all languages I use extensively, Go is the only one that doesn't suffer from the sync/async function coloring nightmare.

This is the answer; turns out that non-transformed links are the most generic data format, without any "compression" - QR codes or a third-party-intermediary - needed.

Definitely agree that goroutines don't suck; it makes go into one of the only languages without "function coloring" problem; True N:M multithreading without a separate sync and async versions of the IO libraries (thus everything else).

I think channels have too many footguns (what should its size be? closing without causing panics when there are multiple writers), thus it's definitely better "abstracted out" at the framework level. Most channels that developers interact with is the `Context.Done()` channel with <-chan struct{}.

Also, I'm not sure whether the go authors originally intended that closing a channel would effectively have a multicast semantics (all readers are notified, no matter how many are); everything else have pub-sub semantics, and turns out that this multicast semantics is much more interesting.

But the term itself was created and captured by the left from the beginning; Proudhon first used it; Marx popularized it; so in the history of terminologies it always had the meaning that we associate with it.

I like the term "market economy" or "commercial society" more, because it does capture more of what's happening on the market and the society.

I think the parent's suggesting that they should be "one way" shortcuts; i.e. "# Heading" auto-formatting as a heading is a shortcut, and it doesn't allow you to go back and modify the original markdown.

ah TIL! I only read it when it was first proposed.

Yes; Ubuntu did this from the beginning; (6.06 is the first I've used, and I still remember _when_ I used it), Python's introducing CalVer too (aptly numbered PEP https://peps.python.org/pep-2026/)

Yes, they tried to avoid the cliche by pointing at the cliche, but they weren't able to refute Our Incredible Journey.

Though, this was a real product, with almost 10 years of operation; very few products last this long, and the product wasn't immediately shuttered after the acquisition, so it is unfair to categorize them into the same OIJ bucket.

yes `== null` is quite convenient for the null or undefined check.

In general, the whole `==` versus `===` is a silly argument in a typescript codebase, because if you know the types of the arguments, `==` behaves predictably.

Looks like a lot of them are pinning to tags (which are not guaranteed to change) or SHA (https://github.com/vitejs/vite/blob/8da04227d6f818a8ad9efc00...) which is more hermetic.

Who's the target audience for this pricing that can afford this? The RUM pricing is indeed quite ridiculous.

It feels quite ridiculous, especially if you are managing "soft" resources like IAM roles via Terraform / Pulumi. At least with real resources (say, RDS instances), one can argue that Terraform / Pulumi pricing is a small percentage of the cloud bill. But IAM roles are not charged for in cloud, and there are so many of them (especially if you use IaaC to create very elaborate scheme).

DuckDB would've been a good example to be included, because it tries to target the need for horizontal scalability with an efficient implementation altogether. If your use case stays below the need for horizontal scalability (which in the modern world, mixture of clever implementation and crazy powerful computers do allow), then you can tackle quite a large workload.

There's two parts to gRPC's performance

- 1. multiplexing protocol implemented on top of HTTP/2 - 2. serialization format via protobuf

For most companies, neither 1 or 2 is needed, but the side effect of 2 (of having structured schema) is good enough. This was the idea behind twrip - https://github.com/twitchtv/twirp - not sure whether this is still actively used / maintained, but it's protobuf as json over HTTP.

This is one of the best thing I read; I thought I was pretty good at Flexbox (and its tailwindcss building blocks), but this scratched my itch on some theoretical foundations.

3.126.0

This is from several years ago (2017), but this has very similar vibe as Instagram disabling Python GC - https://instagram-engineering.com/dismissing-python-garbage-...

Google smartly even refuses you from attempting to log in.

Looking at the traffic, isn't this literally MITM'ing all your traffic? This actually should be marked as [Flagged]; there's absolutely no reason why anyone should be using this.

The Go ecosystem (at least in the public) heavily encourages committing all generated code as go code is meant to be functional via a simple `go get`. Even a popular project like Kubernetes is full of generated protobufs committed in the codebase.

I also think CLAs are eerie and goes against the open source spirit, I don't think CLA alone puts a project in "high risk". I'm not sure about the FAANG open source projects that are used as libraries (Guava, React, ...). These projects fundamentally don't jeopardize these company's businesses, and serve to increase the developer goodwill amongst the engineers. Nobody can predict the future but I can't imagine these projects becoming relicensed.

More plausible scenario is them becoming an abandonware, but even in those cases the community can carry the torch.

This is great; how does this compare to Day One? I've been using Day One for multiple years (1000 day streak) and was wondering if I should stick with this. It does what I want but it seems like it's lacking in product development post acquisition compared to other offerings.

What is there to learn from an "storage industry expert" or major vendors? network attached block level storage at AWS's scale hasn't been done before.

+1

For example, BigQuery has natural support for arrays and nested data, and it's quite nice / essential for good data modeling. For example, "tags" can be stored as `Array<Struct<Key, Value>>`, and this can be used to implement things like, "search with fields with particular tags".

This reduces the cognitive burden of remembering which tables join with which, especially if we know that a relationship is solely relevant in one context. I.e. Tags can only be joined to the main table, and no other joins are sensical.