Don’t understand these rewrites.
- typically they are behind a single person. That’s usually bad because of spf
- typically they are achieved in a very short amount of time, so the author hasn’t acquired any discipline in creating the project. That means it’s unlikely the author is going to stick to the project in the mid and long term
- anyone that wants to contribute to the project needs to pay. Needs to pay tokens because it’s increasingly difficult to maintain these projects without AI
So, who wants to put something like this in production? Doesn’t make much sense
I'd be interested to hear the author's answer to your question, but I see it as an interesting proof-of-concept. It's testing the viability of not only rewriting PostgreSQL in Rust (and their choice of deps) but also in switching the threading model and other architectural changes. LLMs shine at pumping out prototypes insanely fast, and a working prototype can put an end to a lot of speculation.
I likely wouldn't use a rewrite of such a huge project if it doesn't have the backing of the original team (or a significant fraction thereof) and a believable story for having matched/exceeded the original code quality and maintenance. I also think in general using an LLM for license-laundering is legally and morally hard to defend, although this case is different in that they chose a more restrictive license. Not a lawyer, but my understanding is that you can just download PostgreSQL, do s/MIT/AGPL/ and release it, legally. (The original MIT-licensed version still exists, so no reason anyone would prefer yours until you make another release with some compelling new feature.)
This is very critical of an open source project that the maintainer didn't even post here?
"Status:
pgrust is not production-ready yet. It is not performance optimized yet."
The maintainer is not suggesting you use this for anything yourself. So why do you care about spf or (lol) his "discipline in creating the project"?
The gp feels like less of a targeted individual criticism & more of a general musing about a trend.
Nobody is saying this author hasn't demonstrated discipline & won't maintain this project, but the statistical averages across most projects fitting this trend make it likely enough to question their worth in aggregate.
The author is free to ignore any and all complaints they consider unfounded. It’s not even like the author is recieving any complaints personally; they have to come here to see any. And if they come here, they will get to read the viewpoint visible from here.
(Repost of <https://news.ycombinator.com/item?id=45253509>)
Because chances are that it's never going to be production ready, never trustworthy enough to be used by anything serious, and the project will eventually be archived and become at best a (extremely inefficient) learning experience for the author, or at worst a total waste of tokens. I could be completely wrong about this specific project, but most of these projects are like that, and statistics don't lie.
But this is also just silly. The maintainer here did nothing (just a little chat here and there), but is sure that only optimizations are missing for this to be production-ready. How so, based on what exactly?
100%
People on HN love complaining at any given moment.
I’d wager most of these people don’t really produce much and are constantly bikeshedding.
It's a very interesting phenomenon in recent years and most of the discussions about "why" are immediately blocked by the "memory safety" argument, as if it's a silver bullet for all things that are considered "bad" in software implementations. No matter how good the language is, and I consider Rust a very good language, it's practically impossible to replace years of experience and tested code, most of it contributed by a ton of brilliant programmers, no matter how you look at it. And if we take this as the truth, then logically there's still an unanswered question - why? Lets take an undeniable fact - rewriting an existing project give you full control over the new implementation. You can do whatever you want with it, you can't be sued. The only thing now you have to hope for is for your implementation to gather a good enough user base and from then on you can practically hijack the original project. And this is me speculating - rewriting stuff in Rust isn't about the greater good for that magical "memory safety" argument, but at the end it's an attempt to hijack popular software projects.
> it's an attempt to hijack popular software projects
Exactly. And this is why those projects are typically called "XXX in Rust" or "XXX-rs". Because the creators get to do their favorite thing - coding in their loved language - while skipping all the hardships of designing, accepting real feedback, involving users and getting traction - all while simultaneously hijacking the existing brand.
As of now I know of a single project that changed their name after being called and the project surprisingly got some traction.
I think we're a year or two away from the same argument being used by languages which enforce proof of correctness. The economics seem to be shifting in that direction.
Finding exploits is getting exponentially cheaper, and the cost of producing proofs is rapidly going down. For a lot of software correctness is rapidly becoming non-optional.
> impossible to replace years of experience
People with no experience don't have enough experience to realize what exactly they are missing here.
It's not just a rewrite ; it has improvements. I did the same thing for fun for the same reason; I wanted to see if I can improvements on some of the legacy design stuff and, especially, the stuff PG people have told us that it cannot be done differently. It can. I would not put it in production, but it thought me a lot about the internals of databases. To keep my brain happy in the age of LLMs, I implement database things on our (also old but many times refactored/rewritten) production db without an LLM. I'm sweating through Flexible Paxos now; probably we will just keep using raft as it's old and stable and simple but it's interesting anyway.
> I would not put it in production
Nobody else would either.
If this is meant for personal learning, do it that way and make it clear that others should not even consider using this project.
In fact, even for personal learning it's wasteful. You can learn so much about database without a rewrite like this.
It's useful to show the actual team that it's possible. From there, they can make the decision of whether to go the bun route with more information.
I'm not sure I see the value in "showing the team it's possible". I would presume the team are intelligent enough to be well aware that it's possible, given tradeoffs. And as it's clear those tradeoffs have been "traded" in this case, it doesn't seem like having the knowledge confirmed is particularly surprising.
This is true but these projects are rarely presented or interpreted as a proof of concept.
The bun route == spending 100k for an LLM rewrite as an advertisement for the LLM company you sold your soul to.
I'm really happy to see these rewrites. It shows what's possible, especially as the projects get more and more complex.
And maybe Remacs will get reactivated https://github.com/remacs/remacs/wiki/Progress
Maybe even I'll be able to do it when I wait for the bus!
> it’s increasingly difficult to maintain these projects without AI
It's pretty much impossible in a project of this size. IIRC Postgres has over 1M loc.
Are there modular databases with clearly differentiated components? I wouldn't be surprised if there aren't, as the trade-off with modularity is usually performance.
It’s open source. You take ownership of it for your deployment and stop relying on continued free work.
You can use llm to pull in updates as they are released. It’s not gpl, so you don’t need to publish your port
1. Nobody, not even the Googles or NSAs of the world do that. No single entity has the expertise nor resources necessary to maintain a fork for every open source project they use -- forking and maintaining Linux alone takes teams of people. And no, going full psychosis mode with LLMs is not going to save you.
2. This project is AGPLv3.
> going full psychosis mode with LLMs is not going to save you
People in AI psychosis don't know that.
Forking and maintaining Linux does not take teams of people. I've been at it for > 10 years and maintained support for my 15 or so various SBCs/mobile devices, writing drivers, debugging, cleaning things up. It's a weekend project every 3 months + whatever you want to put in for development.
And there are others doing it for projects like Armbian, openwrt, etc.
Except Amazon (Linux, Elastic, RDS..)
The companies I have worked for before all have used open source software like postgres, mysql, go, python, k8s, etc. 99% of the time we relied on free work; never contributed to these projects nor forked them for our own needs. I don’t think this behaviour is the unusual path tbh
You don't even need to publish your port if it's GPLv3 as long as you don't publish the binary.
I guess it is cool to have it around but it comes off as a popular useful case for AI which it really isn't, unless you have a very good test suite to throw the agent against, it is practically useless for rewrites of decades old badly documented code riddled with technical debt. That is where the real value and challenge would be. I see it as marketing and social clout stunt
> So, who wants to put something like this in production?
I don't think anyone suggested deploying this to production - the author is quite explicit that it's an experiment.
>typically they are achieved in a very short amount of time, so the author hasn’t acquired any discipline in creating the project. That means it’s unlikely the author is going to stick to the project in the mid and long term
Lindy effect! The longer something has been around, the longer it probably will be.
https://en.wikipedia.org/wiki/Lindy_effect
Not the same but it is much faster and easier to re-create a 3d model of an existing set of drawings than from scratch. This is because a lot of the decisions have already been made.
Everything has to start somewhere
How is that going for Claude's C compiler [0], or Cursor's web browser? [1]
[0] https://github.com/anthropics/claudes-c-compiler
[1] https://github.com/wilsonzlin/fastrender
Terribly, but just because any two people suck at basketball doesn't mean a third person must suck too.
malisper is the LeBron James of porting Postgres to Rust!
Maybe! Too early in the LLM rewrite era to tell whether this requires a LeBron or just someone who takes the local pickup game more seriously.
This seems to be functional software, though.
spf meaning...
single point of failure
not sun protection factor?!
Sender Policy Framework
SPoF :)
This year, not me.
In five? Everybody but me.
If you were a token burning company a project like this seems like a solution to this: https://xkcd.com/2347/
that hits your metrics without the problem that your contributions are not welcome.