• 35 Posts
  • 61 Comments
Joined 2 years ago
cake
Cake day: April 4th, 2025

help-circle



  • I have tried that with a small side project - a simple TUI app and parser in Rust - and I wasn’t convinced it is really faster. It spat out some 4,000 lines in about four afternoons, a bit of ratatui and so on. The cursor wasn’t visible. The fix was completely hallucinated, or BS, and suggested downloading and patching another lib. The parser was incorrect. It had over one hundred dependencies. I could fix it with two or three more afternoons time. Now, 4000 lines in a few days still sounds impressive, doesn’t it?

    But then, I wanted to know it, threw the generated code away, and wrote it again from scratch. I got there with half the code and had it working. In the same time. With a working cursor and a better parser.

    I think the speed perception is like when you are using public transport or a commuter train vs a bicycle. The motorized vehicle always feels faster. But at distances like ten miles / 15 kilometers, it isn’t. A car still feels much faster, but often it isn’t worth the cost.

    These things save – seem to save – effort, which our primate brain is wired to. But laziness is a bitch. Lke cars, which when used a lot instead moving our body, only make our life shorter.



  • One of the developers in the exercise wrote code that was obviously incorrect to pass one of the rounds, but all of the tests passed. After that code was written, everyone basically became stumped as to how to proceed, and we largely ended up talking about how the “coach” needed to “catch his flight” soon and he exited the exercise early.

    Seems to match what John Ousterhout wrote, in “A Philosophy of Software Design”, and what he called “debugging a system into existence”.

    Tests and testing cannot prove a program is correct. What they can is find bugs in edge cases and usually taken paths, and they are surprisingly efficient at this. The downside is that systems which rely too much on them can have gazillions of bugs when the execution goes astray from the happy path, for example if some memory allocations fail.






  • In the enterprise space, we largely avoid NPM or Composer, et al, because those very best-practice docs (iso27002, here, later SLSA) prohibit repos that obscure or frustrate validation and code pedigree; and the gleeful incestuous inclusion of projects within projects means source code isn’t properly managed - a failure - so npm won’t do.

    Rust (that is, cargo and crates.io) does in principle the same, and Java (via Maven) as well. Their quality is arguably better, but a lot of modern software has hundreds of dependencies.

    I am wondering whether the SBOM philosophy is merely a box-ticking exercise. It does not buy you much when you know you have a buggy 15 years old TCP stack in your industrial control, but you can’t upgrade it because there is no storage left on your device. And the same holds for Cisco routers. Constantly upgrading works,in my experience, only with completely open systems like Linux, on open hardware.









  • Oh, Lisp is perfectly readable, it is merely a matter of getting used to the syntax. I have used at work at least ten different languages in thirty years, and Lisp is definitely not particularly difficult, Scheme is even easier. And what makes it easy to parse is that the syntax is small and regular. Which you can’t exactly say from C++. Even the second most complicated modern language, for which I would nominate Scala, is an order of magnitude simpler. Rust for example is more complex than Common Lisp but far, far simpler than C++.

    And is respect to Python… it suffers from the same syndrome of creeping featuritis and design-by-commitee, Python picks up more and more features which very few people really use, its just not nearly as severe as C++.







  • Even if we include LLMs porting code, the sheer amount of c++ code makes it not worth porting, and some legacy code just need occasional updates, especially embedded.

    It is more effective not to port old working code, which would cost a lot of resources, but to write new code in Rust, where this is possible. There have been a few studies on this, even from companies like Google. The thing is that new code is more likely to have bugs than working old code. So, spending effort on new code gives more safety for a given amount of effort and resources.

    On the other hand, it absolutely makes sense to write completely new projects in Rust, if the needed library support is there, since Rust tends to be more productive.

    Also, in embedded systems, space systems, systems with certification requirements and so on, Rust is making inroads. Though these are rather conservative areas where tools are not changed quickly.