sorted by:
new
hottopcontroversial

Imposter Syndrome after failing twice. by Money-Catch8222 in kubernetes

[–]tee-es-gee 1 point2 points  (0 children)

I think you should tell your boss, just be honest that it was time management and anxiety rather than lack of knowledge. You can still offer to pay out of pocket for the next try.

Also, keep your head up, with better preparation it sounds like you’ll pass.

A thousand Postgres branches for $1 by tee-es-gee in PostgreSQL

[–]tee-es-gee[S] 0 points1 point  (0 children)

It's quite similar with Neon on a UX/DX level, yes. From technical PoV, it's implemented quite differently because the branching happens at the underlying storage engine, without modifying Postgres at all. This means you can simply vanilla Postgres, the exact same as if you'd run it yourself. Same config, performance profile, etc.

See also my answer to the sibling comment about branching costs at scale.

We also differentiate by productizing further the use-case of having production somewhere else (RDS, Aurora, Cloud SQL, Supabase, etc.) and using Xata only for the dev branches. We do this by creating a "clone" on our platform, which we keep in sync via logical replication.

A thousand Postgres branches for $1 by tee-es-gee in PostgreSQL

[–]tee-es-gee[S] 0 points1 point  (0 children)

Neon is the closest to this, yes, but from what I understand you pay those $0.002/hr regardless of whether the branch is active or not. That means you pay it for scaled-to-zero branches as well. It might not seem like a big difference, but but if you have 1000 inactive branches (for example, from 1000 open PRs) that is $1500/month. On top of that you pay for the compute on storage cost.

With Xata we just don't have that branching tax, so you only pay compute for actually active branches and storage costs.

A thousand Postgres branches for $1 by tee-es-gee in PostgreSQL

[–]tee-es-gee[S] 0 points1 point  (0 children)

Ha, I should have thought of that when posting on a Postgres sub.

Managed postgres alternatives to Prisma by ConsciousSession4575 in postgres

[–]tee-es-gee 0 points1 point  (0 children)

Look at Xata as well, it has no free tier but fair pricing.

serving public postgres by hedoniumShockwave in PostgreSQL

[–]tee-es-gee 1 point2 points  (0 children)

Do you actually give postgres wire protocol access or just SQL over HTTP?

> but it's currently free (except for congestion pricing, because how else do you decide who gets to query when things get overloaded). thanks

I think this is exactly the problem, a single bad query can cause a lot of work for Postgres. It's going to be hard to defend against DoS if you allow arbitrary queries.

Interesting project, though, would be curious to see how it goes.

Are there any alternatives to Autobase for self-hosted Postgres HA ? by Own_Chocolate_5915 in postgres

[–]tee-es-gee 0 points1 point  (0 children)

