If the cost is subsidized by another cash source (e.g. VC money) when the source stops prices can definitely go up.

AI may not be the source of the problem but can make it a hundred times worse.

This one works: https://docs.plane.so/self-hosting/self-hosting

Not for me it doesn't. 404. Here's the real link: https://docs.plane.so/self-hosting/docker-compose

Given that YAML it's a configuration language I'd say that not being turing complete it's a feature, not a bug nor a limitation; I always want my language files to be declarative to not suffer the perils of logic.

Edit: Also, I don't see the need for a turing complete language for something like docker compose, if you need something really complex you can always script a docker-compose.yml generator with all the logic and complexity you need.

I can't believe that people is comparing opening a project in a code editor with running a build script.

The PoC doesn't even open a file, it just opens the directory. It's a pretty big difference, when you execute a build script you _expect_ to run code, when you open a directory in your editor you don't expect any side effect _at all_.

My guess is that since the proc_macros returns a TokenStream, rust-analyzer have no way to know what it provides except running it.

I'm not sure there's a solution for this that doesn't cripple macros in Rust, apart from being able to configure rust-analyzer to ignore the macros, which clearly limit its usefulness.

More specifically, a proc macro is a Rust function that is compiled and run inside the compiler at build time. With IDEs, LSP and other protocols for having your editor query the compiler (or language runtime, like SLIME/SWANK), the compiler now runs whenever you open your editor.

It’s just not a new problem. Bash does auto–completion on Makefiles, which requires running make and asking it what the make targets are. IDEs can and will run ./configure for you, so that it can find the right include paths. Etc, etc.

Personally, I thought everyone already knew about this. I knew that proc macros would be a risk when I first heard about rls, years ago.

Certainly editors need to confirm with the user that they are ok with starting the compiler when they load a new project, but also we need to use fine–grained security systems like SELinux that can and do prevent programs from accessing things that they’re not supposed to access.

One potential solution:

- During a session, the first time rust-toolchain encounters a proc macro it must run to analyze, it will first prompt the user and warn them.

- If the user accepts the prompt, rust-toolchain will freely run any proc macros until the next session.

- If the user rejects the prompt, that analysis will be disabled until the next session.

Similar to how VSCode and other apps handle opening links.

You'd have to sandbox the analyzer. Let it run arbitrary code but don't let it do IO. That can be pretty tricky to do for a language not designed to be sandboxed.

Safest way would probably be something hilarious like having the analyzer compiled to WASM and ran in node.js.

By default rust-analyzer also executes Rust build scripts (build.rs) just by opening the project in an IDE, so as far as Rust goes the comparison is apt.

    rust-analyzer.cargo.runBuildScripts (default: true)

    Run build scripts (build.rs) for more precise code analysis.

https://rust-analyzer.github.io/manual.html

Open it in notepad? You don't install software that automatically build your project and complain that it is doing that.

Agreed. The top comments on this thread are wrong, overconfident and silly. Read the article people.

You don't need Termux for that, there are native clients for Android, I use this one: https://play.google.com/store/apps/details?id=dev.msfjarvis....

There are native clients, but can you use git to sync the encrypted passwords with your other devices?

And that was just one example. You can also use python as a much better calculator, share files over wifi with a web server etc.

Rclone is really a fantastic tool, its configurability based on backends allow for amazing combinations!

You can configure any cloud storage backend (B2, S3, GCS ...) and combine it with other utility storage backends, like "crypt" [1], "cache" [2] and "chunker" [3], I highly recommend it to anyone searching for a backup solution.

The only feature I miss from Rclone is automatic directory monitoring and mirroring, which I solved using Syncthing (but forces me to host an additional server for it).

[1] https://rclone.org/crypt/ [2] https://rclone.org/cache/ [3] https://rclone.org/chunker/