It doesn't make the original bug less severe, but it was resolved under an hour after it was reported.

Oh, good to know, thanks for replying!

Makes you wonder about the underlying plumbing though, if setting an GUI appearance option can lead to data loss in the first place.

Is there a writeup/summary somewhere that explains "the lessons learned"? Otherwise I'd kind-of start to worry about what could happen, if ... say ... I change the Bluetooth output codec, or some other other UI details.

> Is there a writeup/summary somewhere that explains "the lessons learned"?

Not that I'm aware of, but I'm sure you could check the GitLab commits and/or ask on their forum if you're interested.

This is a young project (just under a year old) with developers who do this for fun. The developers are going to keep making changes that maintain the fun they have during development.

Mistakes will be made. Things will break. Lessons will be learned. This isn't a decades-old mature distro, so if you're expecting something absolutely bullet-proof then Garuda currently isn't it.

However, I will say that the pace of improvement is pretty stunning. Their direction and what they have achieved in a short space of time is pretty impressive - not just within the distro itself but the surrounding OOB features and infrastructure like ChaoticAUR (prebuilt AUR packages), secure password management (Bitwarden), dotfile sync (NextCloud), a pastebin service for log output (Privatebin), ...

Is it perfect? No. Is it for everyone? No. It is what it is, and doesn't try to be anything else, and I kind of like that approach.

All fine and well, but then the Webpage should perhaps tone down a bit on the flashy images, and perhaps mention more prominently, that this iron is still glowing hot on the forge, and basically a tinkering environment for the time being.

There is an _option_ to do this, it is _not_ the default.

The screenshot in their picture gallery has it checked, so I assumed, that was the default setting

I guess the Garuda Boot Options screenshot shows the options in operation:

https://garudalinux.org/images/garuda/ss/garuda-boot-options...

I'm not sure whether this is misleading or not given the nature of illustrative screenshots, e.g. the package management one shows VLC installed but not Firefox:

https://garudalinux.org/images/garuda/ss/pamac.png

From my limited understanding: it looks like a matrix coprocessor, and implies that hardware-accelerated matrix processing has been built into the M1.

Matrix processing comes in useful for AI/ML/CV-type applications. It's something GPUs are generally very good for.

> 10€ is given to the project edition.

Do you know where this payment goes to? e.g. is it to their OpenCollective or LFX donation accounts?

I have no idea, sorry.

Possibly useful existing implementation:

https://github.com/unfs3/unfs3

This has the benefits of being tested and having a working read-write implementation (along with still being user-space).

Want to "skip" the compile step?

  //usr/bin/tcc -run $0; exit
  main() { printf("Hello\n"); return 0; }

Just `chmod +x` and run it...

It's obviously not the same, but you can emulate this with a conventional compiler:

  #if 0
  set -e; [ "$0" -nt "$0.bin" ] &&
  cc "$0" -o "$0.bin"
  exec "$0.bin" "$@"
  #endif
  
  #include <stdio.h>

  int
  main(int argc, char *argv[]) {
    puts("Hello world!");
    return 0;
  }

It works, because by default system shell will be spawned.

How does this work? Is there an alternate form for #! (aka shebang)?

EDIT: hah, I should have realized that "//" is the C comment and "//usr/bin/tcc" is equivalent to "/usr/bin/tcc". Clever!

I always love these things that are really scripts in two (or more) languages. Common is something like this on Windows to make a command script a Perl script. It lets you run your Perl script without having to make sure you had .pl extensions associated. Though, you needed Perl installed, so I never quite got the point.

    @rem = '--*--Perl-*--
    @echo off
    echo Hello from a command script
    perl -x -S %0 %*
    goto endofperl
    @rem ';
    #!perl
    print "Hello from Perl!\n";
    __END__
    :endofperl

