When using vscode or its derivatives, I find the customizability is very limited. You have a couple of settings, but any new functionality basically requires writing a whole new extension and nobody really does that.
Meanwhile with vim I often add one or two lines to a local vimrc script which adds some project-specific command or keybind. For example - take ioctl name under the cursor, translate to the handler function name and open corresponding driver file in split view. It only saves a couple seconds but makes it so much more natural to analyze code. I have no clue how I would go about doing that in vscode.
I think you overestimate how "serious" most companies are. Sure, they have long documents about compliance but then you look behind the facade and see a CI server running on a windows laptop with an external USB SSD plugged in.
I read this a while ago and was looking forward to the mess that would happen with these default Alpine configurations (after setting non-UTC localtime)
If you're hell bent on functional style, you can represent memory writes as ((Address, Value, X) -> X), where X is a compile-time-only linear type representing the current memory state, which can be manipulated like any other SSA variable. It makes some things more elegant, like two reads of the same address naturally being the same value (as long as it's reading from the same memory state). Doesn't help at all with aliasing analysis or write reordering though so I don't think any serious compilers do this.
At this point might as well make them match the x/y convention, with first index increasing to the right, and second index increasing from bottom to top.
Ruffle is amazing. I launched a 20+ year old game yesterday with zero compatibility issues. Even better than the original Flash because of superior security isolation mechanisms.
Performance is definitely a big factor. I used to think CI was inherently slow and nothing could be done there until I started to self host local runners.
I think what the parent means is we should be able to create syscall sandboxes within the same process (like a library not being able to do IO). Maybe I'm wrong but I think this could sort of be implemented with CHERI, by restricting syscalls to the official libc entry points (like OpenBSD) and requiring a capability pointer to access the functions.
I realize I'm probably in the 0.001% by having this opinion (so don't take this as criticism or request for change or even a suggestion), but the reason I'm not buying this is the mechanical keyboard. Strongly prefer chiclet keyboards.
I'm surprised this required implementing a whole new sleep mode. Since it seems to be mostly used for async background tasks, why not configure the RTC to wake the laptop every hour or so (I think every laptop in existence already supports suspend with timeout) and go back to suspend if no tasks need to be done?
To be fair, the electron project likely invests some resources in reviewing it's own dependencies, because of its scale. But yeah this is a good exercise, I think we need more systems like Yocto which prioritize complete understanding of the entire product from source.
Log to a memory ring buffer (if you need extreme precision, prefetch everything and write binary fixed size "log entries"), flush asynchronously at some point when you don't care about timing anymore. Really helpful in kernel debugging.
The only thing that comes to mind is some form of atomic instructions that need to interact with other code in well defined ways. I don't see how you could polyfill cmpxchg16b for example.
Linux kernel has an interesting optimization using the ALTERNATIVE macro, where you can directly specify one of two instructions and it will be patched at runtime depending on cpu flags. No function calls needed (although you can have a function call as one of the instructions). It's a bit more messy in userspace where you have to respect platform page flags, etc. but it should be possible.
There is a native Teams package in the AUR which worked well when I had to use it. I assume it will get outdated eventually from lack of MS support. Web works of course.
A lot of this can be solved just by telling that to the developers. Sometimes I feel like I'm in some sort of secret don't-let-your-right-hand-know-what-your-left-hand-is-doing style organization. I was trying to meet [artificial] deadlines and putting effort into handling every corner case while a project was doomed due to external factors (lawsuit).
My most productive time is when a manager is honest and willing to explain how the whole thing fits together.
Ironically the more "user friendly" a distro is, the more issues I seem to have with it. I'm running Arch with a window manager, the only issue I ever had was a kernel regression, after which I switched to LTS.
Meanwhile whenever I had to deal with Ubuntu or other such distros, I keep getting issues in the most basic functionality even on fresh installs. Can't launch firefox, random non descriptive errors from package updates, poor device support...
I think checked exceptions are fine, they just haven't updated them along with other features. We now have expression based switch, why not have expression based try-catch? The other major problem is inability to pass them through the new functional interfaces, since they usually don't have anything like `<X> throws X`. But this could be solved by an Optional-like type.