• 11 Posts
  • 659 Comments
Joined 1 year ago
cake
Cake day: June 15th, 2023

help-circle


  • Plenty of self-driving trains around, generally metros where frequency and 24/7 operation is a great boon to overall service quality – you don’t want people to look at schedules, you want them to go to the station knowing there’s going to be a train in a couple of minutes, tops.

    It’s way different for long-haul service, freight, passenger, doesn’t matter. Longer and less frequent trains with way more passengers in them, and you probably need other staff too, like someone needs to run the bistro. The tracks they’re running on are also way less predictable, with a metro you can have station screen doors everywhere (which btw necessitate automatic driving, humans aren’t accurate enough) try that with an international train: Regions much less countries can’t even agree on uniform platform heights. Much less door locations: Automated long-haul would require dedicated platforms at every station and while those could be served by trains with drivers, trains nowadays are all smart enough that including a button “stop at exactly that location, to the half-centimetre” isn’t an issue, those trains would have to have doors at the right location. Now go ahead and convince Germany and France that they need to replace all TGVs and ICEs to have doors in the same location as your regional trains.

    Oh and none of that automation tech used with trains uses machine learning, btw. At least not at the basic level, when it comes to actually driving the train. I do remember watching a documentary about Singapore’s metro, where they have an ML algorithm scheduling track maintenance, minimising not service interruptions as such but impact on people’s commute. First the workers complained that none of the orders made any sense, then the developers made the computer spit out context and motivation alongside with the orders, workers changed their tune to “that’s fucking brilliant”.

    …which, actually, brings me to the conclusion: Also with automated systems we’re going to need maintenance which isn’t going to be automated any time soon. If you automate a metro that currently doesn’t run 24/7 you don’t have that many drivers in the first place, and probably have other jobs for them to do. Automating really is about making “a train max. every five minutes, 24/7” possible without breaking the bank.




  • I try not to and if I have to I’d use string interpolation. I’m not even sure whether you’re pulling my leg right know, I literally don’t remember whether they have a string append operator.

    Like 99.999% of the sh I ever wrote was in Makefiles and short wrapper scripts which could just as well be aliases. No argument handling past $@, no nothing the language is just too fickle for me to bother dealing with. The likes of zsh are make-up on a pig, I think I had a quick run-in with fish but never really got the hang. Nushell is different, it’s actually bold enough in its changes to get rid of all the crufty nonsense.


  • So can any TLD holder. The rules for .org might change to disallow individuals. .com might outlaw non-profits. .net might get restricted to ISPs. There is a small, but existent, chance that all the oxygen molecules in the room I’m in are going to decide that they’ll huddle up in some corner, leaving me to suffocate. I refuse to worry about it.

    If you want to be paranoid like that you can send the rust foundation some money and tell them to spend it on the .rust and .ferris gTLDs.


  • Unlikely, and even more unlikely to not be able to be worked around by a local rust user group.

    Like, the .eu restriction to only give out domains to individuals and companies within the EEA is more about having a domestic contact than anything else, EURid doesn’t care who actually uses the domain just that it has European legal representation.


  • Pre- and post-increment are only really useful when you’re doing C-style looping and there’s a good reason we don’t do that in Rust.

    I actually honestly can’t recall ever making an off by one error in Rust, I’m sure when implementing specific data structures or when doing pointer manipulation it’s still a possibility but you can write a gazillion lines of code without ever running risk of that particular annoyance. Also while C folks may have an argument regarding operator semantics, C++ folks don’t they’re doing unspeakable things to <<.

    Also, FWIW Haskell uses ++ to append lists and therefore also strings. It’s not like it’s an odd-ball usage of the symbols, that’d be .. which I vaguely remember some language using. Would cause a whole new class of confusion regarding 'a'..'z' vs. "a".."z". Not to mention that "aa".."zz" actually makes sense as a range all that’s missing is &str: Step. Probably not a good idea to have built-in because do we mean printable ASCII? Whole unicode range? Just the alphabet? Not an issue when you’re doing it to single chars but strings get ambiguous fast. Does Rust even guarantee stuff about Char ordering C certainly doesn’t really do that, short of I think 0..9 being contiguous.


  • Rust has impl Add<&str> for String and impl AddAssign<&str> for String. Both append as expected.

    I wouldn’t go so far and say “as expected”: “Addition” implies that we’re dealing with a ring, that there’s also multiplication, and that really doesn’t make sense for strings (unless you indeed consider them numbers). It’s why Haskell’s Monoid typeclass comes with the function mappend, not madd.

    In Rust’s defence though std::ops traits aren’t meant to carry any semantics they’re about syntax: It’s called Add because it’s +, not because it means something. I do think it would’ve been worth it to introduce ++ for general appending (also vectors, sets, maps, etc), though, to keep things clean. Also ++= for the mutating case.


  • Saint Helena is in no way comparable because it’s not disputed territory. Back when Mauritius became independent the British carved out some islands for their continued colonial use, breaking (back then brand new) international law.

    Saint Helena has no such connection to another country and it was uninhabited before the Dutch settled. The Brits later conquered it but even if the Dutch want it back it’d keep its autonomous territory status and therefore its own TLD, the Dutch have plenty of those.




  • That makes complete sense. Ranges implement fmt::Debug, .. is a range, in particular the full range (all values) ..= isn’t because the upper bound is missing but ..=.. ranges from the beginning to the… full range. Which doesn’t make sense semantically but you can debug print it so add a couple more nested calls and you get a punch card.

    I totally didn’t need the Rust playground to figure that out.

    EDIT: Oh, glossed over that: .. is only the full range if standing alone, it’s also an infix operator which is why you can add as many as you want (be careful with whitespace, though). .. .. .. .. .. .. .. .. .. .. is a valid Rust expression.





  • I think you dont fully understand how c compilers ( gcc specifically ) work when using multi file projects

    They don’t. C compilers compile single files produced by the c preprocessor (resolving all #includes), they have no concept of multi-file projects. That’s a thing for the build system, such as make, and it needs dependency information from the preprocessor to do its job (cpp -M), and once it has that it has to act correctly on them which is often completely broken because people don’t understand make. Like using it recursively, bad idea. In the wild, a random C project at work you’ll come across needs a full rebuild to build cleanly. Things have gotten better with things like cmake getting more popular but the whole thing is still brittle. GNU autohell certainly makes nothing better, ever.

    Also, anything using IL will always have an abi,

    Everything will always have an ABI because ABI is just API in the target language, whatever that may be. If your program is compiled and can run it uses an ABI.

    Wasm is wasm, and you only need an exposed interface

    The core wasm abi is less capable than the C abi: You get scalar values and pointers, that’s it. No structs, no nothing, memory layout is completely unspecified. The component model allows compilers to say “so I’m laying out strings like this and structs like that” giving linkers a chance to say “yeah I can generate glue code between you two”.

    Again, i like the idea of rust, but it has a long way to go to be viable atm.

    C isn’t even close to being viable according to your standards people just have gotten used to the jank.

    And it has many pitfalls to avoid so it doesnt become the hot mess that is any framework based on node.js

    Rust doesn’t have portable dylibs precisely because it isn’t a hot mess. Because it’s actual work to do it properly. Unlike everyone else. Meanwhile It speaks the local C ABI fluently (they differ by architecture and operating system, btw), which isn’t a thing that can be said about many languages that aren’t C.


    Differently put: What, precisely, do you want to do? Have you any actual use-case for your doubts, or are they spooks?


  • It’s a lacking point yes but unless you want to use a closed-source library it’s also a non-issue, which is why it has never been given priority. It’s not like language semantics would prevent portable dylibs it’s that there’s more important fronts to improve Rust on. A proper solution would take quite some engineering effort, and do note that C doesn’t have a proper solution either it just lets you link stuff up willy-nilly and then crash. Rust is actually in a better position to implement a proper solution than C is.

    The “big project” thing is a red herring given that rust compiles incrementally. I know it is technically possible to not rebuild everything from scratch in C but the code has to specifically written to not break assumptions your build system makes while rust is happily re-using the compilation results for one function in a file while discarding those of another because actual dependencies are actually tracked. Out of the box.

    Speaking of large Rust projects and proper type-safe linking: The WebAssembly folks are hashing out their Component Model which isn’t really limited to compiling to wasm, in principle: Big picture it’s a way to programmatically specify ABIs and even derive ABI translation code. That might be a good option as a rust-specific solution would be, well, rust-specific and when you engineer something that can support multiple versions of a language you can just as well engineer a bit more and have something cross-language.