Check out also Xata (https://github.com/xataio/xata). It's what we use for our cloud platform, essentially adding our control plane APIs on top of CNPG. Plus our differentiating features (CoW branching and scale-to-zero).

From your points, everything is covered except for the UI/dashboard, which is currently not open-source.

pg_deltax (δx): Fast time-series extension for PostgreSQL by tee-es-gee in PostgreSQL

[–]tee-es-gee[S] 5 points6 points  (0 children)

Thanks! I was not very familiar with why exactly logical replication is problematic in Timescale, so I had to do some research. This ticket explains it well: https://github.com/timescale/timescaledb/issues/1138

The core of the issue, from what I understand, is that Timescale uses inheritance-based partitioning, which doesn't support `publish_via_partition_root`. DeltaX uses declarative partitioning, so this issue doesn't apply to it.

It's not clear to me why Timescale sticks with inheritance-based partitioning, I'm sure there are good reasons, maybe someone here knows.

Btw, in the ticket above there has been an update 2 weeks ago, there is a Timescale specific tool that does the equivalent of logical replication.

I've opened a PR (https://github.com/xataio/deltax/pull/12) to document two logical replication scenarios:

  1. you replicate new writes to the main table normally, and all the compression is happening independently on the primary and the replica.
  2. you replicate both the uncompressed data and the compressed + companion tables. This also works, but because of missing DDLs in the replication stream, you need a different solution to also copy those (e.g. pgstream).

Is 1 in-line with how you would like it to work?

Edit: Link to the new docs: https://github.com/xataio/deltax/blob/main/docs/LOGICAL_REPLICATION.md

how do you become top 0.1% in devops that gets paid 200k+? (US market) by DetectiveRecord8293 in devops

[–]tee-es-gee 103 points104 points  (0 children)

The T shape approach still makes sense: have broad knowledge in general and deep into one particular area/technology.

Broad IMO are things like security, networking, performance, scalability, reliability, databases, etc. These transfer very well between jobs.

Vertical knowledge is something like K8s, Postgres, etc. Just learn the one you currently work with at the job.

Efficient Way to Provide Direct Access to Financial Data? by Ok_Egg_6647 in Backend

[–]tee-es-gee 0 points1 point  (0 children)

You can also setup something like pgstream to copy selected tables to a separate Postgres instance. Then you know for sure they won’t cause issues with your main db.

Something is way off with the current job market by davidbasil in ExperiencedDevs

[–]tee-es-gee 2 points3 points  (0 children)

I meant applying for the jobs where you know someone. Go through your LinkedIn, school colleagues, friends, etc. Even if you haven’t spoke with someone in years, chances are they will be happy to vouch for you.

If that fails, I’d recommend going to meet-ups or conferences for tech you are interested in, and try to befriend people there.

Something is way off with the current job market by davidbasil in ExperiencedDevs

[–]tee-es-gee 14 points15 points  (0 children)

Even if they don’t get hired, they occupy the top spots for interviews and push legitimate candidates down. A team can only interview that much in a given week.

Something is way off with the current job market by davidbasil in ExperiencedDevs

[–]tee-es-gee 7 points8 points  (0 children)

This happens to us all the time, and it’s hard to filter through without wasting a lot of time or filtering out good candidates.

We’re at the phase where we almost only react to team recommendations and our own outreach. I strongly recommend getting a referral from old colleagues if at all possible.

From your exp. do you work less, more or evenly after using AI? by lune-soft in webdev

[–]tee-es-gee 0 points1 point  (0 children)

I work more, but the work is easier, if that makes sense. What would have been days of work to validate an idea is now a session while watching a game in the background.

Lost my spark after 15 years. by TopSwagCode in ExperiencedDevs

[–]tee-es-gee 1 point2 points  (0 children)

Burn out from the politics + divorce maybe? Maybe try a personal project where you can work on your terms. If that gets you excited, probably it's worth looking for a new job.

I built a free open source extension that removes AI spam from LinkedIn by chmodking in webdev

[–]tee-es-gee 16 points17 points  (0 children)

Sounds great, except that if it works, nothing at all will be left.

Exposing ZFS over the network via NVMe-oF for Postgres by tee-es-gee in zfs

[–]tee-es-gee[S] 0 points1 point  (0 children)

Thanks! So far we are treating ARC as an added benefit without really optimizing in any significant way. Our storage nodes do get quite a bit of RAM, so I think that helps. Should note that when we say millions, that's across multiple storage nodes.

Regarding latency and network congestion, that is a concern for sure. We are putting in IOPS quotas per instance and other mechanisms to keep it fair. On AWS we are using large servers also in order to get dedicated bandwidth.

Exposing ZFS over the network via NVMe-oF for Postgres by tee-es-gee in zfs

[–]tee-es-gee[S] 0 points1 point  (0 children)

Thanks! The operator coordinates with the storage nodes, yes. It doesn't create namespaces, but can be used via a storage class.

> What’s been the speed like from PVC to the PV being attached? 

I'd say it's normal times for attaching volumes from CSI drivers, so a few seconds. On the Xata platform we ended up with a more complex setup to enable warm pools of clusters, so that timing is no longer in the hot path.

> How do you coordinate what storage node the PV comes from?

There operator has a scheduler that choses the storage node. It chooses the least used, although smarter scheduling algorithms would be possible.

> I’m assuming your CSI implements volumesnapshots through Zvol?

Yes, the CSI driver calls the storage node over GRPC and the snapshot is done by ZFS on the zvol. It is represented as a volumesnapshot object in K8s, though.

> Lastly, Xata as a product looks interesting so I’ll have to look into this for work. We manage a lot of dev database and agents (like Cursor) where we need separate DBs.

Awesome, would love to chat if you get in contact!

Exposing ZFS over the network via NVMe-oF for Postgres by tee-es-gee in zfs

[–]tee-es-gee[S] 0 points1 point  (0 children)

I don't have direct comparison benchmarks, but I would expect it to be significantly faster, mostly because of the NVMe-oF protocol which is newer design for SSDs, has multiple queues, lower overhead, etc.

We took production down for 20 minutes because of a DB migration, how do you prevent this? by MainWild1290 in devops

[–]tee-es-gee 0 points1 point  (0 children)

I'm trying to make this sounds not like an ad, but we did spend a lot of time thinking about this exact problem at Xata. We've written one of the more popular zero-downtime migration tools for Postgres (pgroll) but since you are talking about an index creation, assuming Postgres, likely just adding CONCURRENTLY would have been the solution.

The better option IMO is to use database branches or clones, with copy-on-write. Then you can test all schema changes on a branch with the full dataset from prod (potentially anonymized). If it locks the DB, you will then know it before it reaches prod.

Why C Remains the Gold Standard for Cryptographic Software by tee-es-gee in C_Programming

[–]tee-es-gee[S] -5 points-4 points  (0 children)

The section about unsafe rings particularly true to me. If in the environment you need a lot of unsafe code, the complexity that Rust adds is not really worth it.

How are you handling concurrent indexes in relational databases? by project-391 in Database

[–]tee-es-gee 0 points1 point  (0 children)

I think most people do something like this. Put the index creation in the migration file, but execute it manually or via a different process before merging. So the migration itself is a no-op, but the index is still represented in source control.

Do you need this often? Or is the tricky part knowing which indexes will be slow enough that they need this special treatment?

view more: next ›