these days Hyprland but previously i3.

i basically live in the terminal unless i’m playing games or in the browser. these days i use most apps full screen and switch between desktops, and i launch apps using wofi/rofi. this has all become very specialized over the past decade, and it almost has a “security by obscurity” effect where it’s not obvious how to do anything on my machines unless you have my muscle memory.

not that i necessarily recommend this approach generally, but i find value in mostly using a keyboard to control my machines and minimizing visual clutter. i don’t even have desktop icons or a wallpaper.

i haven’t personally had trouble with that since early 2023, but it depends on your dependencies

i feel like if you’re not sat stationary at a workstation (who is these days) what you want is a laptop that’s good at being a laptop. 99% of the software developers i work with (not a small number) use Macbook Pros. they are well built, have good components, have best in class battery life (we’ll see how things shake out with Qualcomm), and are BSD based and therefore Unix compatible. my servers and gaming/CUDA PC? Linux all day. my laptop? Macbook. i’m not ideological enough to have range anxiety every time i step away from my desk. plus any decent sized org is going to have to administrate these machines, from scientists to administrators, and catering to .4% of your users is not a good ROI if your software vendors struggled for 8 years to get their Windows 98 based specialty sensor software to run on Mac.

that .4% is likely not 0 because they are nerds.

seriously tho if Qualcomm chips can make a Linux book that lasts all day i would happily make the switch

the semantics of C make that virtually impossible. the compiler would have to make some semantics of the language invalid, invalidating patterns that are more than likely highly utilized in existing code, thus we have Rust, which built its semantics around those safety concepts from the beginning. there’s just no way for the compiler to know the lifetime of some variables without some semantic indication

i’ve used Chezmoi for years now pretty successfully. works on my Mac and Linux machines. it probably could be made to work on Windows. i am transitioning to NixOS, but i’ll probably keep using it anyway, since i still have Macs for work (and because they’re great laptops don’t @ me). the only real downside is that it only works for the home folder, so i have to manually control stuff for /etc, but i generally prefer user configuration for most tools anyway.

i had messed around with Ansible for this in the past, but i didn’t really like it for this use case. it’s been a while tho so it’s hard to say why.

not to pile on, but you might also look at GNU Stow. i decided against it, but it’s there.

obligatory i s’pose: https://github.com/covercash2/dotfiles

lol this is like Ben Shapiro telling people in areas threatened by climate change to sell their houses. “to who? fucking Aqua Man?”

best case you’ll get $10 and whoever bought it will end up back here

Users who need to run their application in Python 2 should do so on a platform that offers support for it

damn go off

ah yeah. maybe less well known, but i had a dev kit from Qualcomm that came with Ubuntu

not likely. i think it requires a lot of systems working together

always? Android runs a linux kernel, and they support all kinds of embedded systems that run Linux.

pretty standard compared to OSs like Android and iOS. i think the mobile OSs, at least recently, have done better at this; they don’t ask for permission until they need it. want to import bookmarks? i need file system access for that. want to open your webcam? i need device access. doing it all upfront leads to all the problems mentioned in this thread: unclear as to why, easy to forget what access you’ve given, no ability to deny a subset of options, etc.

nushell is excellent for dealing with structured data. it’s also great as a scripting language.

yeah i see that too. it seems like mostly a reactionary viewpoint. the reaction is understandable to a point since a lot of the “AI” features are half baked and forced on the user. to that point i don’t think GNOME etc should be scrambling to add copies of these features.

what i would love to see is more engagement around additional pieces of software that are supplemental. for example, i would love if i could install a daemon that indexes my notes and allows me to do semantic search. or something similar with my images.

the problems with AI features aren’t within the tech itself but in the surrounding politics. it’s become commonplace for “responsible” AI companies like OpenAI to not even produce papers around their tech (product announcement blogs that are vaguely scientific don’t count), much less source code, weights, and details on training data. and even when Meta releases their weights, they don’t specify their datasets. the rat race to see who can make a decent product with this amazing tech has made the whole industry a bunch of pearl clutching FOMO based tweakers. that sparks a comparison to blockchain, which is fair from the perspective of someone who hasn’t studied the tech or simply hasn’t seen a product that is relevant to them. but even those people will look at something fantastical like ChatGPT as if it’s pedestrian or unimpressive because when i asked it to write an implementation of the HTTP spec in the style of Fetty Wap it didn’t run perfectly the first time.

i guess the rare thing is the public commitment, but Apple has generally had a good track record for updates compared to its Android counterparts, who have previously failed to meet their goals or set laughable goals like 2 years.

used to be the Android team used Ubuntu, not sure if that’s still the case. Linux is pretty much the native environment for Android dev. i’d recommend at least 4GB of dedicated RAM if not 8. definitely at least 8 if you plan to use the emulator (which is itself a VM).

Android Studio will get you 90% of the way there. it will help you install the SDK, emulators, etc, and provide UI front ends for the CLI tools, ie adb.

there’s really not much to system level dependencies. if your distribution supports JDK 17 (probable) you’ll be fine with whatever.

obligatory: i use Arch, btw

IBM then. or, i don’t know, the British Royal Family?

the reality of talking about extremist economics is no one knows how it would work out in the long term. but regardless, if it happened tomorrow we already have a Microsoft to deal with.

“taxation is theft” “wage labour is exploitation”

sometimes things are subtle and complicated and can’t be practically boiled down to absolutes.

honestly 8 space indents always felt a bit ridiculous to me. i usually use 4 since it’s more conventional in most languages but could also be happy with 2.

weird hill to die on. use default setting unless you have a good reason not to. the argument itself is a waste of time on projects that want to get things done.

i really want to like Nix.

gave it a shot a few years ago, but i felt like documentation and community support wasn’t really there yet. this was long before Nix surpassed Arch in terms of number of available packages. now people still complain about documentation, especially of the Nix language. i see a lot of package authors using it, and that kind of tempts me to start using at least the package manager. but a lot of packages don’t. the allure of GitOpsing my entire OS is very tempting, but then there’s been these rumors (now confirmed) of new forks, while Guix splintered off much earlier. for something that’s ostensibly supposed to be the most stable OS, that makes me nervous. it also seems to have some nontrivial overhead—building packages, retaining old packages, etc.

the pitch for Nix is really appealing, but with so much uncertainty it’s hard to pull the trigger on migrating anything. heck, if i could pull off some PoCs, i think my enterprise job might consider adopting it, but it’s a hard recommend for me today as it was 5 years ago.

you’d be surprised how fast a model can be if you narrow the scope, quantize, and target specific hardware, like the AI hardware features they’re announcing.

not a 1-1, but a quantized Mistral 7B runs at ~35 tokens/sec on my M2. that’s not even as optimized as it could be. it can write simple scripts and do some decent writing prompts.

they could get really narrow in scope (super simple RAG, limited responses, etc), quantize down to even something like 4 bit, and run it on custom accelerated hardware. it doesn’t have to reproduce Shakespeare, but i can imagine a PoC that runs circles around Siri in semantic understanding and generated responses. being able to reach out on Slack to the engineers that built the NPU stack ain’t bad neither.

i think it’s a matter of perspective. if i’m deploying some containers or servers on a system that has well defined dependencies then i think Debian wins in a stability argument.

for me, i’m installing a bunch of experimental or bleeding edge stuff that is hard to manage in even a non LTS Debian system. i don’t need my CUDA drivers to be battle tested, and i don’t want to add a bunch of sketchy links to APT because i want to install a nightly version of neovim with my package manager. Arch makes that stuff simple, reliable, and stable, at least in comparison.