Zen

Source string Source string

589/10000 · 589

The string is read only.

English Actions
It's important to understand that while manifests can be used to declare profiles, they are not strictly equivalent: profiles have the side effect that they ``pin'' packages in the store, which prevents them from being garbage-collected (@pxref{Invoking guix gc,,, guix, GNU Guix Reference Manual}) and ensures that they will still be available at any point in the future. The @command{guix shell} command also protects recently-used profiles from garbage collection; profiles that have not been used for a while may be garbage-collected though, along with the packages they refer to.
To be 100% sure that a given profile will never be collected, install the manifest to a profile and use @code{GUIX_PROFILE=/the/profile; . "$GUIX_PROFILE"/etc/profile} as explained above: this guarantees that our hacking environment will be available at all times.
@emph{Security warning:} While keeping old profiles around can be convenient, keep in mind that outdated packages may not have received the latest security fixes.
To reproduce a profile bit-for-bit, we need two pieces of information:
a manifest (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual});
a Guix channel specification (@pxref{Replicating Guix,,, guix, GNU Guix Reference Manual}).
Indeed, manifests alone might not be enough: different Guix versions (or different channels) can produce different outputs for a given manifest.
You can output the Guix channel specification with @samp{guix describe --format=channels} (@pxref{Invoking guix describe,,, guix, GNU Guix Reference Manual}). Save this to a file, say @samp{channel-specs.scm}.
On another computer, you can use the channel specification file and the manifest to reproduce the exact same profile:
GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
GUIX_EXTRA=$HOME/.guix-extra

mkdir -p "$GUIX_EXTRA"/my-project
guix pull --channels=channel-specs.scm --profile="$GUIX_EXTRA/my-project/guix"

mkdir -p "$GUIX_EXTRA_PROFILES/my-project"
"$GUIX_EXTRA"/my-project/guix/bin/guix package \
--manifest=/path/to/guix-my-project-manifest.scm \
--profile="$GUIX_EXTRA_PROFILES"/my-project/my-project
It's safe to delete the Guix channel profile you've just installed with the channel specification, the project profile does not depend on it.
development, with Guix
software development, with Guix
Guix is a handy tool for developers; @command{guix shell}, in particular, gives a standalone development environment for your package, no matter what language(s) it's written in (@pxref{Invoking guix shell,,, guix, GNU Guix Reference Manual}). To benefit from it, you have to initially write a package definition and have it either in Guix proper, or in a channel, or directly in your project's source tree as a @file{guix.scm} file. This last option is appealing: all developers have to do to get set up is clone the project's repository and run @command{guix shell}, with no arguments.
Development needs go beyond development environments though. How can developers perform continuous integration of their code in Guix build environments? How can they deliver their code straight to adventurous users? This chapter describes a set of files developers can add to their repository to set up Guix-based development environments, continuous integration, and continuous delivery---all at once@footnote{This chapter is adapted from a @uref{https://guix.gnu.org/en/blog/2023/from-development-environments-to-continuous-integrationthe-ultimate-guide-to-software-development-with-guix/, blog post} published in June 2023 on the Guix web site.}.
How do we go about ``Guixifying'' a repository? The first step, as we've seen, will be to add a @file{guix.scm} at the root of the repository in question. We'll take @uref{https://www.gnu.org/software/guile,Guile} as an example in this chapter: it's written in Scheme (mostly) and C, and has a number of dependencies---a C compilation tool chain, C libraries, Autoconf and its friends, LaTeX, and so on. The resulting @file{guix.scm} looks like the usual package definition (@pxref{Defining Packages,,, guix, GNU Guix Reference Manual}), just without the @code{define-public} bit:
;; The ‘guix.scm’ file for Guile, for use by ‘guix shell’.

(use-modules (guix)
(guix build-system gnu)
((guix licenses) #:prefix license:)
(gnu packages autotools)
(gnu packages base)
(gnu packages bash)
(gnu packages bdw-gc)
(gnu packages compression)
(gnu packages flex)
(gnu packages gdb)
(gnu packages gettext)
(gnu packages gperf)
(gnu packages libffi)
(gnu packages libunistring)
(gnu packages linux)
(gnu packages pkg-config)
(gnu packages readline)
(gnu packages tex)
(gnu packages texinfo)
(gnu packages version-control))

(package
(name "guile")
(version "3.0.99-git") ;funky version number
(source #f) ;no source
(build-system gnu-build-system)
(native-inputs
(append (list autoconf
automake
libtool
gnu-gettext
flex
texinfo
texlive-base ;for "make pdf"
texlive-epsf
gperf
git
gdb
strace
readline
lzip
pkg-config)

;; When cross-compiling, a native version of Guile itself is
;; needed.
(if (%current-target-system)
(list this-package)
'())))
(inputs
(list libffi bash-minimal))
(propagated-inputs
(list libunistring libgc))

(native-search-paths
(list (search-path-specification
(variable "GUILE_LOAD_PATH")
(files '("share/guile/site/3.0")))
(search-path-specification
(variable "GUILE_LOAD_COMPILED_PATH")
(files '("lib/guile/3.0/site-ccache")))))
(synopsis "Scheme implementation intended especially for extensions")
(description
"Guile is the GNU Ubiquitous Intelligent Language for Extensions,
and it's actually a full-blown Scheme implementation!")
(home-page "https://www.gnu.org/software/guile/")
(license license:lgpl3+))
Quite a bit of boilerplate, but now someone who'd like to hack on Guile now only needs to run:
guix shell
That gives them a shell containing all the dependencies of Guile: those listed above, but also @emph{implicit dependencies} such as the GCC tool chain, GNU@ Make, sed, grep, and so on. @xref{Invoking guix shell,,, guix, GNU Guix Reference Manual}, for more info on @command{guix shell}.
The chef's recommendation
Our suggestion is to create development environments like this:
guix shell --container --link-profile
... or, for short:
guix shell -CP

Loading…

User avatar None

String updated in the repository
Guix is a handy tool for developers; @command{guix shell}, in particular, gives a standalone development environment for your package, no matter what language(s) it's written in (@pxref{Invoking guix shell,,, guix, GNU Guix Reference Manual}). To benefit from it, you have to initially write a package definition and have it either in Guix proper, or in a channel, or directly in your project's source tree as a @file{guix.scm} file. This last option is appealing: all developers have to do to get set up is clone the project's repository and run @command{guix shell}, with no arguments.
Guix is a handy tool for developers; @command{guix shell}, in particular, gives a standalone development environment for your package, no matter what language(s) it's written in (@pxref{Invoking guix shell,,, guix, GNU Guix Reference Manual}). To benefit from it, you have to initially write a package definition and have it either in Guix proper, or in a channel, or directly in your project's source tree as a @file{guix.scm} file. This last option is appealing: all developers have to do to get set up is clone the project's repository and run @command{guix shell}, with no arguments.
a year ago
Browse all string changes

Things to check

Unpluralised

The string is used as plural, but not using plural forms

Reset

Glossary

English English
No related strings found in the glossary.

15275363 String information

Source string description
type: Plain text
Flags
read-only
Source string location
guix-git/doc/guix-cookbook.texi:4385
String age
a year ago
Last updated
yesterday
Source string age
a year ago
Translation file
po/doc/guix-cookbook.pot, string 946