650 karma · joined April 29, 2022
It's not difficult to arrive at the caricature of baroque generic code if you combine lack of knowledge with miscommunication. The knowledgeable coworker should be aware that a writable object implements the Write trait, and know, or find out, the signature of the Write::write() method. Even fully generic, a function accepting a connection and returning the result of writing a block of data is not too gnarly:
use std::io::{self, Write};
fn write_data<W: Write, D: AsRef<[u8]>>(connection: &mut W, data: D) -> io::Result<usize> {
connection.write(data.as_ref())
}
No unwraps, no clones. Because they're not necessary here. But someone has to know the language and the idioms. Even your "easy" C++ code depends on knowing that write() returns zero on success, and that integers can play the role of booleans in conditions.*[1] https://rust-lang.github.io/rfcs/2789-sparse-index.html
[2] https://blog.rust-lang.org/2022/06/22/sparse-registry-testin...
[3] https://blog.rust-lang.org/inside-rust/2023/01/30/cargo-spar...
(The X8 capsule from [1] is a dead ringer for the one described.)
[1] https://www.qsa-global.com/industrial-cs-137-gamma-sources
Sounds complicated, but in practice you don't think about it at all.
(What's strange about A Declaration... is that it came a decade after Neuromancer and two years after Eternal September. You may choose to doubt the predictive power of dystopian fiction, but the reality check of the influx of participants outside of the pretty exclusive early-internet club should be much harder to overlook. That document managed to disregard both. It was strangely anachronistic even at the moment.)
The implication is that their instructions were much more detailed than "fire X% of people" and included using LoC as the metric, which nobody questioned.
(Any quantitative measurement of code quality will have too many outliers to be fair. LoC? Of course not. Number of closed PRs? You can't say much without knowing their complexity or severity. Etc. But they had to be quick, not fair.)
One of the things making this possible is 90+ percent enrichment of U235 in the fuel. That's weapons grade and won't fly in a civilian reactor. I haven't read NuScale's application in great detail but I'd be surprised if they used anything above 5 percent.
[1] https://lists.openldap.org/hyperkitty/list/openldap-technica...
Then you probably haven't been around physicists, or read enough physics-related material. A non-scholarly reference which can't be easily checked online is George Dyson's "Project Orion," where Freeman Dyson (author's father) is quoted as mentioning this or that "code" as significant for the design of various Orion parts. (That should be a native enough English speaker.) The time-frame is late 1950s to early 1960s.
It could also take as long as the async MVP itself to get off the ground, and you can't know if it wouldn't hit its own snags when deployed at scale. (From long ago, I remember the "non-parametric dropck" RFC as an illustration of a neat concept colliding with reality.)
Languages with mainstream aspirations evolve under greater pressure. I don't know this, but I strongly suspect that async was necessary for Rust to gain acceptance at, say, Amazon. So it couldn't practically have been designed with a wide-open timeframe. The result is what we have; one can uncharitably call it "half-baked" and tut-tut about the sharp edges, but it's workable if you know what to avoid. (But it's so tempting to imagine what could have been, eh?)
Why not? "A code" is a software package which solves some kind of problem computationally. Plural, codes. I'm sure it's been in use almost as long as the programmable computers. Here's[1] a link to an article from 1968 which uses the term in the singular ("The MENE Neutron Transport Code".)
[1] https://www.osti.gov/biblio/4819611-mene-neutron-transport-c...
The OS is used by a limited and probably dwindling number of vendors of specialized, complex and long-lived software originally developed for VAX/VMS. I was tangentially related to users of such software for a while; the vendor made the VAX->Alpha and Alpha->Itanium transitions, but saw the writing on the wall and ported the software away from VMS. VSI is not a large outfit, and they're a business. They don't need the hassle of dealing with hobbyists.
It is genuinely great stuff, and with an active community it would probably re-emerge as a legitimate contender.
It's a fascinating and superbly documented system, agreed. But a contender? Far too late for that, IMO, if it was ever in the cards (I don't think so.)
I understand the sentiment, although in reality it wasn't that bad. What I4GL and its ilk accomplished was to make a passable bridge between SQL and a vanilla procedural programming language, which still had the usual SQL/procedural impedance mismatches, but was miles ahead of horrors like Embedded SQL/C (as you've alluded to with the remark about generated C's verbosity.) I did my share of I4GL programming and still remember it semi-fondly.