Guix and the developer ecosystem

[Distopico <distopico@riseup.net>]

Hi, I'm quite new in Guix, I have been using it for 6 months now and I
love it, but for development I have not been able to use it as much as I
would like.

The current programming languages are made up of three 4 parts:

1. The languages itself
2. Language-server
3. The language packages
4. Language tools (formatter, linter)

It is possible to development without a language server, but many
projects now require special formatting or running linter tools,
etc. These are things that are somewhat basic in a certain way.

In terms of programming languages, I have found almost all the ones I
needed, with the exception of Kotlin.

Regarding language servers, most of the ones I needed either haven't
worked for me or don't exist. For example, Rust, Haskell, and Elm have
few tools available, and even though I mainly program in Rust and
Haskell, and lately, I've been getting into Guile, I also have old
projects in Kotlin, for instance, or sometimes I like try other
languages when `guix shell` is awesome.

So, sometimes I wish to do...

```
guix shell ghc haskell-language-server hlint
```

In that case, the language server isn't available. Another example:

```
guix shell rust@1.67.1 rust-analizer rust-clippy
```

In that case, rust-analyzer won't be compatible with that version of
Rust, and the version of rust-analyzer is broken (I sent a patch fixing
it).

In some languages like Haskell and GoLang, the language server depends a
lot on the version it was compiled with. For example, I tried gopls,
which is available in Guix, but it was built with Go 17 and is not
compatible it.

So, in many cases, I haven't been able to fully integrate Guix into my
development workflow. I had to look for alternative ways outside Guix,
like Nix.

I appreciate the simplicity of Guix, but let's say that Nix has a
developer-oriented approach and has become very popular among
programmers. Many projects now include default configurations for Nix in
their repositories.

Another issue is that if I wanted to bring Guix into the development
workflow in a team, there would be the limitation of the OS. While I
promote free software in working groups, not everyone uses the same OS -
some use GNU/Linux, some use Mac, etc. I think this is also part of the
reason why Nix has succeeded in development environments.

All this text is provided some context for two simple questions:

1. Are there plans in the future to improve integration between
development tools? For example, having haskell-language-server for
ghc@9.x and another one for ghc@8.x, or something similar to the
overwrite feature in Nix flake?

2. Do you see developers as a potential target audience for Guix, or is
it mainly focused on HPC (High-Performance Computing)?

I have started contributing to packages that I believe could be useful,
and I like to contributing to teams such as Haskell or Rust. However,
there are other topics, such as compiler and tools compatibility, where
I'm not entirely clear about the direction that has been planned.

And apologies for the lengthy text.