By far very less common is to stuff some Perl code in a C# source file. A dev that was way too clever for his own code did this to have a Perl script that would update a C# script file and be self contained. This is a simple example of what it looked like, minus the instant headache anyone got that had to look at the real version:

    #if PerlScript
    $csharp=<<WhyJustWhy;
    #endif
    using System;

    namespace Example
    {
        public static class Program
        {
            static void Main()
            {
                Console.WriteLine("Hello from C#");
            }
        }
    }

    #if PerlScript
    WhyJustWhy
    print("Hello from Perl!")
    __END__
    #endif

"C comment," you mean.

So it's running the file as a shell script, where the first line runs tcc on the current file and quits.

Fixed typo, thanks. Yeah for some reason it didn't click when I saw it.

From man tcc(1):

    #!/usr/bin/tcc -run
    #include <stdio.h>
    
    int main()
    {
        printf("Hello World\n");
        return 0;
    }

D code can also be run this way:

    #!/usr/bin/rdmd
    void main() { import std.stdio; writeln("hello"); }

And add the -b commandline flag to enable the memory and bounds checker.

Just as a side note... It's important to say that it still does get compiled... it's not some kind of interpreted mode.

I was just about to reply about the same thing:

  #!/usr/bin/tcc -run
  
  #include <stdio.h>
  
  int main() {
    printf("Hello\n");
    return 0;
  }

Or even

  tcc -w -run - <<< 'main() { printf("Hello\n"); return 0; }'           

However, runc seems more convenient to pass in just the statements.

That wasn't quite what I was trying to show with the snippet - I was intimating that you can use tcc to run C directly in something like a shell script.

If you want to make `tcc -w -run` etc. more convenient then:

  alias trun='tcc -w -run - <<<'
  trun 'main() { printf("Hello\n"); return 0; }'

---

I can't edit my parent comment now, but it can be improved with e.g.

  //usr/bin/tcc -run $0; exit
  main() { printf("Hello\n"); return 0; }

> That wasn't quite what I was trying to show with the snippet - I was intimating that you can use tcc to run C directly in something like a shell script.

I know, but the first example in the link was:

  $ runc 'printf("%s\n", "Hello!");'  
  Hello!

So I figured I'd complement your example use with one that was more analogous to that.

> I can't edit my parent comment now, but it can be improved with e.g.

To be honest, I liked your original example more. Using that `//` "shebang" depends on what shell it's invoked from, and it wouldn't work when calling exec from other languages. For example, with your last example using `//`:

  $ python -c 'import subprocess; subprocess.run(["./hello-tcc-double-slash-shebang.c"])'   
  Traceback (most recent call last):
    File "<string>", line 1, in <module>
    File "/usr/lib/python3.8/subprocess.py", line 489, in run
      with Popen(*popenargs, **kwargs) as process:
    File "/usr/lib/python3.8/subprocess.py", line 854, in __init__
      self._execute_child(args, executable, preexec_fn, close_fds,
    File "/usr/lib/python3.8/subprocess.py", line 1702, in _execute_child
      raise child_exception_type(errno_num, err_msg, err_filename)
  OSError: [Errno 8] Exec format error: './hello-tcc-double-slash-shebang.c'

while it would work with the `#!` shebang, since that's handled by the kernel.

> You do realize that no version of Ubuntu was ever released with that feature?

Not sure that is true - I seem to remember that it was enabled by default in a couple of releases (I think somewhere around 12.04?).

> you had to opt in > It's easy to get upset about stuff people have made up

I raised this issue early in the Lens development phase. The response from the mailing list was (paraphrasing) "well, people can always uninstall the package if they don't want the feature" (at which point I then opted out entirely).

Opt-in came much, _much_ later.

You're shocked that they consider and plan for a worst-case/edge-case scenario?

That sort of attention to detail is what continues to impress me about the Arch methodology.

I wish those people who find they can easily find another job without any effort or worry would realise they are not normal.

For the majority of people finding a half-decent job takes a stupid amount of time (the number of jobs advertised which simply list a set of "technology words" and end in a black hole is not insignificant), and even if you do find a reasonable position being advertised then it's perfectly normal to never get any sort of response back.