“Design system” is a way for designers to organize what they are doing with emphasis on structure and central definition of different components, colors, etc. This allows designers to create UI mockups more easily and programmers to implement the designs without guessing.

My guess is that that the new theme will be designed using this new system and then implemented using Union.

IIRC you can’t grant the permission if the app doesn’t explicitly declare it in its manifest. I doubt most devs would care unless access to local network is required for app’s functionality on typical user’s setup (e.g. if it’s a companion app for some device).

Newtypes have their uses, but as a replacement for named arguments they are an overkill in many cases. They solve different problems.

Newtypes are beneficial when some domain-specific value with an invariant is used extensively throughout the codebase. You would use them to store and pass around that value without fear that something goes wrong.

However if we start to create a type for each parameter of every function (which may not be related at all), it would only result in a lot of unnecessary boilerplate. Named arguments is a simple and elegant solution for calling a function in a more explicit way, nothing more.

Devs are lazy. Any productivity gains are negated by them simply choosing to work less and have more free time. Which is not a bad thing.

The biggest hurdle are messengers, especially including cross-platform support and mobile devices.

AFAIK compilot just provides integration with visual studio and GitHub, it doesn’t have its own models. You pay through Microsoft to use use other companies’ models (like GPT or Claude). Though agent harness itself has a big impact on the performance of models.

Which ones don’t support it? It’s a very old format at this point. Every Android device in existence can work with it for example.

There is zero chance it will be released (even if it’s true)

It will still run necessary calculations much slower than a gpu, so you will need to run it much longer for the same result, which is not only inconvenient but will likely use more power in the end anyway.

This will just waste even more energy since cpus are less efficient at this kind of task.

LLMs require insane amounts of compute, period. The hardware to do that needs energy and emits heat, there is no way around.

That’s still just moving the impact from data centers to end users’ machines.

Gamers (especially those that own 5090) are a tiny minority compared to llm users.

It’s really easy to not use ai. It’s not a necessity and not even a part of any “lifestyle” that some people would miss.

They are not magic. You are still using electricity, and for the same amount of work that cloud providers do you will consume the same amount. If every one of the billions of people using chatgpt or whatever buys rtx 5090 and makes it churn 24/7 for their “local” ai then nothing will change for the environment.

So you don’t care about environment, huh?

Yep, it’s all binaries.

In Java world package managers and package registries work with prebuilt libraries because for JVM bytecode it’s sufficient. And if they have native dependencies then they include compiled .dll or .so files that are built on developer’s machine. This makes things simpler but has its own drawbacks (these dependencies work only on architectures and OSes developer thought of, there is no guarantee that the library will be compatible with user’s environment, etc).

In Rust world everything is built from source, including native dependencies. Thsi makes build process much more complicated and necessitates running code on user’s (developer consumes the library as dependency, not end user) machine to build everything that’s not Rust.

It’s necessary to integrate Rust with other languages (to build source code in other languages, generate some bindings, etc). Otherwise you will have to make Cargo understand every other build system in existence, and stay compatible with them forever.

Ideally this should be heavily audited and allowed only when it’s really necessary.

Firefox tries but this is very hard to fight against. Most of the obvious holes were closed long ago. Now these fuckers use normal browser functionality that can’t be disabled and record how it subtly differs (in various ways like execution time of functions) between different combinations of browsers, OSes, hardware, etc. This information alone is enough to create a more or less unique fingerprint.

The only reliable solution is to completely get rid of client-side code execution like JavaScript and WebAssembly and return to static web pages. Which of course won’t happen.

Happens all the time with GitHub Actions when they update runner images. According to Microsoft, it’s “fundamentally unfixable”.

Do you use cloud or local ai to write your comments?