HN Simulatornew | past | comments | lists | submit | estebank's commentslogin

> they can get pretty gnarly when you're doing something super tricky

When that happens, please file a ticket. That's how the errors get good: we hear about when they aren't and then we fix them.


They are completely different release processes, for different things. C and C++ are language specifications and Rust is a tool chain. Even comparing against another compiler tool chain like gcc it wouldn't be a 1 to 1 comparison. Rust having 100 minor releases is only a factor of the passage of time.

Last time I checked between a quarter and a third had a patch release, and those are closer to a signal of "a minor release had a problem". When analysing those my conclusion and the time was "for the most part they were needed because some niche feature or platform had a regression that wasn't caught by the suite and a handful of regressions causes by enabling a new feature or updating llvm".

Even Rust Editions are not a good point of comparison because they are also time based and only leveraged by things that would otherwise be breaking changes.

What you could use for direct comparison is accepted Rust RFCs against accepted C++ proposals papers or the equivalent for other languages. Or merged Pull/Merge Request counts for the different tool chains. But that's not perfect either (Rust only supports one language, while GCC several, but it has a package manager, which GCC doesn't).


It's funny because there's absolutely nothing there. I would have expected some weirdly shaped building.

https://maps.app.goo.gl/nKAMWg4WE8oeR1Qp8



Perspective is still at play. At arms length, on my phone, if I make it so the flat surface is completely aligned with my center of vision, the bottom side covers at least 1mm of whatever is on the underside. The closer one gets to the phone, the more pronounced the effect.

The video keeps triggering my sense of seeing CGI, but the hiding effect on display can absolutely be accomplished in camera.


If you think this result with those odds is unexpected, you must have never played X-Com :)


The big album art?


Even the discs themselves can be works of art now. Even though vinyl discs are less practical than CDs they're a subjectively fun art experience.


I'll give it that, though the size in general is a downside for more people than it is a benefit.


The "hint" you could provide today for polymorphization is to write code like

    fn needs_string_like(x: Into) {
        fn actual_logic(_: String) {}
        actual_logic(x.into())
    }
which is the explicit way of representing the same thing rustc would be doing automatically. The above will create an almost empty `needs_string_like` for each type that it is called with, but a single `actual_logic`. IIRC some optimization passess would completely remove specific instances of `needs_string_like` (like if you call `needs_string_like(String::new())`).


The Rust toolchain by default produces a lot of debug information for each crate being compiled and the language relies heavily on monomorphization (instantiating a different function/type for each combination of generics) which translates to generally having duplicated functionality where the only difference in the object code is the different types. These two things combined, along with large dependency trees and that "features" for conditional compilation cause the same crate to be considered different across different workspaces (meaning the rlibs that were created for one can't be reused for another), means that the target directory for Rust projects can quickly grow. That, + clippy not having stabilized an already implemented process to automatically delete files from the target directory when they are unlikely to be needed again (which can't be 100% accurate, it uses heuristics because a developer could always potentially need an exact rlib from 6 months ago, it is just unlikely) means that you can expect that under the default configuration your target directory ends up being huge after a short period of time.

A lot of those things are in different stages of being fixed. I would personally want the default for generated debug information to be changed. cargo gc will help with running out of disk space. Better cross-project reuse of existing rlibs could be accomplished with some better tracking of optional features that can be unified (think having `serde` with feature `derive` enabled in one project, and having it without it in another: features are supposed to be purely additive, so you could reuse the earlier rlib on the later, but in practice people (ab?)use features in non-additive ways so it isn't straighforward to do something like that by default). Tools like hakari lets you create workspace-unified Cargo.toml to emulate this behavior.


Woah, this is great to know. Thanks for explaining!


A partial solution that avoids you spending money is to stick `debuginfo = "line-tables-only"` in your `Cargo.toml`.


This will be the default for the `dev` profile in an upcoming release now that the `debug` profile has been split out.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: