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

help-circle










  • Germany has 80 million people, China 1.400 millions. The per-capita consumption of Germany is still much higher. Chinas energy production is rapidly growing, and the share of renewable energy in it is growing as well.

    Moreover, Germany is the largest economy in the world’s largest democratic economic bloc, since the US objectively ceased to be democratic. So, Germany and the EU have the duty to show that they can do better. “We had democratic governments but they had to serve the short-term interest of capitalist megscorporations” will not sound like a good excuse to our grandchilds when they have to live on a devastated earth.







  • Just to get that straight: Legacy code is practically always large code with countless hidden requirements, and with insufficient or no tests and without documentation. But which works somehow. Any change needs to meet numerous unwritten requirements, and it can often only be tested in the real world. If you have N features, you have N*(N-1)/2 interactions between two features, so it is quadratic growth with N. This is why it is very hard and time-consuming to change.

    It shouldn’t be that way, but writing large software - especially in commercial environments - is often like climbing a high roof on a ladder, and then throwing away that ladder. Modifications are only incremental, and usually not documented. Incremental modifications are one of the only two working engineering approaches for software we know - and the only one used for commercial software.

    The other way - which is used in aviation for example - is to specify, document, and test everything, right from the start.

    Now the problem is you can rewrite legacy stuff as much as you like, but it is near impossible to make sure that large changes work. Because in order to do that, you would need to run the tests that do not exist, or create tests from specifications and requirements which do not exist either.

    And GenAI tools are not going to change that. The agentic tools kinda work by filling in missing requirements with assumptions and average observed stuff. It can generate reams of code, fast. But while this kinda works for a small phone app, it doesn’t for large complex stuff. If the code does not fit in the head of one person working for months on it, it will never fit in the context window of an LLM.







  • He is right in many aspects. However, for example Guile, Racket or SBCL Lisp are a lot faster than Python, and they are more powerful than Python while being much simpler, which makes them very interesting for prototyping algorithms.

    The ideal combo for such things would be a powerful interactive language with debugging capabilities combined with Rust, perhaps even a language similar to Rust. I do not know of any easy solution for that, but it could be made work with Rust’s macro system (since the above languages all provide C ABI FFI).

    Also,most of design happens when a program is written first. It is hard to re-design a larger program later, which might be one reason to re-write it. So maybe the main reason for rewriting is to get a better design, not the faster language - the faster language might be an additional reason.

    Also, LLMs can produce terribly bloated Rust code - not only by a factor ten larger, but also much slower.

    Also, CRUD apps are uninteresting to many programming enthusiasts, and for companies, optimizing them is only interesting if it saves them money.