MapleWalnut

Interesting that they did a major layoff on a US holiday (MLK Day).

Spanner provides serializability. It seems like DSQL only guarantees "repeatable read".

https://docs.aws.amazon.com/aurora-dsql/latest/userguide/wor...

Sentry provides a great hosted service. You can self host if you like, but it’s nicer to let them do it

The Sentry SDK is open source and easy to contribute to in my experience.

It'll be hard to position this against Sentry. Sentry's a joy to use and their performance product is so helpful in debugging performance issues

That’s true, but with ESPPs, you get a discount on the stock price, effectively guaranteeing a decent return that would be hard to beat.

Yes, but that wasn't available when they did this migration

I like that polar supports funding specific issues or pull requests. Seems like a nice way to help fund a project while also helping prioritize issues you care about.

There is a lounge with seating, you just need a ticket

It'd be great if there was an rss feed for your blog

Not the most accurate title. They’re still using Typescript for type checking, they’re just using JSDoc type annotations instead of Typescript syntax

Mypy is the most correct and flexible type checker I’ve found. Pyright is great for auto complete in VSCode though, so I use both.

The Google and Facebook options aren’t well supported.

I pay for Feedly even though I had access to a very generous free plan. Their product is reliable and I use it every day, so it only seems fair to pay.

With the new GitHub code search, the first result is the DeleteView class: https://github.com/django/django/blob/bd366ca2aeffa869b7dbc0...

One of the engineering leaders at my company was big on Retool and it was pushed out as a way for backend developers to write frontend code.

Now 6 months later that leader is gone, developers realized applications in Retool are harder to maintain because it’s just spaghetti code with no type safety or proper code review and teams are moving back to internal React applications.

You could build a much nicer user experience with react and make a maintainable codebase.

I think the promise of no-code making it easier for users to contribute is not reality.

WAL is reliable, but Publish/Notify isn't. You'll lose messages with Publish/Notify if you aren't listening for them.

Your Python example has unnecessary type annotations. Python type checkers like mypy and Pylance can infer the type of `words` automatically.

    def main() -> None:
        words = ["Hello", "World"]
        for word in words:
            print(word)

    if __name__ == '__main__':
        main()

TIL that ContextVars can work in place of thread locals too. Thanks for pointing that out!

I had mistakenly assumed ContextVars only worked for async code.

Yeah, precommit isn’t my favorite thing out of personal preference. So it’s a shame prettier doesn’t have built in caching like other tools in the space.

Prettier itself would feel much faster if it supported caching like other code formatters (Python's Black, Rust's rust-fmt)

Dropbox support can rollback your Dropbox account to a previous point in time too.

What about https://github.com/Roblox/luau? It gives Typescript-like annotations.

I'm encountering issues with the GitHub API too.

I wish there was something this good for Golang.

PlanetScale branching only copies the schema, not the data.

from their docs:

> Note: Data from the main database is not copied to development branches.

https://docs.planetscale.com/concepts/branching

They're pretty similar. The auto complete alone is worth adding type annotations.

Both have type stubs for third party packages that can make it easier to get coverage for your project.

My organization gradually migrated a ~300k line Python project to have full type annotations and it's so much nicer to work on.

Mypy provides a server to help with this called dmypy: https://mypy.readthedocs.io/en/stable/mypy_daemon.html

From what I understand, they only branch the schema. They don't copy the data.

Scoring results in Postgres requires scanning all matches, which is slow if you have a lot of results.

Elastic search and other search solutions don’t have this problem.

I ran into this issue when setting up UI previews for a GitHub OAuth app.

My solution is to have a single callback server that looks in the OAuth state to determine where to redirect. This isn't secure, so when building the UI, I sign the UI's preview URL with a secret and send that in the OAuth state. The callback server checks the signature and redirects that way.

It's hacky and I wouldn't trust it for a production app, but for a test environment it seems okay.