[TheChaplain]

IMHO there is little point of these conversion projects. It screams of "look at me, see what I made" and when the attention goes down a little nothing was ever pushed to the repo ever again.

Perhaps I am out of touch, but a project with author/s that have passion for every line, function and purpose, feels more real and worth my trust to spend time using it.

[bravetraveler]

I'd go even further: 'look at me, see what was paid for.'

This isn't much different than the 'builder brained' coworker who is obsessed with creating technical debt, not owning it. Throwing shit at the wall and seeing what sticks, passing it off as sage wisdom.

It'd be interesting to see the math behind offsetting the GPU crunching with more power efficient linting. Assuming every person or CI job switched (and the model stays offline), how many years are we looking at?

[NonHyloMorph]

Can someone with a deeper understanding of these sort of processes say something about the intricaies of building such a transformation process? Seems like constucting the architecture and feedback loops that guide the LLM to achieve a specific goal (byte wise bevhaviour replication) seems rather non trivial and as its on field of research? How common is it to achieve what the authors are publishing here as been having achieved? How elaborate are the achieved goals (i assume that what is specified here is rather precise and assume its true - in good faith for the sake of my question and as it is stated for the sake of being potentually reviewed/checked against)? How advanced are the metrics/behavioral constraints that guided the process? Whats the state of the art of this sort of ehm..reversereplication(?)archaeomorphic kyberneering(?), archaehylomorphic programming(?). Seems like an interesting approach and maybe thats also partially because I haven't seen such an approach - regarding the specificity and methology of defining the desired endresult.

[some speculative neologismification based on my (limited) understanding of ancient greek ethymology《to illustrate my aesthesis of that process. For the notion of hylomorphism see gilbert simondon ("machine") philosophy]

Adding: polite request to overlook potential orthographic deficiencies of text

[rpunkfu]

Essentially pay-to-win for coding.

[bravetraveler]

With moves like this, I'm not so sure victory is assured... but yes. Pay to play.

[dgellow]

In this case, it’s maybe more “I can access that luxurious model you all pleb are banned from using”

[bravetraveler]

Eh, I'm not that interested in participating in the marketing. I don't believe Fable/Mythos-lite/whatever is needed to translate. Or, as you call it, luxurious.

Fair point, though. Agreed in principle.

[esperent]

[delayed]

[the_duke]

Making something 50-2000x faster is pointless?

Besides that, Rust code is actually much easier to maintain , thanks to type system guarantees.

[xnickb]

I don't think you are. My first reaction was: "cool, now maintain it"

[baq]

"/loop maintain it" in a cron job

[tuna74]

Using less electricity or time for the same result seems a pretty good point.

[danpalmer]

Most software is not a single finished artifact though, it's a community, a process, knowledge, documentation, and mindshare. This has none of those, so by default it'll die as a project immediately.

To gain any of those is a much bigger problem: is the code structured well enough to get contributors over? Do the contributors know Rust? What about all the open bug reports? What about the edge cases that aren't triggered by the benchmarked projects, how do you even find them?

[baq]

...what's the point?

pylint keeps being developed, maintained as usual, etc. and the LLM conversion pipeline (little more than "rewrite the diff in rust, make no mistakes" in a loop) runs in the background. why do you care about it? do you care about maintainability of the output of your C compiler?

[odiroot]

The ~~beatings~~ rewriting to Rust will continue until morale improves.

[baq]

> 100x faster for byte-for-byte identical output

> little point

...yeah.

[whereistejas]

While I agree with your point in general, rewriting a big widely used project in a stricter language is always a good thing. It improves the dev-ex of people contributing to these projects and more importantly helps people seperate logic into silos. Python is inherently limited in which kinds of abstraction it can express.

[lelanthran]

In an open source tool, there is no value without community of contributors.

The value of the discussed project is exactly zero right now in the best-case scenario.

It's more likely to be negative: because there has been no contact with reality (no users have used it in production), the risk is higher than using the existing one.

IOW,

1. Only after some brave souls use this in production, will the value of this project rise to zero.

2. Only after a community (could even just be a single person) demonstrates commitment to this project will it have a non-zero positive value.

Since it was done primarily by someone who was never part of the original community, and they have yet to demonstrate a commitment to maintenance, there is no value to this project.

> While I agree with your point in general, rewriting a big widely used project in a stricter language is always a good thing.

Assuming everything else stays the same, sure. But everything else is not the same - there is no community, no commitment to maintenance, high risk and, worst of all, no human involvement. This project has negative value now due to the risk.

> It improves the dev-ex of people contributing to these projects

What contributors? There are none, and there are unlikely to be any for the majority of the new repos created like this.

Improving the devex of zero contributors improves exactly nothing.

> Python is inherently limited in which kinds of abstraction it can express.

Sure, but successful projects require committed humans. This has none.

[baq]

category error.

surely you aren't calling binary releases of binutils 'projects'? why would you call this thing a 'project' in the sense you're using?

[lelanthran]

> surely you aren't calling binary releases of binutils 'projects'? why would you call this thing a 'project' in the sense you're using?

Because you called it a good thing using my definition of project:

>>> It improves the dev-ex of people contributing to these projects

If this is supposed to be a "Product of the compilation process only", then sure, but if so, what devex of the contributors exist?

If you want to shift to regarding this as analogous to the binary releases of binutils, then the devex of contributors doesn't matter, because the contributors to binutils aren't binary-patching files.

[cornholio]

> rewriting a big widely used project in a stricter language is always a good thing

Always might be a too strong word. Rust is, by design, a language with low development velocity.

So you risk: 1. ossification of the current architecture and deferment of important features; or 2. reliance on AI coding to recover velocity.

Maybe for some 2 does not look like a risk, but I think it's too early to call. We have yet to see the effects of extensively using these tools on large scale projects, for years and decades.