Hacker News Reader

Comment by brianwawok | Hacker News Reader

So Claude can convert python code bases to rust or golang, and give you an easy 10x speed boost. Much better than waiting for Python performance to improve

View on HN

There is a benefit in being able to read and understand your code. If you’re most proficient in Python, it’s reasonable to want to stay there, perhaps looking to PyPy.

Also, of course, the majority of SaaS apps (perhaps most apps in general?) are not compute-bound, so gains from performance alone shouldn’t be the only metric.

My current job has a mix of Python and Go. Personally, I dislike Go. I don’t like its syntax, I don’t like its utter lack of formatting standards (gofmt is not a standard; also it sets tabs - ugh), I don’t like its insistence on static linking, and I don’t like how people claim it’s a great scripting language when you can’t just run a file on its own (and its stdlib is weak sauce compared to Python).

Of course, Claude understands Rust, too.

I can read rust much easier than go at least. If the Python doesn't have types then it's about even as well.

Rust is nice to read because you can see from a function signature what it mutates

If you write slow rust, it's very easy to read, and still plenty fast.

For a server using a DB, all of your methods are calling out to data stores. So you're like "OK I receive a &connection" but all the mutability is hidden inside.

There's a bunch of type direction you can do to get around this (`ReadConnection` vs `ReadWriteConnection` and some other magic), far from an immediate win but it's not impossible.

People talk about mutability a lot but the vast majority of Python code I see in the wild is SSA and has _very_ little mutability to begin with.

Of course ownership still has its costs. Lots of "I guess I'm copying this dict because I don't know if the owner will modify it or not" issues.

I think people overestimate how much they'll get from `&mut` annotations on business logic, and undersestimate how much line noise they'd get from a lot of the other stuff that happens in a lot of business logic.

Granted, I'm coming from a web-dev/Django perspective, where duck typing and overriding methods in subclasses is used heavily. And a lot of that doesn't have a nice 1:1 equivalent in the Rust model.

(I enjoy Rust BTW, just don't feel particular excitement about shuffling around strings in it)

not everyone is writing simple web servers :) and if you are, then the rust is easy to read as it's simple. I also use django in some large projects, and don't see a future of my use of django really anymore. If I'm not feeling like rust is a great fit, I usually reach for Java with javalin.

For a lot of scripts (think replacement to bash scripts - perhaps even one-offs), Python will save time over rust compilation times.

Golang it is then! I'm really enjoying the fast compile time compared to C++...

And packaging + distribution is ridiculously easy.

We are moving every script we can to Go. Compared to bash it's a no-brainer, every dev can understand it, it has approximately .0000000000001% of the possible footguns, a great debugger, etc.

Non-optimized builds can be pretty quick, although I guess you're always paying for borrow checking.

Being a local property, borrow checking is cheap. IIRC even Polonius is single digit percent in the worst case on crater runs.

For one offs, sure. But once you get to a script executed multiple times it doesn't take very long before you have payed off the rust compile time. Especially if it is fairly simple (as in, you can do everything with just rust std lib and not a bunch of rust libs).

Almost all the rust compilation times come from needing to build the supporting libs. For simple scripts, it's very possible to get away with just using the std lib.

At the same time, If a python script can be thrown together in 20 minutes, and it will execute hundreds of times at most..... Who really cares if it takes 25 seconds to execute, or 2 minutes as long as it accomplishes all it is intended to do?

In my opinion, what is pretty typical a script will be executed never, once, or thousands of times.

If you are at the point of doing multiple executions, you are probably at the point where converting your script to rust would end up saving time/power. Maybe not all the time (like a manually executed script), but not infrequently.

At the scale of “bash scripts”, rust will compile instantly unless you’ve gone insane with dependencies

There are D, Go, C#, OCaml as an option, not only Rust.

Yeah, none of these tight loop benchmark tasks should be happening in python, which is why you won't see anywhere NEAR this kind of speedup with "normal" python code, that makes any attempt to use the many c python libraries that exists for these (like the built in sort functions, ffs).

Over the years, I've tried pypy and whatnot, but I've only ever seen between -30% and 30% speedups, depending on the code.

Why not convert to assembly?

Portability

Assembly doesn't add anything here. You'd still need to implement the IO, portability, safety, etc etc. You'd end up with the same thing so you might as well use Go from the get go. Assembly is useful for dedicated SIMD like in dav1d.

You mean compiling?

Can’t wait for this to eliminate Python frankly. Too many scars from that unfortunate ecosystem

Good luck. AI is built on Python, and it's just getting started.

Reply on news.ycombinator.com