2,784 karma · joined March 29, 2011
Website: https://yorickpeterse.com
In particular, there's a big difference between "can show more colors" and "shows the same colors but overly saturated".
The Framework 16 suffers from this by default, something that's quite obvious when comparing it by looking at photos for which you know what the actual colors look like, something I did do but didn't cover in the article.
Whether this is because the display operates in a different colorspace by default (e.g AdobeRGB) or not I don't know, but there's at least no option for it anywhere in the BIOS that I could find.
Claiming the Framework is superior over a monitor literally meant for color grading and photography is laughable to be honest, and seems to suggest you interpret display quality as "more intense is better".
> I don't really know what the "creaking screen" is about though. IMO the F16 screen and hinges are a higher build quality than the F13. I had to upgrade my F13 hinges to the 4kg hinges to keep it from bouncing and moving.
I think the comment was referring to the noise of the spacers, unless the author also thought it was in relation to the display. So to clarify, the display makes no noise whatsoever and neither do the hinges. The noise shown in the video is specifically about the trackpad and keyboard spacers. Given my past experiences with X1 Carbon laptops breaking outside of warranty and the frustration that comes with replacing their components, I decided it was time to look for a replacement.
[...]
There are also some other issues with the X1 line in general, such as poor CPU cooling and the absolute nightmare that is opening them up to replace parts or clean them properly.
Maintaining an X1 is certainly possible, but it's incredibly frustrating and based on my past experiences with this series I strongly suspect other components will also fail in the near future.Indeed, I just pressed a "Buy now" button without a moment's thought. Clearly the fault is all mine.
Basically I just trust IPS more than any other technology :)
Btrfs supports both snapshots and sending/receiving them between different hosts. You can also create additional Btrfs subvolumes.
This is mostly what I meant with the differences between zfs and btrfs not being that significant for most: they largely seem to give you the same end result, instead taking a different path to get there. I do know that zfs is better in terms of reliability (or at least people love to bring that up), but it's something I don't have any experience with myself and thus can't comment on.
Location: Delft, The Netherlands
Remote: Yes (remote only)
Willing to relocate: No
Technologies: Rust, Ruby, PostgreSQL (a lot more in the past, but less relevant as to what I'm looking for)
Résumé/CV: https://yorickpeterse.com/resume/ / https://github.com/yorickpeterse/
Email: yorick at my domain name
15 years of backend experience, with a focus on distributed systems, compilers, and language runtimes. Currently looking for a Rust focused job that involves doing something meaningful for the world (e.g. no crypto, high-frequency trading, etc).The downside is that you can end up with thousands of object files, but for modern linkers that isn't a problem.
- Array.get/Array.get_mut for when you want to panic on an out-of-bounds index
- Array.opt/Array.opt_mut for when you want an Option type, with it being a None for an out of bounds index
So for example:
[10, 20, 30].get(0) => 10
[10, 20, 30].get(42) => panic
[10, 20, 30].opt(0) => Option.Some(10)
[10, 20, 30].opt(42) => Option.None
This pattern is applied across the standard library where this makes sense, such that the developer can pick which option works best for their needs.There are a few places where we check for some input at runtime and panic if this is invalid, but this is limited to cases where there's simply no sensible alternative (e.g. providing a key with an invalid size to a ChaCha20 cipher).
For runtime error handling you'd use algebraic types such as Result and Option, similar to most functional languages and Rust.
The reason we don't allow catching of panics (such as Rust allows) is because it can result in people more or less ignoring such errors (something I've seen happen far too often in past projects) and just retrying over and over again, achieving the same result every time. I'd much rather have the program crash and scream loudly, forcing developers to address the issue. Fortunately, the chances of you actually running into a panic at runtime should be pretty slim, so not being able to catch them shouldn't be much of an issue in practice.
There isn't. For this to work, functions for inline types have to be compiled such that one of these approaches is used:
1. They always take inline values by pointer, and we have to guarantee those pointers are never invalidated. This again means you need some sort of borrow checking scheme.
2. We compile two versions for each function: one that takes the data by value, and one by pointer, resulting in significant code bloat and compiler complexity.
I think the split also better captures the intent: heap types are for cyclic and heavily mutated values, inline types are more for short-lived mostly immutable values.