Live data from Hacker News

Viewing profile — kimundi

kimundi

HN member
Joined
Mon, Jul 14, 2014, 6:30 PM UTC
HN karma
34
Public activity
21 items

About kimundi

No profile information was provided.

Recent public activity

  1. comment
    Comment #29935048

    Yes, the macros parse the string at compiletime and generate code that does the formatting as given by them. Here is an example for how the code would look like expanded: https://p…

  2. comment
    Comment #28536757

    Think of raising an orbit like moving an item from one side of your desk to the other. You have to put energy into doing it, but the end result is just as much in balance with grav…

  3. comment
    Comment #26917034

    Separating the "get to/from moon" vehicle from the "land on/start from moon) vehicle has indeed been the plan for many years now.

  4. comment
    Comment #26814139

    With dynamically sized types like `str`, Rust allows to separate "what kind of pointer + metadata is this" from "what kind of data does it point at". So, for example, you can have …

  5. comment
    Comment #26447757

    The github discussion thread where that originates from also contain the language designers optimistically discussing how in the worst case `Pin` just has to be hardcoded to exclud…

  6. comment
    Comment #26412405

    Fully agree with that, and Rust makes that very easy still. Its 5-10 lines to spawn multiple threads that communicate with each other either via shared state or message passing, an…

  7. comment
    Comment #26008510

    The flip will be less extreme in later designs because they will have better/larger RCS control thrusters to rotate it without involving the main engines. Also the center of rotati…

  8. comment
    Comment #25592450

    Affinity is a property of the type in Rust, so any given value is affine or not depending on which type it has.

  9. comment
    Comment #23942679

    Note that that is passing by value, so its moving/copying ownership. Its like having a immutable integer variable and copying it to a different mutable variable.

  10. comment
    Comment #21801770

    Wasm programs can only crash by triggering a "trap", which has the well defined semantic of aborting the entire (wasm) function stack at that point. It depends on the embedding hos…

  11. comment
    Comment #15806214

    I think they just meant that Rust references are like normal first-class generic types. Eg, you can nest them to get a &mut &T for example, since they behave more like a pointer in…

  12. comment
    Comment #12976628

    Rusts references behave like plain raw C/C++ pointers at runtime, without any bookkeeping code running at all. The magic all lies in the compiletime borrow checker, which roughly w…

  13. comment
    Comment #11579424

    I don't have concrete examples, but in general: For one, the build system/dependency system is much more easier to handle. Rust uses the cargo package manager, and depending on an …

  14. comment
    Comment #11516986

    Hi, me and a few others in the Rust community kinda hashed out an plan of how you would do safe code un- and reloading Rust. Its nothing official, and has no implementation or offi…

  15. comment
    Comment #11180705

    The multi threaded architecture of servo is actually more energy friendly than existing engines for the same workloads, since distributing the same amount of work over more cores m…

  16. comment
    Comment #11122166

    Note that I'm not really familiar enough with versioned symbols to know whether there is much more to it than just a specially formatted name.

  17. comment
    Comment #11116453

    The default name mangling of Rust library symbols is already kinda versioned because it includes a hash of the library, so two different versions of a library can coexist at the sa…

  18. comment
    Comment #9530091

    That's not a list of Show, that's a list of a single type that instantiates Show. The difference being that in your code you can only put in a single type at a time, eg [Int] or [S…

  19. comment
    Comment #8865487

    Well, the first two are really just the same thing :P

  20. comment
    Comment #8434703

    Yes, though this particular code would not compile because one of the lifetimes is not declared.

  21. comment
    Comment #8032444

    Rust actually has two different reference counted smart pointers: `Rc`, which uses non-threadsafe reference counting, and hence is not sendable across thread boundaries; and `Arc`,…