Thanks, this looks awesome! Will play around on my CI/CD first to see if it's any good for the build-server to add trixie builds. Might use in prod deploys later.
I develop my apps in the most possible native way I can: deb packages, apt repo, systemd, journald etc. however I would like to also be able to run it in docker/vm. Is there a good systemd-in-docker solution for this to basically not run anything differently and not have to maintain two sets of systems?
I wonder if Nix is finally OK to use with LLMs. Used to be such a pain and just hours of googling to make simple things work. I think even ChatGPT didn't work well at the time for me, but now at least the try-and-fail can be done by the LLM itself.
Yeah, the only thing I'd love to see is "open with gdocs" to be somehow integrated similar to desktop experience. Having to drag and drop every time, creating new file, is really stupid.
I remember when it was absolutely crucial for your desktop/laptop to be able to do everything and Linux was a no go for people. Today you can live off your phone and be OK, so Linux actually makes much more sense. Camera/audio doesn't work well? No worries, just call via phone.
Off-topic, but kudos to Zed as being the first editor to actually allow me do Emacs keybindings which don't suck. Requires configuration, but overall it works and I use it alongside my regular Emacs. Feels great!
Yeah, it says "go find linux suitable for beginners". I googled "linux for beginners" and Google currently gave me such a mix bag of articles with options including Kali Linux. Crazy.
Also, who googles now anyways? Ask your local ChatGPT haha.
Jokes aside, ideally would be to make a decision and recommend Ubuntu (or PopOS).
I'm a much heavier Signal user than WhatsApp but for broader audience it not even serious to consider. Too slow/laggish, lacks features (at some point it ate 40GB of my phone space -- with no good UI to clean it up), crashes etc. Not ready for this kind of scenario, unfortunately.
It's discord-level feature-rich, e.g. it has "forums/topics", "channels" (which WhatsApp added poorly), much more developed sticker/reactions functionality, "round videos" and other catchy, viral features, at the same time doesn't feel like heavy discord. I've switched off long time ago due to security concerns, but now that I'm using WhatsApp/Signal -- they're just too basic.
I really hope it helps them build a decent app, but I doubt it. In Ukraine, there's a huge problem of Telegram being so feature-rich compared to WhatsApp that it's impossible to convince people to do the switch, even under the national security threat.
The big questions are: how's package management, community, ease of forking, patching and other dependency management related stuff. Server-side development needs those questions to have good answers.
I like how yes.rs has this header to make compiler shut up and not ruin the joke:
#![allow(unused_imports)] // We need ALL the imports for quantum entanglement
#![allow(dead_code)] // No code is dead in the quantum realm
#![allow(unused_variables)] // Variables exist in superposition until measured
#![allow(unused_mut)] // Mutability is a state of mind
#![allow(unused_macros)] // Our macros exist in quantum superposition until observed
#![allow(clippy::needless_lifetimes)] // Our lifetimes are NEVER needless - they're crab-grade
#![allow(clippy::needless_range_loop)] // Our loops are quantum-enhanced, not needless
#![allow(clippy::too_many_arguments)] // More arguments = more crab features
#![allow(clippy::large_enum_variant)] // Our errors are crab-sized
#![allow(clippy::module_inception)] // We inception all the way down
#![allow(clippy::cognitive_complexity)] // Complexity is our business model
#![allow(clippy::type_complexity)] // Type complexity demonstrates Rust mastery
#![allow(clippy::similar_names)] // Similar names create quantum entanglement
#![allow(clippy::many_single_char_names)] // Single char names are blazingly fast
#![allow(clippy::redundant_field_names)] // Redundancy is crab safety
#![allow(clippy::match_bool)] // We match bools with quantum precision
#![allow(clippy::single_match)] // Every match is special in our codebase
#![allow(clippy::option_map_unit_fn)] // Unit functions are zero-cost abstractions
#![allow(clippy::redundant_closure)] // Our closures capture quantum state
#![allow(clippy::clone_on_copy)] // Cloning is fearless concurrency
#![allow(clippy::let_and_return)] // Let and return is crab methodology
#![allow(clippy::useless_conversion)] // No conversion is useless in quantum computing
#![allow(clippy::identity_op)] // Identity operations preserve quantum coherence
#![allow(clippy::unusual_byte_groupings)] // Our byte groupings are quantum-optimized
#![allow(clippy::cast_possible_truncation)] // Truncation is crab-controlled
#![allow(clippy::cast_sign_loss)] // Sign loss is acceptable in quantum realm
#![allow(clippy::cast_precision_loss)] // Precision loss is crab-approved
#![allow(clippy::missing_safety_doc)] // Safety is obvious in quantum operations
#![allow(clippy::not_unsafe_ptr_arg_deref)] // Our pointers are quantum-safe
#![allow(clippy::ptr_arg)] // Pointer arguments are crab-optimized
#![allow(clippy::redundant_pattern_matching)] // Our pattern matching is quantum-precise
Not clear. Will this allow loading ipc files in DuckDB finally? That's been my biggest issue, since I use IPC files for append operations before I turn them into parquet files.
Biggest problem with flatpak for me is that it's not suitable for server-side software, which is well supported in Snap. Is that even planned at some point?
It looks more like "conceptually solved" thing, but I would wait and see a number of real-world web apps to compare it with Elm before I'd understand how good it is.
So far the best way to fix Rust for me was to use OpenAI's CODEX tool. Rust libraries change APIs often and evolve quickly, but luckily all the code is available under ~/.cargo/registry, so it can go and read the actual library code. Very useful!
Raspberry Pi uses microSD card. Just using fsync after every write would be a bit devastating, but batching might've worked ok in this case. Anyways, too late to check now.