Zen

Translation

follow the coding style (@pxref{Coding Stylea manifest (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual}),;
English type: itemize
a manifest (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual});
86/740 · 74

Sign in to save translations.

English Slovak Actions
without having to specify the path to a profile.
bez nutnosti uvádzať cestu k profilu.
Manifests let you @dfn{declare} the set of packages you'd like to have in a profile (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual}). They are a convenient way to keep your package lists around and, say, to synchronize them across multiple machines using a version control system.
Balíkospisy sú šikovným spôsobom ako ukladať vaše zoznamy balíkov a udržiavať ich zosúladené naprieč viacerými počítačmi pomocou systému na správu verzií.
A common complaint about manifests is that they can be slow to install when they contain large number of packages. This is especially cumbersome when you just want get an upgrade for one package within a big manifest.
Medzi časté sťažnosti používateľov patrí, že inštalácia balíkospisov obsahujúcich veľké množstvo balíkov môže trvať veľmi dlho. Je to otravné hlavne vtedy, keď potrebujete aktualizovať iba jeden balík vrámci dlhého balíkospisu.
This is one more reason to use multiple profiles, which happen to be just perfect to break down manifests into multiple sets of semantically connected packages. Using multiple, small profiles provides more flexibility and usability.
Je to ďalší dôvod pre používanie viacerých profilov, čo umožňuje rozdelenie balíkospisov do viacerých množín významovo prepojených balíkov. Používanie viacerých, menších profilov tiež vedie k väčšej prispôsobiteľnosti a pohodlnejšej práci.
Manifests come with multiple benefits. In particular, they ease maintenance:
Balíkospisy prinášajú mnoho výhod. Predovšetkým, zjednodušujú údržbu:
When a profile is set up from a manifest, the manifest itself is self-sufficient to keep a ``package listing'' around and reinstall the profile later or on a different system. For ad-hoc profiles, we would need to generate a manifest specification manually and maintain the package versions for the packages that don't use the default version.
Pri nastavení profilu z balíkospisu, on samotný stačí na uschovanie zoznamu balíkov poruke a na opätovnú inštaláciu profilu niekedy inokedy alebo na inom systéme. V prípade dočasných účelových profilov by sme museli vytvoriť zadanie balíkospisu ručne a udržiavať správne verzie tých balíkov, pri ktorých nebola použitá ich predvolená verzia.
@code{guix package --upgrade} always tries to update the packages that have propagated inputs, even if there is nothing to do. Guix manifests remove this problem.
@code{guix package --upgrade} sa pokúša o aktualizáciu balíkov s rozšírenými vstupmi aj vtedy, keď to nie je potrebné. Guixové balíkospisy touto nevýhodou netrpia.
When partially upgrading a profile, conflicts may arise (due to diverging dependencies between the updated and the non-updated packages) and they can be annoying to resolve manually. Manifests remove this problem altogether since all packages are always upgraded at once.
Pri čiastočnej aktualizácii profilu sa môžu vyskytnúť rozpory (kvôli rozličným závislostiam medzi aktualizovanými a neaktualizovanými balíkmi), ktoré je obvykle náročné vyriešiť ručne. Pri balíkospisoch k tomu nedochádza, keďže všetky balíky sa aktualizujú súčasne.
As mentioned above, manifests allow for reproducible profiles, while the imperative @code{guix install}, @code{guix upgrade}, etc. do not, since they produce different profiles every time even when they hold the same packages. See @uref{https://issues.guix.gnu.org/issue/33285, the related discussion on the matter}.
Ako už bolo spomenuté, balíkospisy umožňujú napodobniteľné profily, zatiaľčo príkazy @code{guix install}, @code{guix upgrade}, a pod. nie, pretože zakaždým vytvárajú nové profily, aj keď obsahujú rovnaké balíky. Viď @uref{https://issues.guix.gnu.org/issue/33285, súvisiacu rozpravu}.
Manifest specifications are usable by other @samp{guix} commands. For example, you can run @code{guix weather -m manifest.scm} to see how many substitutes are available, which can help you decide whether you want to try upgrading today or wait a while. Another example: you can run @code{guix pack -m manifest.scm} to create a pack containing all the packages in the manifest (and their transitive references).
Zadania balíkospisov môžu využiť aj iné príkazy @samp{guix}. Napríklad, pomocou @code{guix weather -m balikospis.scm} môžete zistiť dostupné množstvo náhrad a lepšie sa rozhodnúť, či chcete vykonať aktualizáciu už dnes, alebo chvíľu počkáte. Ďalší príklad: @code{guix pack -m balikospis.scm} vám umožní vytvoriť súpravu obsahujúcu všetky balíky balíkospisu (a ich závislosti).
Finally, manifests have a Scheme representation, the @samp{<manifest>} record type. They can be manipulated in Scheme and passed to the various Guix @uref{https://en.wikipedia.org/wiki/Api, APIs}.
Nakoniec, balíkospisy sú zapísané v jazyku Scheme, ako záznamy druhu @samp{<manifest>}. Možno s nimi, teda, v Scheme aj narábať a používať ich s rozličnými @uref{https://sk.wikipedia.org/wiki/Application_programming_interface, API} Guixu.
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.
Je dôležité si uvedomiť, že aj keď balíkospisy možno použiť na zadávanie profilov, tieto dva pojmy si nie sú úplne rovné: vedľajším účinkom profilov je, že „pripínajú“ balíky k úložisku, čo zabraňuje ich vyčisteniu zberačom odpadkov (@pxref{Invoking guix gc,,, guix, GNU Guix Reference Manual}) a zaisťuje, že do budúcnosti zostanú dostupné.
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.
Zostavovaniu by sme sa ale radšej vyhli. To samozrejme môžeme. Jediné, čo musíme urobiť je nainštalovať balíkospis do nejakého profilu a použiť @code{GUIX_PROFILE=/ten/profil; . "$GUIX_PROFILE"/etc/profile} ako sme si už predtým vysvetlili. Takto zabezpečíme, že naše vývojové prostredie budeme mať vždy poruke.
@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.
@emph{Bezpečnostné upozornenie:} Napriek tomu, že je uchovávanie starých profilov šikovné, zapamätajte si, že zastarané balíky nemusia obsahovať najnovšie bezpečnostné záplaty.
To reproduce a profile bit-for-bit, we need two pieces of information:
Napodobnenie profilu bit-po-bite vyžaduje dva údaje:
a manifest (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual});
dodržiavať spôsob kódovania (@pxref{Coding Style,,, guix, GNU Guix Reference Manual}),
a Guix channel specification (@pxref{Replicating Guix,,, guix, GNU Guix Reference Manual}).
a prejsť si kontrolný zoznam z príručky (@pxref{Submitting Patches,,, 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.
Vskutku, samotný balíkospis nestačí: rozdielne verzie Guixu (alebo rozdielne kanály) môžu viesť k odlišných výsledkom pre daný balíkospis.
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}.
Určenie kanálov môžete získať pomocou @samp{guix describe --format=channels}. Výsledok uložte do súboru, napr. do @samp{urcenie-kanalov.scm}.
On another computer, you can use the channel specification file and the manifest to reproduce the exact same profile:
Na inom počítači môžete toto určenie kanálov spolu s balíkospisom použiť na napodobnenie presne toho istého profilu:
GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
GUIX_EXTRA=$HOME/.guix-extra

GUIX_DOPLNKOVE_PROFILY=$HOME/.guix-doplnkove-profily
GUIX_DOPLNKY=$HOME/.guix-doplnky

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

mkdir -p "$GUIX_DOPLNKY"/moj-projekt
guix pull --channels=urcenie-kanalov.scm --profile="$GUIX_DOPLNKY/moj-projekt/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
mkdir -p "$GUIX_DOPLNKOVE_PROFILY/moj-projekt"
"$GUIX_DOPLNKY"/moj-projekt/guix/bin/guix package \
--manifest=/cesta/ku/guix-balikospis-mojho-projektu.scm \
--profile="$GUIX_DOPLNKOVE_PROFILY"/moj-projekt/moj-projekt
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.
Profil kanálu Guix, ktorý ste práve nainštalovali môžete bezpečne odstrániť, profil projektu na ňom nezávisí.
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))

 

Loading…

User avatar None

String updated in the repository
a manifest (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual});
dodržiavať spôsob kódovania (@pxref{Coding Style,,, guix, GNU Guix Reference Manual}),
a year ago
User avatar None

Source string changed
follow the coding style (@pxref{Coding Stylea manifest (@pxref{Writing Manifests,,, guix, GNU Guix Reference Manual}),;
a year ago
Browse all string changes

Things to check

Mismatched semicolon

Source and translation do not both end with a semicolon.

Reset

Glossary

English Slovak
GNU Guix guix Glossary
Guix Guix guix Glossary
manifest balíkospis guix Glossary

Osobitne zvolený výraz vo vzťahu ku Guixu.

15283930 String information

Source string description
type: itemize
Source string location
guix-git/doc/guix-cookbook.texi:4471
String age
a year ago
Last updated
2 weeks ago
Source string age
a year ago
Translation file
po/doc/guix-cookbook.sk.po, string 956