Hi,
Thanks all people! It was a very interesting experience for me and a
very good moment. I hope that we will do again in the near future.
As a record for the next time, let me mention two points that help:
1. Demos! It seems very helpful to have both: Guix System and Guix on
foreign distro. Depending on the people, some are interested by one
or the other. Mainly, what mark points (main selling arguments ;-))
Guix on foreign distro:
a) do not interact with foreign distro
=> good complement and rolling release
b) containerized shell
=> please developers
Guix System:
a) roll-back
b) transactional
c) roll-back at GRUB level
2. An explanation about what makes Guix different compared to X
where X is:
i) classical distro as Arch, Gentoo, Debian, etc.
ii) Nix and NixOS
Sadly, we do not have a clear story for ii) IMHO.
Well, from my point of view, the main difference is the continuous*
approach of Guix – the same “language“ from declaring packages or OS
configuration to Guix core; except the daemon, another story. ;-) Well,
that “language” allows to implement a powerful solution as G-expression
tackling, among other things, string interpolation.
It could be nice if we could collectively draft a short FAQ about what
Guix is and Guix is not, answering such common questions.
Cheers,
simon
*continuous approach: The Emacs Thesis :-)
----------------------
The story of Guile is the story of bringing the development experience
of Emacs to the mass of programs on a GNU system.
Emacs, when it was first created in its GNU form in 1984, was a new
take on the problem of “how to make a program”. The Emacs thesis is
that it is delightful to create composite programs based on an
orthogonal kernel written in a low-level language together with a
powerful, high-level extension language.
Extension languages foster extensible programs, programs which adapt
readily to different users and to changing times. Proof of this can be
seen in Emacs’ current and continued existence, spanning more than a
quarter-century.
Besides providing for modification of a program by others, extension
languages are good for _intension_ as well. Programs built in “the
Emacs way” are pleasurable and easy for their authors to flesh out with
the features that they need.
After the Emacs experience was appreciated more widely, a number of
hackers started to consider how to spread this experience to the rest of
the GNU system. It was clear that the easiest way to Emacsify a program
would be to embed a shared language implementation into it.
