undefined

points

[-]

You probably already know this, but I figure it bears repeating: most people should be running `cargo check` during development, not `cargo build`. The latter is only necessary when you actually need the built binary; the former is sufficient for type- and borrow-checking.

(On my local machine, `cargo check` is roughly 2x faster than `cargo build`. It's still slower than hot-reloaded Python, but it's rarely my development bottleneck.)

by est313 hours ago|

parent|

[-]

cargo check is useful to verify the code compiles (it's extremely rare to have compilation errors that survive cargo check). But cargo build is required if you want to actually try out the code you wrote, e.g. in order to run a test that you or the LLM wrote.

by J_Shelby_J3 hours ago|

parent|

[-]

Yeah but like, tests encode behavior… sometimes I go all day without running a test. Sometimes multiple days. I’ve been using unit tests less and debug asserts more and more now days anyways. Encoding behavior as close the relevant code as possible. And using types and type state to minimize invariants. Idk, but it seems like such a smell when my coding agent drops 10 unit tests for a 300 LoC module. It means it did a bad job of writing the code in the first place.

Anyways, if the code compiles, but the behavior is wrong, a test might be useful. But so is reading the code… so I’m skeptical of rerunning tests constantly.

by woodruffw3 hours ago|

parent|

prev|

[-]

Yeah, I mean more for the iteration half -- YMMV, but I find that I make the LLMs most productive when I have them design the typestates first, ensure they compile, and then work on tests after that (rather than stacking tests through the process).

by pjmlp5 hours ago|

parent|

prev|

[-]

A non starter for anything related to graphics or UI development, which is kind of most Rust stuff are CLIs or TUIs, like being back on curses heyday, Turbo Vision and Clipper.

by woodruffw5 hours ago|

parent|

[-]

Is it? An immense amount of the world’s graphical software is written for native graphical targets like SwiftUI, where the iteration cycle is similarly bound to build times. It’s certainly painful, but I don’t think it’s a non-starter.

by pjmlp3 hours ago|

parent|

[-]

SwiftUI has an incremental compiler with interactive workflows.

by woodruffw2 hours ago|

parent|

[-]

Rust has an incremental compiler. And TMU SwiftUI’s live preview is essentially a very rough approximation of what the actual build would produce; it’s not a suitable replacement for a real build when developing a non-trivial UI.

by pjmlp2 hours ago|

parent|

[-]

The experiences still fails short of XCode or Playground, hence why Slint has its own scripting language.

by woodruffw1 hours ago|

parent|

[-]

Sure, I don't disagree. It's just not clear to me that developers actually index that heavily on hot reloading to begin with.

by Klonoar5 hours ago|

parent|

prev|

[-]

Various Rust UI projects have been working towards hot-reloadable capabilities, based on the work from the Dioxus team.

IME it's just not really that big of a deal at this point. YMMV, etc.

by pjmlp3 hours ago|

parent|

[-]

I am aware, still far away from what something like C++ Builder was already offering in the 1990's, let alone other more modern alternatives.

by slopinthebag3 hours ago|

parent|

prev|

[-]

My rust compiles in the time it takes to switch from my editor to my browser to see the changes incremental recompiles are fast enough imo. Dioxus has hot reloading if you want to go faster and Bevy uses it for hot reloading as well.

by pjmlp3 hours ago|

parent|

[-]

With a beefy desktop, or some Apple wonder CPU, right?

by embedding-shape2 hours ago|

prev|

[-]

> I dont really like Python but the ability to make some changes then run it instantly is wild for me.

You'll love Clojure, gets you even closer; you can make changes while your program is running, by changing source code then applying just that function you changed, while your editor is connected to your program and can show what the new results are.

by 77341281 hours ago|

parent|

[-]

I'm quite often working in a Jupyter notebook where the imported modules are reloaded. I can have x in memory, change method y of X and then call x.y() and get the new definition.

It feels almost criminal that it works, but it's quite nice.

by Aurornis5 hours ago|

prev|

[-]

Initial compilation and incremental compilation are very different.

Large Rust projects are broken up into modules. If you change one module you don’t have recompile the whole project.

Remember we’re talking about compensation time versus LLM turns in this thread. Even a 10 second incremental compile is orders of magnitude faster than an LLM turn.

by majormajor4 hours ago|

parent|

[-]

> Remember we’re talking about compensation time versus LLM turns in this thread. Even a 10 second incremental compile is orders of magnitude faster than an LLM turn.

This entirely depends on (a) what a step/prompt/turn is trying to do and (b) tooling and rate limiting and various other aspects of your model and/or access to it.

If you have high rate limits and aren't using an Opus-or-larger sized model you can get a LOT of changes done in 10 seconds.

And this is especially true for "oh not all the tests are passing yet, let me change..." iterations where the change attempts are often low-single-digit seconds.