emptysea

In Postgres you can define custom operators via `create operator`[0]

    -- infix
    select a <!!!> b;

    -- prefix
    select <||> a;

    select @-@ '[(0,0),(1,0),(1,1)]'::path;
    -- 2

Not OP, but I think building feature flags yourself really isn’t hard and worth doing. It’s such an important component that I wouldn’t want to depend on a third party

Ruff’s ast is used by Ruff, Ty, and Pyrefly

Pretty sure you can get EU data residency with sentry

https://docs.sentry.io/organization/data-storage-location/

Instagram built a linter with the ability to fix errors which is an improvement over flake8 & pylint: https://github.com/Instagram/Fixit

But Ruff is an even greater improvement over that

That's one of the features of EdgeQL:

    select Movie {
      id,
      title,
      actors: {
        name
      }
    };

Although I think good enough language server / IDE could automatically insert the join when you typed `credit.CLIENT->NAME`

Also interesting, pyrefly uses Ruff’s parser!

https://github.com/facebook/pyrefly/blob/a8626110da034f8e513...

Might be worth checking out https://github.com/DetachHead/basedpyright

But I’ve had the same issue with too many warnings, mypy is better at understanding Python but even slower.

A rewrite of https://github.com/facebook/pyre-check in rust?

The web version is actually pretty decent, I use it on windows from time to time and it works great!

It also has some features that the MacOS one doesn't have like, a full screen lyrics view with some nice WebGL animations.

Ah yeah I remember that one, but can’t remember the origin.

A lot of times the reason sentry can’t do much is because the browser JS VMs have terrible/non-existent stack traces, especially true with things like unhandled rejected promises.

At work we have a lot of sentry errors related to browser extensions doing weird stuff.

Chrome’s Google translate is also notorious for breaking react based sites.

It ends up being a tedious triage process to ignore each new extension issue. We use the client side filtering to reduce our ingest volume. In general we have to have a lot higher thresholds to handle the noise vs our backends.

Rust-analyzer uses a similar technique for parsing https://github.com/rust-lang/rust-analyzer/blob/master/crate... which then gets fed into https://github.com/rust-analyzer/rowan (lossless syntax tree)

Have you tried a Waymo yet? Honestly the coolest tech I’ve seen/used in ages

Lots of engineering involved

Do you know why they use JSC rather than the V8?

YouTube uses Spanner now, they migrated off Vitess a while ago

Seems they’ve built out a PG version of MySQL’s Vitess

Query rewriting seems interesting, having a layer between your DB and your application would also allow various ACL stuff as well

We have the same problem with bazel at work, after a few months your machine is running out of disk space

If you think Figjam is expensive, you should see their new dev mode pricing — I’m sure they’re making a mint!

Did you manage to get IDE support to click into the backend implementation from the front end code?

Yeah it looks off, makes the website look rushed imho

Or looking to play the promo game, build a bunch of unnecessary stuff and get a pat on the back and better comp

The problem with Django simple history and similar is they use Django signals and aren’t transactional. So if you have any bulk updates or things that don’t trigger signals, your SOL, and your history starts missing things

A more robust solution would use triggers or an ORM with more transactional guarantees (aka not using signals)

UI wise it looks like they’ve cribbed some design notes from Apple’s calendar apps

Curious how you're using SQLite at Notion, do you have anything public?

Do you have a link to the DSL? Curious to learn more

To me it seems more like the typescript-ification of CSS which is a good thing if you’re into static types!

Called an efoil, they also have non electric versions that are much cheaper

I’m not really familiar with the trade offs of modes with Postgres but why isn’t Serializable necessary?

The passing stuff down when it isn't needed also comes up with JSX / React. The basic options for solving it are either:

- pass it down manual - use Context, essentially thread local variables but React

both have tradeoffs and it really depends on what you're building your codebase.