guix manual checkout - en to sk translation catalogue (311 entries)

note: type: Plain text
en: @documentencoding UTF-8
sk: @documentencoding UTF-8
    @documentlanguage sk

note: type: top
en: GNU Guix Cookbook
sk: Receptár GNU Guix

note: type: copying
en: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A copy of the license is included in the section entitled ``GNU Free Documentation License''.
sk: Tento dokument môžete kopírovať, ďalej šíriť a/alebo upravovať pod podmienkami licencie GNU Free Documentation License vo verzii 1.3 alebo v akejkoľvek novšej verzii, ktorú vydáva Free Software Foundation; bez nemenných oddielov, úvodnej strany a propagačného textu.  Kópia tejto licencie je priložená v oddiele „GNU Free Documentation License“.

note: type: dircategory
en: System administration
sk: Správa systému

note: type: menuentry
en: Guix cookbook: (guix-cookbook)
sk: Receptár Guix: (guix-cookbook)

note: type: menuentry
en: Tutorials and examples for GNU Guix.
sk: Návody a príklady GNU Guix.

note: type: subtitle
en: Tutorials and examples for using the GNU Guix Functional Package Manager
sk: Návody na používanie funkcionálneho správcu balíkov GNU Guix a príklady z praxe

note: type: author
en: The GNU Guix Developers
sk: Vývojári GNU Guix

note: type: Plain text
en: This document presents tutorials and detailed examples for GNU@tie{}Guix, a functional package management tool written for the GNU system.  Please @pxref{Top,,, guix, GNU Guix reference manual} for details about the system, its API, and related concepts.
sk: Tento dokument obsahuje návody a podrobné príklady použitia GNU@tie{}Guix, funkcionálneho správcu balíkov napísaného pre systém GNU.  Získajte viac podrobností o systéme, jeho API a súvisiacich pojmoch v @pxref{Top,,, guix, GNU Guix reference manual}.

note: You can replace the following paragraph with information on type: Plain text
en: This manual is also available in French (@pxref{Top,,, guix-cookbook.fr, Livre de recettes de GNU Guix}) and German (@pxref{Top,,, guix-cookbook.de, GNU-Guix-Kochbuch}).  If you would like to translate this document in your native language, consider joining @uref{https://translate.fedoraproject.org/projects/guix/documentation-cookbook, Weblate} (@pxref{Translating Guix,,, guix, GNU Guix reference manual}).
sk: Táto príručka je dostupná aj v angličtine (@pxref{Top,,, guix-cookbook, GNU Guix Cookbook}), francúzštine (@pxref{Top,,, guix-cookbook.fr, Livre de recettes de GNU Guix}) a nemčine (@pxref{Top,,, guix-cookbook.de, GNU-Guix-Kochbuch}).  Ak chcete pomôcť s prekladom tohto dokumentu do vášho rodného jazyka, pripojte sa k @uref{https://translate.fedoraproject.org/projects/guix/documentation-cookbook, Weblate} (@pxref{Translating Guix,,, guix, GNU Guix reference manual}).

note: type: chapter
en: Scheme tutorials
sk: Návody na Scheme

note: type: menuentry
en: Meet your new favorite language!
sk: Zoznámte sa s vašim novým najobľúbenejším jazykom!

note: type: chapter
en: Packaging
sk: Zadávanie balíkov

note: type: menuentry
en: Packaging tutorials
sk: Návody na zadávanie balíkov

note: type: chapter
en: System Configuration
sk: Nastavenie systému

note: type: menuentry
en: Customizing the GNU System
sk: Prispôsobenie systému GNU

note: type: chapter
en: Advanced package management
sk: Pokročilá správa balíkov

note: type: menuentry
en: Power to the users!
sk: Moc pre používateľov!

note: type: chapter
en: Environment management
sk: Správa prostredí

note: type: menuentry
en: Control environment
sk: Kontrolné prostredie

note: type: chapter
en: Acknowledgments
sk: Poďakovanie

note: type: menuentry
en: Thanks!
sk: Ďakujeme!

note: type: appendix
en: GNU Free Documentation License
sk: Licencia GNU Free Documentation

note: type: menuentry
en: The license of this document.
sk: Licencia, ktorej podlieha tento dokument.

note: type: unnumbered
en: Concept Index
sk: Zoznam pojmov

note: type: menuentry
en: Concepts.
sk: Pojmy.

note: type: menuentry
en: --- The Detailed Node Listing ---
sk: --- Podrobný zoznam uzlov ---

note: type: section
en: A Scheme Crash Course
sk: Zrýchlené školenie jazyka Scheme

note: type: menuentry
en: Learn the basics of Scheme
sk: Naučte sa základy jazyka Scheme

note: type: section
en: Packaging Tutorial
sk: Návod na zadávanie balíkov

note: type: menuentry
en: Let's add a package to Guix!
sk: Pridajme do Guixu nejaký balík!

note: type: section
en: Auto-Login to a Specific TTY
sk: Automatické pripojenie k určitému TTY

note: type: menuentry
en: Automatically Login a User to a Specific TTY
sk: Automaticky pripojiť používateľa k určitému TTY

note: type: section
en: Customizing the Kernel
sk: Prispôsobenie jadra

note: type: menuentry
en: Creating and using a custom Linux kernel on Guix System.
sk: Vytvorenie a používanie vlastného Linuxového jadra v systéme Guix.

note: type: section
en: Guix System Image API
sk: API pre vytváranie obrazov systému Guix

note: type: menuentry
en: Customizing images to target specific platforms.
sk: Prispôsobenie obrazov nezvyčajným platformám.

note: type: section
en: Connecting to Wireguard VPN
sk: Pripojenie k Wireguard VPN

note: type: menuentry
en: Connecting to a Wireguard VPN.
sk: Pripojenie k Wireguard VPN sieti.

note: type: section
en: Customizing a Window Manager
sk: Prispôsobenie správcu okien

note: type: menuentry
en: Handle customization of a Window manager on Guix System.
sk: Spravovať prispôsobenie správcu okien v systéme Guix.

note: type: section
en: Running Guix on a Linode Server
sk: Spúšťanie Guixu na serveri Linode

note: type: section
en: Setting up a bind mount
sk: Nastavenie podvojného pripojenia

note: type: menuentry
en: Setting up a bind mount in the file-systems definition.
sk: Nastavenie podvojného pripojenia v zadaní systému súborov.

note: type: section
en: Getting substitutes from Tor
sk: Získavanie náhrad prostredníctvom Tor

note: type: menuentry
en: Configuring Guix daemon to get substitutes through Tor.
sk: Nastavenie démona Guix na získavanie náhrad cez Tor.

note: type: section
en: Setting up NGINX with Lua
sk: Nastavenia NGINX a Lua

note: type: menuentry
en: Configuring NGINX web-server to load Lua modules.
sk: Nastavenie web-servera NGINX na načítavanie Lua modulov.

note: type: Plain text
en: GNU@tie{}Guix is written in the general purpose programming language Scheme, and many of its features can be accessed and manipulated programmatically.  You can use Scheme to generate package definitions, to modify them, to build them, to deploy whole operating systems, etc.
sk: GNU@tie{}Guix je zapísaný v programovacom jazyku Scheme. K mnohým jeho súčastiam je možné pristupovať a upravovať ich prostredníctvom programovania.  Pomocou jazyka Scheme môžete zadávať, upravovať a zostavovať balíky, nasadzovať celé operačné systémy, atď.

note: type: Plain text
en: Knowing the basics of how to program in Scheme will unlock many of the advanced features Guix provides --- and you don't even need to be an experienced programmer to use them!
sk: Poznať základy programovania v jazyku Scheme vám otvorí dvere k množstvu pokročilých súčastí, ktoré Guix ponúka --- a to ani nemusíte byť skúseným vývojárom, aby ste ich mohli využívať!

note: type: Plain text
en: Let's get started!
sk: Poďme na to!

note: type: cindex
en: Scheme, crash course
sk: Scheme, rýchlokurz

note: type: Plain text
en: Guix uses the Guile implementation of Scheme.  To start playing with the language, install it with @code{guix install guile} and start a @dfn{REPL}---short for @uref{https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop, @dfn{read-eval-print loop}}---by running @code{guile} from the command line.
sk: Guix používa Guile implementáciu jazyka Scheme. Ak si chcete tento jazyk vyskúšať, nainštalujte si Guile pomocou @code{guix install guile} a spustite @dfn{REPL}, tzv. @uref{https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop, @dfn{slučku čítaj-vykonaj-zobraz}}, zadaním @code{guile} v príkazovom riadku.

note: type: Plain text
en: In the following examples, lines show what you would type at the REPL; lines starting with ``@result{}'' show evaluation results, while lines starting with ``@print{}'' show things that get printed.  @xref{Using Guile Interactively,,, guile, GNU Guile Reference Manual}, for more details on the REPL.
sk: Riadky v nasledovných príkladoch znázorňujú to, čo treba zadať v rámci REPL; riadky začínajúce na „@result{}“ znázorňujú výsledok vykonania príkazu, zatiaľ čo riadky začínajúce na „@print{}“ znázorňujú to čo sa zobrazí na obrazovke. @xref{Using Guile Interactively,,, guile, GNU Guile Reference Manual}, pre viac podrobností o REPL.

note: type: itemize
en: Scheme syntax boils down to a tree of expressions (or @emph{s-expression} in Lisp lingo).  An expression can be a literal such as numbers and strings, or a compound which is a parenthesized list of compounds and literals.  @code{#true} and @code{#false} (abbreviated @code{#t} and @code{#f}) stand for the Booleans ``true'' and ``false'', respectively.
sk: Skladbu jazyka Scheme si možno predstaviť ako strom výrazov (alebo ako @emph{s-expression} v jazyku Lisp). Výrazom môže byť priama konštanta, napr. číselná hodnota či reťazec znakov, alebo môže predstavovať zoznam iných zložených prvkov a priamych konštánt ohraničený v zátvorkách. @code{#true} a @code{#false} (skrátene @code{#t} a @code{#f}) znázorňujú logické hodnoty „pravda“ a „nepravda“.

note: type: itemize
en: Examples of valid expressions:
sk: Príklady platných výrazov:

note: type: lisp
en: "Hello World!"
    @result{} "Hello World!"
sk: "Ahoj svet!"
    @result{} "Ahoj svet!"

note: type: lisp
en: (display (string-append "Hello " "Guix" "\n"))
    @print{} Hello Guix!
    @result{} #<unspecified>
sk: (display (string-append "Ahoj " "Guix" "\n"))
    @print{} Ahoj Guix!
    @result{} #<unspecified>

note: type: itemize
en: This last example is a function call nested in another function call.  When a parenthesized expression is evaluated, the first term is the function and the rest are the arguments passed to the function.  Every function returns the last evaluated expression as its return value.
sk: Tento posledný príklad znázorňuje volanie funkcie vnorené do iného volania funkcie. Pri vykonávaní výrazu v zátvorkách predstavuje prvá položka funkciu a zvyšok sú parametre volania. Návratová hodnota každej funkcie je výsledok vykonania posledného výrazu v nej.

note: type: itemize
en: Anonymous functions are declared with the @code{lambda} term:
sk: Bezmenné funkcie možno zadávať pomocou slova @code{lambda}:

note: type: itemize
en: The above procedure returns the square of its argument.  Since everything is an expression, the @code{lambda} expression returns an anonymous procedure, which can in turn be applied to an argument:
sk: Vyššie uvedená funkcia vracia druhú mocninu hodnoty jej parametra. Keďže všetko sa považuje za výraz, aj výraz @code{lambda} vracia bezmennú funkciu, ktorú je následne možné uplatniť na nejaký parameter:

note: type: itemize
en: Anything can be assigned a global name with @code{define}:
sk: Všetkému je možné prideliť globálny názov pomocou @code{define}:

note: type: lisp
en: (define a 3)
    (define square (lambda (x) (* x x)))
    (square a)
    @result{} 9
sk: (define a 3)
    (define druha-mocnina (lambda (x) (* x x)))
    (druha-mocnina a)
    @result{} 9

note: type: itemize
en: Procedures can be defined more concisely with the following syntax:
sk: Funkcie možno zadávať aj v kratšom tvare s použitím nasledovnej skladby:

note: type: lisp
en: (define (square x) (* x x))
sk: (define (druha-mocnina x) (* x x))

note: type: itemize
en: A list structure can be created with the @code{list} procedure:
sk: Zoznam je možné vytvoriť pomocou funkcie @code{list}:

note: type: itemize
en: The @dfn{quote} disables evaluation of a parenthesized expression: the first term is not called over the other terms (@pxref{Expression Syntax, quote,, guile, GNU Guile Reference Manual}).  Thus it effectively returns a list of terms.
sk: @dfn{quote} (jednoduchá úvodzkovka) zabraňuje vykonaniu výrazu v zátvorkách: prvá položka sa nevykoná ako volanie funkcie s ostatnými položkami ako parametrami (@pxref{Expression Syntax, quote,, guile, GNU Guile Reference Manual}). Výsledkom je teda zoznam výrazov.

note: type: lisp
en: '(display (string-append "Hello " "Guix" "\n"))
    @result{} (display (string-append "Hello " "Guix" "\n"))
sk: '(display (string-append "Ahoj " "Guix" "\n"))
    @result{} (display (string-append "Ahoj " "Guix" "\n"))

note: type: itemize
en: The @dfn{quasiquote} disables evaluation of a parenthesized expression until @dfn{unquote} (a comma) re-enables it.  Thus it provides us with fine-grained control over what is evaluated and what is not.
sk: @dfn{quasiquote} (obrátená jednoduchá úvodzovka) zabraňuje vykonaniu výrazu v zátvorke dovtedy, kým nie je jeho vykonanie opätovne povolené pomocou @dfn{unquote} (čiarky). Týmto spôsobom si zachovávame kontrolu nad tým, čo sa vykoná a čo nie.

note: type: itemize
en: Note that the above result is a list of mixed elements: numbers, symbols (here @code{a}) and the last element is a list itself.
sk: Všimnite si, že hore uvedený výsledok je zoznam rôznorodých položiek: čísel, znakov (@code{a}) a posledná položka je tiež zoznam.

note: type: itemize
en: Multiple variables can be named locally with @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}):
sk: Pomocou @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}) môžeme zadať a pomenovať viacero miestnych premenných:

note: type: itemize
en: Use @code{let*} to allow later variable declarations to refer to earlier definitions.
sk: Ak chcete, aby bolo možné v neskorších zadaniach premenných odkazovať na predtým zadané premenné, použite @code{let*}.

note: type: itemize
en: @dfn{Keywords} are typically used to identify the named parameters of a procedure.  They are prefixed by @code{#:} (hash, colon) followed by alphanumeric characters: @code{#:like-this}.  @xref{Keywords,,, guile, GNU Guile Reference Manual}.
sk: @dfn{Kľúčové slová} sa bežne používajú na stotožnenie pomenovaných parametrov funkcie. Začínajú sa @code{#:} (mriežkou a dvojbodkou), po ktorých nasledujú písmenové či číselné znaky: @code{#:takto}. @xref{Keywords,,, guile, GNU Guile Reference Manual}.

note: type: itemize
en: The percentage @code{%} is typically used for read-only global variables in the build stage.  Note that it is merely a convention, like @code{_} in C.  Scheme treats @code{%} exactly the same as any other letter.
sk: Znak percento @code{%} je bežne používaný pre globálne premenné s prístupom len na čítanie počas zostavovania. Všimnite si, že je to len všeobecným zvykom, ako napr. @code{_} v jazyku C. Scheme spracúva  @code{%} ako hocijaký iný znak.

note: type: itemize
en: Modules are created with @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}).  For instance
sk: Moduly sa vytvárajú pomocou @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). Napríklad

note: type: itemize
en: defines the module @code{guix build-system ruby} which must be located in @file{guix/build-system/ruby.scm} somewhere in the Guile load path.  It depends on the @code{(guix store)} module and it exports two variables, @code{ruby-build} and @code{ruby-build-system}.
sk: určuje modul @code{guix build-system ruby}, ktorý má byť umiestnený v @file{guix/build-system/ruby.scm} niekde vo vyhľadávacej ceste Guilu. Závisí na module @code{(guix store)} a určuje dve premenné, @code{ruby-build} a @code{ruby-build-system}.

note: type: quotation
en: You'll find more books, tutorials and other resources at @url{https://schemers.org/}.
sk: Ďalšie knihy, návody ako aj iné druhy zdrojov nájdete na @url{https://schemers.org/}.

note: type: cindex
en: packaging
sk: zadávanie balíkov

note: type: Plain text
en: This chapter is dedicated to teaching you how to add packages to the collection of packages that come with GNU Guix.  This involves writing package definitions in Guile Scheme, organizing them in package modules, and building them.
sk: Tento oddiel je zameraný na pridávanie nových balíkov do zbierky balíkov GNU Guix, čo zahŕňa zadávanie balíkov v Guile Scheme, ich usporadúvanie do modulov a zostavovanie.

note: type: menuentry
en: A tutorial on how to add packages to Guix.
sk: Návod na pridávanie balíkov do Guixu.

note: type: Plain text
en: GNU Guix stands out as the @emph{hackable} package manager, mostly because it uses @uref{https://www.gnu.org/software/guile/, GNU Guile}, a powerful high-level programming language, one of the @uref{https://en.wikipedia.org/wiki/Scheme_%28programming_language%29, Scheme} dialects from the @uref{https://en.wikipedia.org/wiki/Lisp_%28programming_language%29, Lisp family}.
sk: GNU Guix sa vyznačuje ako @emph{prispôsobiteľný} správca balíkov hlavne preto, že používa @uref{https://www.gnu.org/software/guile/, GNU Guile}, výkonný vysokoúrovňový programovací jazyk, jedno z nárečí jazyka @uref{https://en.wikipedia.org/wiki/Scheme_%28programming_language%29, Scheme} z jazykovej rodiny @uref{https://en.wikipedia.org/wiki/Lisp_%28programming_language%29, Lispu}.

note: type: Plain text
en: Package definitions are also written in Scheme, which empowers Guix in some very unique ways, unlike most other package managers that use shell scripts or simple languages.
sk: Zadania balíkov sú rovnako písané v jazyku Scheme, čo dáva Guixu jedinečnú výhodu v porovnaní s ostatnými správcami balíkov, ktoré používajú skripty shellu alebo jednoduché programovacie jazyky.

note: type: itemize
en: Use functions, structures, macros and all of Scheme expressiveness for your package definitions.
sk: Vo vašich zadaniach balíkov môžete využiť funkcie, štruktúry, makrá a všetku schopnosť vyjadrovania jazyka Scheme.

note: type: itemize
en: Inheritance makes it easy to customize a package by inheriting from it and modifying only what is needed.
sk: Dedičnosť zjednodušuje prispôsobovanie balíka tým, že umožňuje zdediť vybraný jestvujúci balík a upraviť len to čo je potrebné.

note: type: itemize
en: Batch processing: the whole package collection can be parsed, filtered and processed.  Building a headless server with all graphical interfaces stripped out? It's possible.  Want to rebuild everything from source using specific compiler optimization flags? Pass the @code{#:make-flags "..."} argument to the list of packages.  It wouldn't be a stretch to think @uref{https://wiki.gentoo.org/wiki/USE_flag, Gentoo USE flags} here, but this goes even further: the changes don't have to be thought out beforehand by the packager, they can be @emph{programmed} by the user!
sk: Dávkové spracovanie: celú zbierku balíkov je možné načítať, prefiltrovať a spracovať. Potrebujete zostaviť server bez grafického rozhrania? Dá sa to. Potrebujete opätovne zostaviť všetko zo zdrojových súborov s použitím odlišných optimalizačných príznakov? Pridajte parameter @code{#:make-flags "..."} do zoznamu balíkov. Tiež by nebolo od veci spomenúť @uref{https://wiki.gentoo.org/wiki/USE_flag, Gentoo príznak USE}, ale to je na dlhšie: tvorca balíkov nemusí vopred myslieť na tieto zmeny, pretože ich môže neskôr @emph{naprogramovať} koncový používateľ!

note: type: Plain text
en: The following tutorial covers all the basics around package creation with Guix.  It does not assume much knowledge of the Guix system nor of the Lisp language.  The reader is only expected to be familiar with the command line and to have some basic programming knowledge.
sk: Nasledovný návod vysvetľuje základy vytvárania balíkov s Guixom. Nepredpokladá žiadnu znalosť systému Guix ani jazyka Lisp. Čitateľ by však mal byť oboznámený s príkazovým riadkom a mať aspoň základnú znalosť programovania.

note: type: subsection
en: A ``Hello World'' package
sk: Balík „Vitaj svet“

note: type: Plain text
en: The ``Defining Packages'' section of the manual introduces the basics of Guix packaging (@pxref{Defining Packages,,, guix, GNU Guix Reference Manual}).  In the following section, we will partly go over those basics again.
sk: Oddiel „Zadávanie balíkov“ v príručke obsahuje základy tvorby balíkov s Guixom (@pxref{Defining Packages,,, guix, GNU Guix Reference Manual}). V nasledovnom oddieli si tieto základy z časti pripomenieme.

note: type: Plain text
en: GNU@tie{}Hello is a dummy project that serves as an idiomatic example for packaging.  It uses the GNU build system (@code{./configure && make && make install}).  Guix already provides a package definition which is a perfect example to start with.  You can look up its declaration with @code{guix edit hello} from the command line.  Let's see how it looks:
sk: GNU@tie{}Hello je šablóna projektu, ktorá slúži ako základný príklad zadávania balíkov. Využíva zostavovací systém GNU (@code{./configure && make && make install}). Guix už obsahuje zadanie príslušného balíka, ktoré predstavuje vhodný odrazový bod. Môžete si zadanie balíka prezrieť zadaním @code{guix edit hello} do príkazového riadku. Pozrime sa ako toto zadania balíka vyzerá:

note: type: Plain text
en: As you can see, most of it is rather straightforward.  But let's review the fields together:
sk: Ako môžete vidieť, tá najobsiahlejšia časť je dosť jednoduchá. Ale prejdime si spoločne jednotlivé polia:

note: type: table
en: The project name.  Using Scheme conventions, we prefer to keep it lower case, without underscore and using dash-separated words.
sk: Názov projektu. Podľa všeobecných zvyklostí ho zapisujeme malými písmenami, bez podčiarkovníkov a s použitím pomlčiek na oddelenie jednotlivých slov.

note: type: table
en: This field contains a description of the source code origin.  The @code{origin} record contains these fields:
sk: Toto pole obsahuje popis pôvodu zdrojového kódu. Záznam @code{origin} obsahuje tieto polia:

note: type: item
en: The method, here @code{url-fetch} to download via HTTP/FTP, but other methods
sk: Spôsob, v tomto prípade @code{url-fetch} pre stiahnutie prostredníctvom HTTP/FTP, ale poznáme

note: type: enumerate
en: exist, such as @code{git-fetch} for Git repositories.
sk: aj iné spôsoby, ako napr. @code{git-fetch} pre Git repozitáre.

note: type: item
en: The URI, which is typically some @code{https://} location for @code{url-fetch}.  Here
sk: Prepojenie (URI), čo obyčajne predstavuje nejaké umiestnenie @code{https://} pre @code{url-fetch}. V tomto prípade

note: type: enumerate
en: the special `mirror://gnu` refers to a set of well known locations, all of which can be used by Guix to fetch the source, should some of them fail.
sk: zvláštne „mirror://gnu“ odkazuje na súbor dobre známych umiestnení, ktoré môžu byť všetky použité na získanie zdrojového kódu ak by niektoré z nich nebolo dostupné.

note: type: item
en: The @code{sha256} checksum of the requested file.  This is essential to ensure
sk: Kontrolný súčet @code{sha256} požadovaného súboru. Je dôležitý pre zaistenie

note: type: enumerate
en: the source is not corrupted.  Note that Guix works with base32 strings, hence the call to the @code{base32} function.
sk: celistvosti zdroja. Všimnite si, že Guix pracuje z base32 reťazcami, čo vysvetľuje použitie funkcie @code{base32}.

note: type: table
en: This is where the power of abstraction provided by the Scheme language really shines: in this case, the @code{gnu-build-system} abstracts away the famous @code{./configure && make && make install} shell invocations.  Other build systems include the @code{trivial-build-system} which does not do anything and requires from the packager to program all the build steps, the @code{python-build-system}, the @code{emacs-build-system}, and many more (@pxref{Build Systems,,, guix, GNU Guix Reference Manual}).
sk: Práve tu má príležitosť zažiariť sila všeobecnosti jazyka Scheme: v tomto prípade, @code{gnu-build-system} je zovšeobecnenie známych príkazov shellu @code{./configure && make && make install}. Medzi ďalšie zostavovacie systémy patrí @code{trivial-build-system}, ktorý nerobí nič a necháva na programátorovi, aby zadal všetky potrebné kroky zostavenia, @code{python-build-system}, @code{emacs-build-system} a mnohé ďalšie (@pxref{Build Systems,,, guix, GNU Guix Reference Manual}).

note: type: table
en: It should be a concise summary of what the package does.  For many packages a tagline from the project's home page can be used as the synopsis.
sk: Toto by mal byť súhrnný popis toho, na čo balík slúži. Pri mnohých balíkoch je vhodné použiť slogan zo stránky príslušného projektu.

note: type: table
en: Same as for the synopsis, it's fine to re-use the project description from the homepage.  Note that Guix uses Texinfo syntax.
sk: Podobne ako v prípade súhrnného popisu je vhodné použiť popis projektu z jeho domovskej stránky. Všimnite si, že Guix používa značkovanie Texinfo.

note: type: table
en: Use HTTPS if available.
sk: Použitie HTTPS prepojenie, ak je dostupné.

note: type: table
en: See @code{guix/licenses.scm} in the project source for a full list of available licenses.
sk: Viď @code{guix/licenses.scm} v zdrojovom kóde projektu pre zoznam všetkých dostupných licencií.

note: type: Plain text
en: Time to build our first package! Nothing fancy here for now: we will stick to a dummy @code{my-hello}, a copy of the above declaration.
sk: Nastal čas na zostavenie nášho prvého balíka! Zatiaľ nič zvláštne: spoľahneme sa jednoducho na kópiu vyššie uvedeného zadania @code{my-hello}.

note: type: Plain text
en: As with the ritualistic ``Hello World'' taught with most programming languages, this will possibly be the most ``manual'' approach.  We will work out an ideal setup later; for now we will go the simplest route.
sk: Tak ako pri rituálnom „Ahoj svet“, ktorý sa vyučuje pri väčšine programovacích jazykov, toto bude ten „najručnejší“ spôsob zadávania balíka, ktorý použijete. Neskôr si ukážeme dokonalejší postup, no zatiaľ sa vyberieme tou najjednoduchšou cestou.

note: type: Plain text
en: Save the following to a file @file{my-hello.scm}.
sk: Uložte nasledujúci obsah do súboru s názvom @file{my-hello.scm}.

note: type: Plain text
en: We will explain the extra code in a moment.
sk: Dodatočné príkazy si vysvetlíme o chvíľu.

note: type: Plain text
en: Feel free to play with the different values of the various fields.  If you change the source, you'll need to update the checksum.  Indeed, Guix refuses to build anything if the given checksum does not match the computed checksum of the source code.  To obtain the correct checksum of the package declaration, we need to download the source, compute the sha256 checksum and convert it to base32.
sk: Neváhajte a vyskúšajte si, čo sa stane ak zmeníte hodnoty niektorých polí. Ak zmeníte zdroj balíka, budete musieť aktualizovať aj kontrolný súčet. Guix nezostaví nič ak daný kontrolný súčet neodpovedá kontrolnému súčtu zdrojového kódu. Pre získanie správneho kontrolného súčtu potrebujeme stiahnuť zdroj, vypočítať kontrolný súčet sha256 a previesť ho do base32.

note: type: Plain text
en: Thankfully, Guix can automate this task for us; all we need is to provide the URI:
sk: Našťastie, Guix to môže urobiť za nás; všetko čo budeme potrebovať je prepojenie (URI) zdroja:

note: type: Plain text
en: In this specific case the output tells us which mirror was chosen.  If the result of the above command is not the same as in the above snippet, update your @code{my-hello} declaration accordingly.
sk: V tomto konkrétnom prípade nám výstup hovorí, aké zrkadlo bolo vybraté. Ak výsledok tohto príkazu nie je rovnaký ako v predchádzajúcom úryvku, aktualizujte vaše zadanie @code{my-hello} podľa potreby.

note: type: Plain text
en: Note that GNU package tarballs come with an OpenPGP signature, so you should definitely check the signature of this tarball with `gpg` to authenticate it before going further:
sk: Všimnite si, že archívy GNU balíkov sú poskytované spolu s OpenPGP podpisom, takže by ste si jednoznačne mali overiť podpis tohto archívu pomocou „gpg“ predtým než budete pokračovať:

note: type: example
en: Starting download of /tmp/guix-file.03tFfb
    From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz.sig...
    following redirection to `https://ftp.igh.cnrs.fr/pub/gnu/hello/hello-2.10.tar.gz.sig'...
     ….tar.gz.sig  819B                                                                                                                       1.2MiB/s 00:00 [##################] 100.0%
    /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig
    0q0v86n3y38z17rl146gdakw9xc4mcscpk8dscs412j22glrv9jf
    $ gpg --verify /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig /gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
    gpg: Signature made Sun 16 Nov 2014 01:08:37 PM CET
    gpg:                using RSA key A9553245FDE9B739
    gpg: Good signature from "Sami Kerola <kerolasa@@iki.fi>" [unknown]
    gpg:                 aka "Sami Kerola (http://www.iki.fi/kerolasa/) <kerolasa@@iki.fi>" [unknown]
    gpg: WARNING: This key is not certified with a trusted signature!
    gpg:          There is no indication that the signature belongs to the owner.
    Primary key fingerprint: 8ED3 96E3 7E38 D471 A005  30D3 A955 3245 FDE9 B739
sk: Starting download of /tmp/guix-file.03tFfb
    From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz.sig...
    following redirection to `https://ftp.igh.cnrs.fr/pub/gnu/hello/hello-2.10.tar.gz.sig'...
     ….tar.gz.sig  819B                                                                                                                       1.2MiB/s 00:00 [##################] 100.0%
    /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig
    0q0v86n3y38z17rl146gdakw9xc4mcscpk8dscs412j22glrv9jf
    $ gpg --verify /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig /gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
    gpg: Podpis vytvorený Ne 16. november 2014, 13:08:37 CET
    gpg:                pomocou RSA kľúča A9553245FDE9B739
    gpg: Dobrý podpis od "Sami Kerola <kerolasa@@iki.fi>" neznáme
    gpg:                 alias "Sami Kerola (http://www.iki.fi/kerolasa/) <kerolasa@@iki.fi>" neznáme
    gpg: VAROVANIE: Tento kľúč nie certifikovaný dôveryhodným podpisom!
    gpg:          Nič nenaznačuje tomu, že tento podpis patrí vlastníkovi kľúča.
    Primárny fingerprint kľúča: 8ED3 96E3 7E38 D471 A005  30D3 A955 3245 FDE9 B739

note: type: Plain text
en: You can then happily run
sk: Potom môžete spokojne spustiť

note: type: Plain text
en: You should now have @code{my-hello} in your profile!
sk: Teraz by ste už mali mať @code{my-hello} vo vašom profile!

note: type: Plain text
en: We've gone as far as we could without any knowledge of Scheme.  Before moving on to more complex packages, now is the right time to brush up on your Scheme knowledge.  @pxref{A Scheme Crash Course} to get up to speed.
sk: Dostali sme sa tak ďaleko ako sa dalo bez znalosti Scheme. Predtým než prejdeme k zložitejším balíkom si dáme rýchlokurz jazyka Scheme. Na začiatok odporúčame @pxref{A Scheme Crash Course}.

note: type: subsection
en: Setup
sk: Nastavenie

note: type: Plain text
en: In the rest of this chapter we will rely on some basic Scheme programming knowledge.  Now let's detail the different possible setups for working on Guix packages.
sk: V ďalších častiach tohto oddielu sa budeme spoliehať na vašu základnú znalosť jazyka Scheme. Teraz si predstavíme rôzne možnosti práce s balíkmi Guix.

note: type: Plain text
en: There are several ways to set up a Guix packaging environment.
sk: Jestvuje viacero spôsobov nastavenia prostredia pre zadávanie balíkov Guix.

note: type: Plain text
en: We recommend you work directly on the Guix source checkout since it makes it easier for everyone to contribute to the project.
sk: Odporúčame vám pracovať priamo v repozitári zdrojových súborov Guixu za účelom jednoduchšieho prispievania do projektu.

note: type: Plain text
en: But first, let's look at other possibilities.
sk: Ale najprv sa pozrime na ostatné možnosti.

note: type: subsubsection
en: Local file
sk: Miestny súbor

note: type: Plain text
en: This is what we previously did with @samp{my-hello}.  With the Scheme basics we've covered, we are now able to explain the leading chunks.  As stated in @code{guix package --help}:
sk: Toto je spôsob, ktorý sme práve použili v prípade @samp{my-hello}. Vďaka základom Scheme, ktoré sme si predstavili, vám teraz môžeme vysvetliť tie najdôležitejšie časti. Ako je uvedené v @code{guix package --help}:

note: type: example
en:   -f, --install-from-file=FILE
                             install the package that the code within FILE
                             evaluates to
sk:   -f, --install-from-file=SÚBOR
                             inštalovať balíky priamo definované
                             v SÚBORE

note: type: Plain text
en: Thus the last expression @emph{must} return a package, which is the case in our earlier example.
sk: Teda, posledný výraz @emph{musí} vracať balík, čo pre náš skorší príklad aj platí.

note: type: Plain text
en: The @code{use-modules} expression tells which of the modules we need in the file.  Modules are a collection of values and procedures.  They are commonly called ``libraries'' or ``packages'' in other programming languages.
sk: Výraz @code{use-modules} nám hovorí, ktoré moduly potrebujeme. Moduly predstavujú zbierky hodnôt a funkcií. V iných programovacích jazykoch sa všeobecne označujú ako „knižnice“ alebo „balíky“.

note: type: emph{#1}
en: Note: Starting from Guix 0.16, the more flexible Guix @dfn{channels} are the preferred way and supersede @samp{GUIX_PACKAGE_PATH}.  See next section.
sk: Upozornenie: Počínajúc Guix 0.16 sú Guix @dfn{channels} uprednostňovaným spôsobom práce a nahrádzajú použitie @samp{GUIX_PACKAGE_PATH}. Viď nasledujúci oddiel.

note: type: Plain text
en: It can be tedious to specify the file from the command line instead of simply calling @code{guix package --install my-hello} as you would do with the official packages.
sk: Uvádzanie súboru so zadaním balíka v príkazovom riadku namiesto použitia @code{guix package --install my-hello}, ako v prípade oficiálnych balíkov, môže byť zdĺhavé.

note: type: Plain text
en: Guix makes it possible to streamline the process by adding as many ``package declaration directories'' as you want.
sk: Guix umožňuje zjednodušiť túto úlohu pridaním toľkých „priečinkov zadaní balíkov“, koľkých chcete.

note: type: Plain text
en: Create a directory, say @file{~/guix-packages} and add it to the @samp{GUIX_PACKAGE_PATH} environment variable:
sk: Vytvorte priečinok, povedzme @file{~/guix-packages} a pridajte cestu k nemu do premennej prostredia @samp{GUIX_PACKAGE_PATH}:

note: type: Plain text
en: To add several directories, separate them with a colon (@code{:}).
sk: Pri pridávaní viacerých priečinkov oddeľte jednotlivé cesty k nim dvojbodkou (@code{:}).

note: type: Plain text
en: Our previous @samp{my-hello} needs some adjustments though:
sk: Avšak, náš predchádzajúci príklad @samp{my-hello} vyžaduje niekoľko úprav:

note: type: Plain text
en: Note that we have assigned the package value to an exported variable name with @code{define-public}.  This is effectively assigning the package to the @code{my-hello} variable so that it can be referenced, among other as dependency of other packages.
sk: Všimnite si, že sme tentokrát zadanie balíka uložili do verejnej premennej @code{my-hello} pomocou @code{define-public}, na ktorú je možné odkazovať, medzi iným aj ako na závislosť v rámci zadania nejakého ďalšieho balíka.

note: type: Plain text
en: If you use @code{guix package --install-from-file=my-hello.scm} on the above file, it will fail because the last expression, @code{define-public}, does not return a package.  If you want to use @code{define-public} in this use-case nonetheless, make sure the file ends with an evaluation of @code{my-hello}:
sk: Ak spustíte @code{guix package --install-from-file=my-hello.scm} s použitím vyššie uvedeného súboru, tak príkaz zlyhá, pretože posledný výraz, @code{define-public}, nevracia balík. Ak aj napriek tomu chcete v tomto prípade použiť @code{define-public}, uistite sa, že súbor končí vykonaním @code{my-hello}:

note: type: Plain text
en: This last example is not very typical.
sk: Tento posledný príklad nie je veľmi bežný.

note: type: Plain text
en: Now @samp{my-hello} should be part of the package collection like all other official packages.  You can verify this with:
sk: Teraz by už mal byť @samp{my-hello} súčasťou zbierky balíkov ako všetky ostatné oficiálne balíky. Môžete si to overiť pomocou:

note: type: subsubsection
en: Guix channels
sk: Kanály Guix

note: type: Plain text
en: Guix 0.16 features channels, which is very similar to @samp{GUIX_PACKAGE_PATH} but provides better integration and provenance tracking.  Channels are not necessarily local, they can be maintained as a public Git repository for instance.  Of course, several channels can be used at the same time.
sk: Guix 0.16 uvádza kanály, čo je mechanizmus veľmi podobný @samp{GUIX_PACKAGE_PATH}, ale ponúka lepšie začlenenie a sledovanie pôvodu. Kanály nemusia byť miestne, môžu byť udržiavané, napríklad, vo forme verejných Git repozitárov. Je samozrejme možné použiť viacero kanálov naraz.

note: type: Plain text
en: @xref{Channels,,, guix, GNU Guix Reference Manual} for setup details.
sk: Viď @xref{Channels,,, guix, GNU Guix Reference Manual} pre viac podrobností o používaní kanálov.

note: type: subsubsection
en: Direct checkout hacking
sk: Priamy zásah do git repozitára

note: type: Plain text
en: Working directly on the Guix project is recommended: it reduces the friction when the time comes to submit your changes upstream to let the community benefit from your hard work!
sk: Odporúčame vám pracovať priamo v rámci projektu Guix: znižuje to čas potrebný na odoslanie a zapracovanie vašich zmien do oficiálnej verzie Guixu, aby aj ostatní mali úžitok z vašej ťažkej práce!

note: type: Plain text
en: Unlike most software distributions, the Guix repository holds in one place both the tooling (including the package manager) and the package definitions.  This choice was made so that it would give developers the flexibility to modify the API without breakage by updating all packages at the same time.  This reduces development inertia.
sk: Na rozdiel od väčšiny softvérových distribúcií, repozitár Guixu obsahuje aj nástroje (vrátane správcu balíkov) aj zadania balíkov. Vývojárom je takto možné zaistiť pružnosť potrebnú pre upravovanie API bez toho, aby niečo pokazili. Všetky zadania balíkov sa po každej úprave samy aktualizujú, čím sa predíde zdržaniam vo vývoji.

note: type: Plain text
en: Check out the official @uref{https://git-scm.com/, Git} repository:
sk: Vytvorte si kópiu oficiálneho @uref{https://git-scm.com/, Git} repozitára:

note: type: Plain text
en: In the rest of this article, we use @samp{$GUIX_CHECKOUT} to refer to the location of the checkout.
sk: Vo zvyšku tohto príspevku použijeme pri odkazovaní na túto kópiu premennú @samp{$GUIX_CHECKOUT}.

note: type: Plain text
en: Follow the instructions in the manual (@pxref{Contributing,,, guix, GNU Guix Reference Manual}) to set up the repository environment.
sk: Pre nastavenie prostredia repozitára postupujte podľa pokynov v príručke (@pxref{Contributing,,, guix, GNU Guix Reference Manual}).

note: type: Plain text
en: Once ready, you should be able to use the package definitions from the repository environment.
sk: Keď budete pripravení, mali by ste byť schopní použiť zadania balíkov z prostredia repozitára.

note: type: Plain text
en: Feel free to edit package definitions found in @samp{$GUIX_CHECKOUT/gnu/packages}.
sk: Nebojte sa upravovať zadania balíkov v @samp{$GUIX_CHECKOUT/gnu/packages}.

note: type: Plain text
en: The @samp{$GUIX_CHECKOUT/pre-inst-env} script lets you use @samp{guix} over the package collection of the repository (@pxref{Running Guix Before It Is Installed,,, guix, GNU Guix Reference Manual}).
sk: Skript @samp{$GUIX_CHECKOUT/pre-inst-env} vám umožňuje použiť @samp{guix} so zbierkou balíkov v repozitári (@pxref{Running Guix Before It Is Installed,,, guix, GNU Guix Reference Manual}).

note: type: itemize
en: Search packages, such as Ruby:
sk: Vyhľadávajte balíky, napríklad Ruby:

note: type: itemize
en: Build a package, here Ruby version 2.1:
sk: Zostavte balík, v tomto prípade Ruby vo verzii 2.1:

note: type: itemize
en: Install it to your user profile:
sk: Nainštaluje ho do vášho používateľského profilu:

note: type: itemize
en: Check for common mistakes:
sk: Overte si, či ste neurobili niektorú z častých chýb:

note: type: Plain text
en: Guix strives at maintaining a high packaging standard; when contributing to the Guix project, remember to
sk: Guix sa usiluje udržať vysokú úroveň zadávania balíkov; pri prispievaní do projektu Guix si zapamätajte, že je potrebné

note: type: itemize
en: follow the coding style (@pxref{Coding Style,,, guix, GNU Guix Reference Manual}),
sk: dodržiavať spôsob kódovania (@pxref{Coding Style,,, guix, GNU Guix Reference Manual}),

note: type: itemize
en: and review the check list from the manual (@pxref{Submitting Patches,,, guix, GNU Guix Reference Manual}).
sk: a prejsť si kontrolný zoznam z príručky (@pxref{Submitting Patches,,, guix, GNU Guix Reference Manual}).

note: type: Plain text
en: Once you are happy with the result, you are welcome to send your contribution to make it part of Guix.  This process is also detailed in the manual.  (@pxref{Contributing,,, guix, GNU Guix Reference Manual})
sk: Keď ste spokojní s výsledkom, privítame, ak nám zašlete váš príspevok, aby sa mohol stať súčasťou Guixu. Tento postup je tiež opísaný v príručke. (@pxref{Contributing,,, guix, GNU Guix Reference Manual})

note: type: Plain text
en: It's a community effort so the more join in, the better Guix becomes!
sk: Guix závisí od spoločného úsilia, preto čím viac ľudí prispeje, tým bude Guix lepší!

note: type: subsection
en: Extended example
sk: Zložitejší príklad

note: type: Plain text
en: The above ``Hello World'' example is as simple as it goes.  Packages can be more complex than that and Guix can handle more advanced scenarios.  Let's look at another, more sophisticated package (slightly modified from the source):
sk: Vyššie uvedený príklad zadania balíka „Ahoj svet“ je taký jednoduchý ako sa len dá. Avšak, zadania balíkov môžu byť zložitejšie a Guix si poradí aj s omnoho náročnejšími balíkmi. Pozrime sa teda na iné, zložitejšie zadanie balíka (mierne upravené v porovnaní s pôvodným zadaním):

note: type: lisp
en: (define-public my-libgit2
      (let ((commit "e98d0a37c93574d2c6107bf7f31140b548c6a7bf")
            (revision "1"))
        (package
          (name "my-libgit2")
          (version (git-version "0.26.6" revision commit))
          (source (origin
                    (method git-fetch)
                    (uri (git-reference
                          (url "https://github.com/libgit2/libgit2/")
                          (commit commit)))
                    (file-name (git-file-name name version))
                    (sha256
                     (base32
                      "17pjvprmdrx4h6bb1hhc98w9qi6ki7yl57f090n9kbhswxqfs7s3"))
                    (patches (search-patches "libgit2-mtime-0.patch"))
                    (modules '((guix build utils)))
                    ;; Remove bundled software.
                    (snippet '(delete-file-recursively "deps"))))
          (build-system cmake-build-system)
          (outputs '("out" "debug"))
          (arguments
           `(#:tests? #true                         ; Run the test suite (this is the default)
             #:configure-flags '("-DUSE_SHA1DC=ON") ; SHA-1 collision detection
             #:phases
             (modify-phases %standard-phases
               (add-after 'unpack 'fix-hardcoded-paths
                 (lambda _
                   (substitute* "tests/repo/init.c"
                     (("#!/bin/sh") (string-append "#!" (which "sh"))))
                   (substitute* "tests/clar/fs.h"
                     (("/bin/cp") (which "cp"))
                     (("/bin/rm") (which "rm")))))
               ;; Run checks more verbosely.
               (replace 'check
                 (lambda _ (invoke "./libgit2_clar" "-v" "-Q")))
               (add-after 'unpack 'make-files-writable-for-tests
                 (lambda _ (for-each make-file-writable (find-files "." ".*")))))))
          (inputs
           (list libssh2 http-parser python-wrapper))
          (native-inputs
           (list pkg-config))
          (propagated-inputs
           ;; These two libraries are in 'Requires.private' in libgit2.pc.
           (list openssl zlib))
          (home-page "https://libgit2.github.com/")
          (synopsis "Library providing Git core methods")
          (description
           "Libgit2 is a portable, pure C implementation of the Git core methods
    provided as a re-entrant linkable library with a solid API, allowing you to
    write native speed custom Git applications in any language with bindings.")
          ;; GPLv2 with linking exception
          (license license:gpl2))))
sk: (define-public my-libgit2
      (let ((commit "e98d0a37c93574d2c6107bf7f31140b548c6a7bf")
            (revision "1"))
        (package
          (name "my-libgit2")
          (version (git-version "0.26.6" revision commit))
          (source (origin
                    (method git-fetch)
                    (uri (git-reference
                          (url "https://github.com/libgit2/libgit2/")
                          (commit commit)))
                    (file-name (git-file-name name version))
                    (sha256
                     (base32
                      "17pjvprmdrx4h6bb1hhc98w9qi6ki7yl57f090n9kbhswxqfs7s3"))
                    (patches (search-patches "libgit2-mtime-0.patch"))
                    (modules '((guix build utils)))
                    ;; Odstrániť pribalený softvér.
                    (snippet '(delete-file-recursively "deps"))))
          (build-system cmake-build-system)
          (outputs '("out" "debug"))
          (arguments
           `(#:tests? #true                         ; Preveriť výsledok zostavenia (predvolené).
             #:configure-flags '("-DUSE_SHA1DC=ON") ; Zisťovanie rozporov v odtlačkoch SHA-1
             #:phases
             (modify-phases %standard-phases
               (add-after 'unpack 'fix-hardcoded-paths
                 (lambda _
                   (substitute* "tests/repo/init.c"
                     (("#!/bin/sh") (string-append "#!" (which "sh"))))
                   (substitute* "tests/clar/fs.h"
                     (("/bin/cp") (which "cp"))
                     (("/bin/rm") (which "rm")))))
               ;; Bohatší výstup pri preverovaní zostavenia
               (replace 'check
                 (lambda _ (invoke "./libgit2_clar" "-v" "-Q")))
               (add-after 'unpack 'make-files-writable-for-tests
                 (lambda _ (for-each make-file-writable (find-files "." ".*")))))))
          (inputs
           (list libssh2 http-parser python-wrapper))
          (native-inputs
           (list pkg-config))
          (propagated-inputs
           ;; Tieto dve knižnice sa nachádzajú v „Requires.private“ v libgit2.pc.
           (list openssl zlib))
          (home-page "https://libgit2.github.com/")
          (synopsis "Library providing Git core methods")
          (description
           "Libgit2 is a portable, pure C implementation of the Git core methods
    provided as a re-entrant linkable library with a solid API, allowing you to
    write native speed custom Git applications in any language with bindings.")
          ;; GPLv2 s odkazovou výnimkou
          (license license:gpl2))))

note: type: Plain text
en: (In those cases were you only want to tweak a few fields from a package definition, you should rely on inheritance instead of copy-pasting everything.  See below.)
sk: (V prípade, že chcete zmeniť len pár polí v pôvodnom zadaní balíka by ste sa mali spoľahnúť na dedičnosť namiesto skopírovania celého zadania. Viď nižšie.)

note: type: Plain text
en: Let's discuss those fields in depth.
sk: Pozrime sa teraz na tieto polia zblízka.

note: type: subsubsection
en: @code{git-fetch} method
sk: spôsob @code{git-fetch}

note: type: Plain text
en: Unlike the @code{url-fetch} method, @code{git-fetch} expects a @code{git-reference} which takes a Git repository and a commit.  The commit can be any Git reference such as tags, so if the @code{version} is tagged, then it can be used directly.  Sometimes the tag is prefixed with a @code{v}, in which case you'd use @code{(commit (string-append "v" version))}.
sk: Narozdiel od funkcie @code{url-fetch}, @code{git-fetch} vyžaduje @code{git-reference}, ktorú určuje Git repozitár a príslušná úprava. Úpravou sa rozumie akýkoľvek odkaz Git ako napríklad značka. Teda, ak je @code{version} označená, tak je možné použiť priamo číslo verzie. Niekedy majú značky verzií perdponu @code{v}. V tomto prípade môžete použiť @code{(commit (string-append "v" version))}.

note: type: Plain text
en: To ensure that the source code from the Git repository is stored in a directory with a descriptive name, we use @code{(file-name (git-file-name name version))}.
sk: Aby sme sa uistili, že sa zdrojový kód z Git repozitára uloží do priečinka s výstižným názvom, použijeme @code{(file-name (git-file-name name version))}.

note: type: Plain text
en: The @code{git-version} procedure can be used to derive the version when packaging programs for a specific commit, following the Guix contributor guidelines (@pxref{Version Numbers,,, guix, GNU Guix Reference Manual}).
sk: Keď zadávate balík pre program s určitým číslom úpravy, môžete pre odvodenie správneho označenia verzie použiť funkciu @code{git-version} podľa pokynov v príručke prispievateľa do Guixu (@pxref{Version Numbers,,, guix, GNU Guix Reference Manual}).

note: type: Plain text
en: How does one obtain the @code{sha256} hash that's in there, you ask? By invoking @command{guix hash} on a checkout of the desired commit, along these lines:
sk: Pýtate sa ako získať správny odtlačok @code{sha256}? Vyvolaním @command{guix hash} na miestnej kópii repozitára v požadovanej úprave, asi takto:

note: type: Plain text
en: @command{guix hash -rx} computes a SHA256 hash over the whole directory, excluding the @file{.git} sub-directory (@pxref{Invoking guix hash,,, guix, GNU Guix Reference Manual}).
sk: @command{guix hash -rx} vypočíta odtlačok SHA256 celého priečinka nezahŕňajúc pod-priečinok @file{.git} (@pxref{Invoking guix hash,,, guix, GNU Guix Reference Manual}).

note: type: Plain text
en: In the future, @command{guix download} will hopefully be able to do these steps for you, just like it does for regular downloads.
sk: Do budúcna bude snáď @command{guix download} schopný vykonávať tieto kroky za vás, tak ako je tomu pri bežných sťahovaniach súborov.

note: type: subsubsection
en: Snippets
sk: Kusy kódu

note: type: Plain text
en: Snippets are quoted (i.e. non-evaluated) Scheme code that are a means of patching the source.  They are a Guix-y alternative to the traditional @file{.patch} files.  Because of the quote, the code in only evaluated when passed to the Guix daemon for building.  There can be as many snippets as needed.
sk: Kusy kódu predstavujú malé časti Scheme kódu v úvodzovkách, t.j. bežne nevykonávané, ktoré sa používajú na plátanie zdrojových súborov. Je to taká Guixová náhrada za dobre známe @file{.patch} súbory. Vďaka úvodzovkám sa daný kód vykoná len vtedy, keď sa odošle démonovi Guixu na zostavenie. V praxi môžeme použiť toľko kusov kódu, koľko potrebujeme.

note: type: Plain text
en: Snippets might need additional Guile modules which can be imported from the @code{modules} field.
sk: Kusy kódu môžu vyžadovať prídavné moduly Guilu, ktoré je možné načítať pomocou poľa @code{modules}.

note: type: subsubsection
en: Inputs
sk: Vstupy

note: type: Plain text
en: There are 3 different input types.  In short:
sk: Jestvujú tri rôzne druhy vstupov. V skratke:

note: type: table
en: Required for building but not runtime -- installing a package through a substitute won't install these inputs.
sk: Vyžadované pri zostavovaní ale nie pri spúšťaní. V prípade inštalácie balíka prostredníctvom náhrady sa tieto vstupy nebudú inštalovať.

note: type: item
en: inputs
sk: vstupy

note: type: table
en: Installed in the store but not in the profile, as well as being present at build time.
sk: Inštalované do úložiska ale nie do profilu a prítomné pri zostavovaní.

note: type: table
en: Installed in the store and in the profile, as well as being present at build time.
sk: Inštalované do úložiska aj do profilu a prítomné pri zostavovaní.

note: type: Plain text
en: The distinction between the various inputs is important: if a dependency can be handled as an @emph{input} instead of a @emph{propagated input}, it should be done so, or else it ``pollutes'' the user profile for no good reason.
sk: Správne rozlišovanie medzi jednotlivými druhmi vstupov je dôležité: ak je možné závislosť zaradiť ako @emph{input} namiesto @emph{propagated input}, tak by sa to tak malo urobiť. Inak bezdôvodne „znečistí“ používateľský profil.

note: type: Plain text
en: For instance, a user installing a graphical program that depends on a command line tool might only be interested in the graphical part, so there is no need to force the command line tool into the user profile.  The dependency is a concern to the package, not to the user.  @emph{Inputs} make it possible to handle dependencies without bugging the user by adding undesired executable files (or libraries) to their profile.
sk: Napríklad, ak inštalujete grafický program, ktorý závisí na nejakom nástroji spúšťanom v príkazovom riadku, tak vám pravdepodobne ide len o tú grafickú časť. Nie je teda potrebné siliť inštaláciu nástroja spúšťaného v príkazovom riadku do používateľského profilu. Závislosti sú spravované balíkmi a nie používateľmi. @emph{Vstupy} umožňujú spravovať závislosti bez toho, aby to nejako zaťažovalo používateľov pridávaním neužitočných programov či knižníc do ich profilu.

note: type: Plain text
en: Same goes for @emph{native-inputs}: once the program is installed, build-time dependencies can be safely garbage-collected.  It also matters when a substitute is available, in which case only the @emph{inputs} and @emph{propagated inputs} will be fetched: the @emph{native inputs} are not required to install a package from a substitute.
sk: Rovnako to platí aj pre @emph{native-inputs}: po inštalácii programu môžu byť závislosti vyžadované pri zostavovaní bezpečne odstránené zberačom odpadkov. Okrem toho, ak je dostupná binárna náhrada, stiahnu sa len @emph{inputs} a @emph{propagated inputs}: @emph{native inputs} nie sú pri inštalácii balíka prostredníctvom náhrady potrebné.

note: type: quotation
en: Note
sk: Poznámka

note: type: quotation
en: You may see here and there snippets where package inputs are written quite differently, like so:
sk: Tu a tam nájdete úryvky, v ktorých sú vstupy zapísané pomerne odlišne, teda asi takto:

note: type: lisp
en: ;; The "old style" for inputs.
    (inputs
     `(("libssh2" ,libssh2)
       ("http-parser" ,http-parser)
       ("python" ,python-wrapper)))
sk: ;; „Pôvodný tvar“ zápisu vstupov
    (inputs
     `(("libssh2" ,libssh2)
       ("http-parser" ,http-parser)
       ("python" ,python-wrapper)))

note: type: quotation
en: This is the ``old style'', where each input in the list is explicitly given a label (a string).  It is still supported but we recommend using the style above instead.  @xref{package Reference,,, guix, GNU Guix Reference Manual}, for more info.
sk: Toto je „pôvodný tvar“, v ktorom má každá položka zoznamu vstupov pridelenú menovku (reťazec).  Tento tvar je stále podporovaný ale odporúčame vám používať už len vyššie uvedený tvar.  Viď @xref{package Reference,,, guix, GNU Guix Reference Manual} pre viac podrobností.

note: type: subsubsection
en: Outputs
sk: Výstupy

note: type: Plain text
en: Just like how a package can have multiple inputs, it can also produce multiple outputs.
sk: Tak ako môže mať balík viacero vstupov, môže mať aj viacero výstupov.

note: type: Plain text
en: Each output corresponds to a separate directory in the store.
sk: Každý výstup má osobitný priečinok v úložisku.

note: type: Plain text
en: The user can choose which output to install; this is useful to save space or to avoid polluting the user profile with unwanted executables or libraries.
sk: Používateľ si môže vybrať, ktorý výstup nainštaluje; pomáha to šetriť úložné miesto a predchádzať znečisteniu používateľského profilu nechcenými programami či knižnicami.

note: type: Plain text
en: Output separation is optional.  When the @code{outputs} field is left out, the default and only output (the complete package) is referred to as @code{"out"}.
sk: Oddeľovanie výstupov je voliteľné. Ak sa pole @code{outputs} vynechá, predvoleným a jediným výstupom (celý balík) bude @code{"out"}.

note: type: Plain text
en: Typical separate output names include @code{debug} and @code{doc}.
sk: Často vidíme oddelené výstupy s názvom @code{debug} alebo @code{doc}.

note: type: Plain text
en: It's advised to separate outputs only when you've shown it's worth it: if the output size is significant (compare with @code{guix size}) or in case the package is modular.
sk: Oddelené výstupy by ste mali používať len vtedy, keď sa to oplatí: ak je výstup značne veľký (možno porovnať pomocou @code{guix size}), alebo ak je balík modulárny.

note: type: subsubsection
en: Build system arguments
sk: Argumenty zostavovacieho systému

note: type: Plain text
en: The @code{arguments} is a keyword-value list used to configure the build process.
sk: Pole @code{arguments} obsahuje páry kľúč-hodnota používané pri nastavovaní postupu zostavenia.

note: type: Plain text
en: The simplest argument @code{#:tests?} can be used to disable the test suite when building the package.  This is mostly useful when the package does not feature any test suite.  It's strongly recommended to keep the test suite on if there is one.
sk: Ten najjednoduchší argument @code{#:tests?} možno použiť na vynechanie testov po zostavení balíka. Je to užitočné najmä v prípade, keď balík neobsahuje žiadnu testovaciu súpravu. Je dôrazne odporúčané ponechať testovaciu súpravu povolenú, ak je nejaká dostupná.

note: type: Plain text
en: Another common argument is @code{:make-flags}, which specifies a list of flags to append when running make, as you would from the command line.  For instance, the following flags
sk: Ďalším bežným argumentom je @code{:make-flags} určujúci zoznam dodatočných príznakov, ktoré sa majú použiť pri spúšťaní nástroja make ako keby ste pridali priamo do príkazového riadku. Napríklad, nasledovné príznaky

note: type: Plain text
en: translate into
sk: sú chápané ako

note: type: Plain text
en: This sets the C compiler to @code{gcc} and the @code{prefix} variable (the installation directory in Make parlance) to @code{(assoc-ref %outputs "out")}, which is a build-stage global variable pointing to the destination directory in the store (something like @file{/gnu/store/...-my-libgit2-20180408}).
sk: Toto nastaví prekladač jazyka C na @code{gcc} a premennú @code{prefix} (cieľový priečinok inštalácie v prípade nástroja Make) na @code{(assoc-ref %outputs "out")}, čo predstavuje globálnu premennú prítomnú pri zostavovaní, ktorá udáva cestu k cieľovému priečinku v úložisku (niečo ako @file{/gnu/store/...-my-libgit2-20180408}).

note: type: Plain text
en: Similarly, it's possible to set the configure flags:
sk: Podobným spôsobom môžete nastaviť aj príznaky nastavenia:

note: type: Plain text
en: The @code{%build-inputs} variable is also generated in scope.  It's an association table that maps the input names to their store directories.
sk: Dostupná je aj premenná @code{%build-inputs}. Predstavuje tabuľku, ktorá priraďuje názvy vstupov k ich priečinkom v úložisku.

note: type: Plain text
en: The @code{phases} keyword lists the sequential steps of the build system.  Typically phases include @code{unpack}, @code{configure}, @code{build}, @code{install} and @code{check}.  To know more about those phases, you need to work out the appropriate build system definition in @samp{$GUIX_CHECKOUT/guix/build/gnu-build-system.scm}:
sk: Kľúčové slovo @code{phases} predstavuje postupnosť krokov zostavovacieho systému. Medzi bežné kroky patria @code{unpack}, @code{configure}, @code{build}, @code{install} a @code{check}. Ak chcete o týchto krokoch zistiť viac, musíte nájsť to správne zadanie zostavovacieho systému v @samp{$GUIX_CHECKOUT/guix/build/gnu-build-system.scm}:

note: type: Plain text
en: Or from the REPL:
sk: Alebo cez REPL:

note: type: Plain text
en: If you want to know more about what happens during those phases, consult the associated procedures.
sk: Ak chcete vedieť čo sa počas jednotlivých krokov odohráva, preštudujte si príslušné funkcie.

note: type: Plain text
en: For instance, as of this writing the definition of @code{unpack} for the GNU build system is:
sk: Napríklad, v čase písania týchto riadkov, bolo zadanie kroku @code{unpack} v zostavovacom systéme GNU nasledovné:

note: type: Plain text
en: Note the @code{chdir} call: it changes the working directory to where the source was unpacked.  Thus every phase following the @code{unpack} will use the source as a working directory, which is why we can directly work on the source files.  That is to say, unless a later phase changes the working directory to something else.
sk: Všimnite si volanie @code{chdir}: zmení súčasný priečinok na umiestnenie, kde boli rozbalené zdrojové súbory. To znamená, že kroky nasledujúce po @code{unpack} použijú priečinok so zdrojovými súbormi ako ich pracovný priečinok. Preto môžeme priamo narábať so zdrojovými súbormi. Teda aspoň dovtedy, kým niektorý ďalší krok nezmení pracovný priečinok na iný.

note: type: Plain text
en: We modify the list of @code{%standard-phases} of the build system with the @code{modify-phases} macro as per the list of specified modifications, which may have the following forms:
sk: Zoznam krokov @code{%standard-phases} zostavovacieho systému upravujeme pomocou makra @code{modify-phases} určujúceho aké úpravy sa majú vykonať, čo môže vyzerať asi takto:

note: type: itemize
en: @code{(add-before @var{phase} @var{new-phase} @var{procedure})}: Run @var{procedure} named @var{new-phase} before @var{phase}.
sk: @code{(add-before @var{krok} @var{novy-krok} @var{funkcia})}: Spustiť @var{funkcia} s názvom @var{novy-krok} pred @var{krok}.

note: type: itemize
en: @code{(add-after @var{phase} @var{new-phase} @var{procedure})}: Same, but afterwards.
sk: @code{(add-after @var{krok} @var{novy-krok} @var{funkcia})}: Tak isto, ale za @var{krok}.

note: type: itemize
en: @code{(replace @var{phase} @var{procedure})}.
sk: @code{(replace @var{krok} @var{funkcia})}.

note: type: itemize
en: @code{(delete @var{phase})}.
sk: @code{(delete @var{krok})}.

note: type: Plain text
en: The @var{procedure} supports the keyword arguments @code{inputs} and @code{outputs}.  Each input (whether @emph{native}, @emph{propagated} or not) and output directory is referenced by their name in those variables.  Thus @code{(assoc-ref outputs "out")} is the store directory of the main output of the package.  A phase procedure may look like this:
sk: @var{Funkcia} prijíma parametre @code{inputs} a @code{outputs} v tvare kľúčových slov.  Každý vstup (či už @emph{pôvodný}, @emph{rozšírený} alebo nie) a výstupný priečinok je označený svojim názvom v týchto premenných.  Takže @code{(assoc-ref outputs "out")} predstavuje priečinok úložiska hlavného výstupu balíka.  Funkcia kroku vyzerá nasledovne:

note: type: Plain text
en: The procedure must return @code{#true} on success.  It's brittle to rely on the return value of the last expression used to tweak the phase because there is no guarantee it would be a @code{#true}.  Hence the trailing @code{#true} to ensure the right value is returned on success.
sk: Funkcia musí po úspešnom vykonaní vrátiť @code{#true}.  Nie je veľmi spoľahlivé opierať sa o návratovú hodnotu posledného výrazu keďže nie je isté, že to bude práve @code{#true}.  Koncové @code{#true} zaisťuje, že bude po úspešnom vykonaní vrátená správna hodnota.

note: type: subsubsection
en: Code staging
sk: Oddialené vykonanie

note: type: Plain text
en: The astute reader may have noticed the quasi-quote and comma syntax in the argument field.  Indeed, the build code in the package declaration should not be evaluated on the client side, but only when passed to the Guix daemon.  This mechanism of passing code around two running processes is called @uref{https://arxiv.org/abs/1709.00833, code staging}.
sk: Ak ste boli pozorní, mohli ste si všimnúť obrátenú úvodzovku a čiarku v poli parametrov.  Vskutku, zdrojový kód zostavenia v zadaní balíka by sa nemal vykonávať na strane klienta, ale až vtedy, keď sa odovzdá démonovi Guixu.  Toto odovzdávanie zdrojového kódu medzi dvoma procesmi nazývame @uref{https://arxiv.org/abs/1709.00833, oddialené vykonanie}.

note: type: subsubsection
en: Utility functions
sk: Pomocné funkcie

note: type: Plain text
en: When customizing @code{phases}, we often need to write code that mimics the equivalent system invocations (@code{make}, @code{mkdir}, @code{cp}, etc.)@: commonly used during regular ``Unix-style'' installations.
sk: Pri prispôsobovaní @code{phases} budete často potrebovať funkcie zodpovedajúce systémovým volaniam (@code{make}, @code{mkdir}, @code{cp}, atď.), ktoré sú zvyčajne dostupné na Unixových systémoch.

note: type: Plain text
en: Some like @code{chmod} are native to Guile.  @xref{,,, guile, Guile reference manual} for a complete list.
sk: Niektoré z nich, ako napríklad @code{chmod}, sú priamo dostupné v jazyku Guile.  Viď úplný zoznam v @xref{,,, guile, Guile reference manual}.

note: type: Plain text
en: Guix provides additional helper functions which prove especially handy in the context of package management.
sk: Guix poskytuje ďalšie pomocné funkcie, užitočné najmä v súvislosti so správou balíkov.

note: type: Plain text
en: Some of those functions can be found in @samp{$GUIX_CHECKOUT/guix/guix/build/utils.scm}.  Most of them mirror the behaviour of the traditional Unix system commands:
sk: Niektoré z týchto funkcií sa nachádzajú v @samp{$GUIX_CHECKOUT/guix/guix/build/utils.scm}.  Väčšinou napodobňujú správanie pôvodných Unixových systémových príkazov:

note: type: table
en: Like the @samp{which} system command.
sk: Rovnaká ako systémový príkaz @samp{which}.

note: type: table
en: Akin to the @samp{find} system command.
sk: Podobná príkazu @samp{find}.

note: type: table
en: Like @samp{mkdir -p}, which creates all parents as needed.
sk: Rovnaká ako príkaz @samp{mkdir -p}, ktorý v prípade potreby vytvorí aj všetky nadradené priečinky.

note: type: table
en: Similar to @samp{install} when installing a file to a (possibly non-existing) directory.  Guile has @code{copy-file} which works like @samp{cp}.
sk: Podobná ako príkaz @samp{install} na inštaláciu súboru do priečinka (aj nejestvujúceho). Guile má funkciu @code{copy-file}, ktorá funguje ako príkaz @samp{cp}.

note: type: table
en: Like @samp{cp -r}.
sk: Ako @samp{cp -r}.

note: type: table
en: Like @samp{rm -rf}.
sk: Ako @samp{rm -rf}.

note: type: table
en: Run an executable.  This should be used instead of @code{system*}.
sk: Vyvolať spustiteľný súbor.  Toto by ste mali používať namiesto @code{system*}.

note: type: table
en: Run the body in a different working directory, then restore the previous working directory.
sk: Vykoná telo funkcie v odlišnom pracovnom priečinku a následne obnoví pôvodný pracovný priečinok.

note: type: table
en: A ``@command{sed}-like'' function.
sk: Funkcia podobná príkazu @command{sed}.

note: type: Plain text
en: @xref{Build Utilities,,, guix, GNU Guix Reference Manual}, for more information on these utilities.
sk: Viď @xref{Build Utilities,,, guix, GNU Guix Reference Manual} pre viac podrobností o pomocných funkciách.

note: type: subsubsection
en: Module prefix
sk: Predpony modulov

note: type: Plain text
en: The license in our last example needs a prefix: this is because of how the @code{license} module was imported in the package, as @code{#:use-module ((guix licenses)  #:prefix license:)}.  The Guile module import mechanism (@pxref{Using Guile Modules,,, guile, Guile reference manual})  gives the user full control over namespacing: this is needed to avoid clashes between, say, the @samp{zlib} variable from @samp{licenses.scm} (a @emph{license} value) and the @samp{zlib} variable from @samp{compression.scm} (a @emph{package} value).
sk: Licencia v našom predošlom príklade je uvedená s predponou vzhľadom na spôsob akým bol načítaný modul @code{licenses} v tomto balíku: @code{#:use-module ((guix licenses) #:prefix license:)}.  Spôsob načítavania modulov v Guile (@pxref{Using Guile Modules,,, guile, Guile reference manual}) používateľovi dáva úplnú kontrolu nad menným priestorom.  Môže sa tak predísť rozporom, povedzme, medzi premennou @samp{zlib} zo súboru @samp{licenses.scm} (názov @emph{licencie}) a premennou @samp{zlib} zo súboru @samp{compression.scm} (názov @emph{balíka}).

note: type: subsection
en: Other build systems
sk: Ďalšie zostavovacie systémy

note: type: Plain text
en: What we've seen so far covers the majority of packages using a build system other than the @code{trivial-build-system}.  The latter does not automate anything and leaves you to build everything manually.  This can be more demanding and we won't cover it here for now, but thankfully it is rarely necessary to fall back on this system.
sk: To čo sme doteraz videli pokrýva väčšinu balíkov využívajúcich iný zostavovací systém ako je @code{trivial-build-system}, ktorý nič neautomatizuje a nechá vás všetko zostaviť ručne.  Tento postup môže byť náročnejší a zatiaľ sa tu ním nebudeme zaoberať.  Našťastie je nutné uchýliť sa k nemu len zriedkavo.

note: type: Plain text
en: For the other build systems, such as ASDF, Emacs, Perl, Ruby and many more, the process is very similar to the GNU build system except for a few specialized arguments.
sk: Pri ostatných zostavovacích systémoch, ako sú ASDF, Emacs, Perl, Ruby a mnoho ďalších, je postup, okrem niekoľkých zvláštnych parametrov, veľmi podobný zostavovaciemu systému GNU.

note: type: Plain text
en: @xref{Build Systems,,, guix, GNU Guix Reference Manual}, for more information on build systems, or check the source code in the @samp{$GUIX_CHECKOUT/guix/build} and @samp{$GUIX_CHECKOUT/guix/build-system} directories.
sk: Viď @xref{Build Systems,,, guix, GNU Guix Reference Manual} alebo zdrojový kód v priečinkoch @samp{$GUIX_CHECKOUT/guix/build} a @samp{$GUIX_CHECKOUT/guix/build-system} pre viac podrobností o zostavovacích systémoch.

note: type: subsection
en: Programmable and automated package definition
sk: Programovateľné a automatické zadávanie balíkov

note: type: Plain text
en: We can't repeat it enough: having a full-fledged programming language at hand empowers us in ways that reach far beyond traditional package management.
sk: Nemôžme to nezdôrazniť: mať po ruke plnohodnotný programovací jazyk nám umožňuje oveľa viac než len bežnú správu balíkov.

note: type: Plain text
en: Let's illustrate this with some awesome features of Guix!
sk: Ukážme si to na príklade niekoľkých úžasných súčastí Guixu!

note: type: subsubsection
en: Recursive importers
sk: Rekurzívne nahrávače

note: type: Plain text
en: You might find some build systems good enough that there is little to do at all to write a package, to the point that it becomes repetitive and tedious after a while.  A @emph{raison d'être} of computers is to replace human beings at those boring tasks.  So let's tell Guix to do this for us and create the package definition of an R package from CRAN (the output is trimmed for conciseness):
sk: Niektoré zostavovacie systémy sú natoľko dobré, že toho na zadanie balíka ani veľa netreba, a to až do takej miery, že sa vám zadávanie balíkov rýchlo zunuje.  Jedným z dôvodov bytia počítačov je nahradiť ľudí pri vykonávaní týchto nudných činností.  Nechajme teda Guix urobiť to za nás a vytvoriť zadanie nejakého balíka R pochádzajúceho z CRANu (výstup bol skrátený pre ušetrenie miesta):

note: type: Plain text
en: The recursive importer won't import packages for which Guix already has package definitions, except for the very first.
sk: Rekurzívny nahrávač nahrá len balíky, pre ktoré Guix ešte nemá zadanie, okrem úplne prvého.

note: type: Plain text
en: Not all applications can be packaged this way, only those relying on a select number of supported systems.  Read about the full list of importers in the guix import section of the manual (@pxref{Invoking guix import,,, guix, GNU Guix Reference Manual}).
sk: Takto vytvoriť zadania balíkov nie je možné pre všetky aplikácie, iba pre tie, ktoré sa opierajú o vybraný počet podporovaných systémov.  Viď úplný zoznam nahrávačov v príslušnom oddiele príručky (@pxref{Invoking guix import,,, guix, GNU Guix Reference Manual}).

note: type: subsubsection
en: Automatic update
sk: Automatické aktualizácie

note: type: Plain text
en: Guix can be smart enough to check for updates on systems it knows.  It can report outdated package definitions with
sk: Guix môže byť dostatočne múdry na to, aby vyhľadal aktualizácie v systémoch, ktoré pozná.  To, ktoré balíky sú zastarané možno zistiť pomocou

note: type: Plain text
en: In most cases, updating a package to a newer version requires little more than changing the version number and the checksum.  Guix can do that automatically as well:
sk: Vo väčšine prípadov vyžaduje aktualizácia balíka na novšiu verziu len o niečo viac ako zmeniť číslo verzie a kontrolný súčet.  Aj toto môže Guix vykonať automaticky:

note: type: subsubsection
en: Inheritance
sk: Dedičnosť

note: type: Plain text
en: If you've started browsing the existing package definitions, you might have noticed that a significant number of them have a @code{inherit} field:
sk: Ak ste si už začali prezerať zadania jestvujúcich balíkov, možno ste si všimli, že niektoré z nich obsahujú pole @code{inherit}:

note: type: Plain text
en: All unspecified fields are inherited from the parent package.  This is very convenient to create alternative packages, for instance with different source, version or compilation options.
sk: Všetky neupresnené polia sú zdedené z nadradeného balíka.  Je to veľmi užitočné na vytváranie obmien balíkov, napr. s odlišným zdrojom, verziou alebo voľbami zostavenia.

note: type: subsection
en: Getting help
sk: Získavanie pomoci

note: type: Plain text
en: Sadly, some applications can be tough to package.  Sometimes they need a patch to work with the non-standard file system hierarchy enforced by the store.  Sometimes the tests won't run properly.  (They can be skipped but this is not recommended.)  Other times the resulting package won't be reproducible.
sk: Nanešťastie, zadanie balíka môže byť pre niektoré aplikácie veľmi zložité.  Niekedy je potrebná záplata, aby mohla aplikácia fungovať v neobyčajnom systéme súborov úložiska. Niekedy sa zase sústava testov nespúšťa správne (môžete ich preskočiť ale neodporúča sa to).  Inokedy nie je výsledný balík opakovateľný.

note: type: Plain text
en: Should you be stuck, unable to figure out how to fix any sort of packaging issue, don't hesitate to ask the community for help.
sk: Keď už neviete ako ďalej a nie ste schopní prísť na to, ako vyriešiť nejakú ťažkosť so zadávaním balíka, neváhajte požiadať o pomoc spoločenstvo.

note: type: Plain text
en: See the @uref{https://www.gnu.org/software/guix/contact/, Guix homepage} for information on the mailing lists, IRC, etc.
sk: Viď @uref{https://www.gnu.org/software/guix/contact/, Guix homepage} pre podrobnosti o elektronických konferenciách, IRC, atď.

note: type: subsection
en: Conclusion
sk: Záver

note: type: Plain text
en: This tutorial was a showcase of the sophisticated package management that Guix boasts.  At this point we have mostly restricted this introduction to the @code{gnu-build-system} which is a core abstraction layer on which more advanced abstractions are based.
sk: Tento návod vám predviedol vyumelkovanú správu balíkov, ktorou sa Guix chváli.  V tejto chvíli sme tento úvod zúžili na @code{gnu-build-system} predstavujúci ústrednú abstrakčnú vrstvu, na ktorej sú založené pokročilejšie abstrakčné vrstvy.

note: type: Plain text
en: Where do we go from here? Next we ought to dissect the innards of the build system by removing all abstractions, using the @code{trivial-build-system}: this should give us a thorough understanding of the process before investigating some more advanced packaging techniques and edge cases.
sk: Kam teraz? Ďalej by sme si mali posvietiť na vnútorné fungovanie zostavovacích systémov vynechajúc všetky abstrakčné vrstvy prostredníctvom @code{trivial-build-system}. Malo by nám to umožniť lepšie porozumieť postupu zostavenia, skôr ako sa dostaneme k pokročilejším postupom a výnimkám.

note: type: Plain text
en: Other features worth exploring are the interactive editing and debugging capabilities of Guix provided by the Guile REPL@.
sk: Ďalšie funkcie, ktoré sa oplatí preskúmať, sú interaktívna úprava a možnosti ladenia Guixu poskytované cez Guile REPL@.

note: type: Plain text
en: Those fancy features are completely optional and can wait; now is a good time to take a well-deserved break.  With what we've introduced here you should be well armed to package lots of programs.  You can get started right away and hopefully we will see your contributions soon!
sk: Tieto pokročilé funkcie sú len doplnkové a môžu počkať. Teraz je ten správny čas na zaslúženú prestávku.  S tým, čo sme si ukázali, by ste si mali vystačiť pri zadávaní balíkov pre mnoho programov.  Môžete sa do toho hneď pustiť a dúfame, že nás vašim príspevkom potešíte už čoskoro!

note: type: subsection
en: References
sk: Odkazy

note: type: itemize
en: The @uref{https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html, package reference in the manual}
sk: @uref{https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html, odvolávka na „package“ v príručke}

note: type: itemize
en: @uref{https://gitlab.com/pjotrp/guix-notes/blob/master/HACKING.org, Pjotr’s hacking guide to GNU Guix}
sk: @uref{https://gitlab.com/pjotrp/guix-notes/blob/master/HACKING.org, Pjotrova príručka na prispôsobenie GNU Guix}

note: type: itemize
en: @uref{https://www.gnu.org/software/guix/guix-ghm-andreas-20130823.pdf, ``GNU Guix: Package without a scheme!''}, by Andreas Enge
sk: @uref{https://www.gnu.org/software/guix/guix-ghm-andreas-20130823.pdf, „GNU Guix: Package without a scheme!“}, od Andreasa Engeho

note: type: Plain text
en: Guix offers a flexible language for declaratively configuring your Guix System.  This flexibility can at times be overwhelming.  The purpose of this chapter is to demonstrate some advanced configuration concepts.
sk: Guix ponúka všestranný jazyk na deklaratívne nastavenie vášho systému Guix.  Táto všestrannosť sa môže niekedy zdať nadmerná.  Účelom tohto oddielu je predstaviť niektoré pokročilé spôsoby nastavenia.

note: type: Plain text
en: @pxref{System Configuration,,, guix, GNU Guix Reference Manual} for a complete reference.
sk: Viď úplnú odvolávku v @pxref{System Configuration,,, guix, GNU Guix Reference Manual}.

note: type: Plain text
en: While the Guix manual explains auto-login one user to @emph{all} TTYs ( @pxref{auto-login to TTY,,, guix, GNU Guix Reference Manual}), some might prefer a situation, in which one user is logged into one TTY with the other TTYs either configured to login different users or no one at all.  Note that one can auto-login one user to any TTY, but it is usually advisable to avoid @code{tty1}, which, by default, is used to log warnings and errors.
sk: Zatiaľ čo príručka pre Guix popisuje automatické prihlásenie jedného používateľa ku @emph{všetkým} TTY (@pxref{auto-login to TTY,,, guix, GNU Guix Reference Manual}), mohol by vám viac vyhovovať stav, keď je jeden používateľ pripojený k jednému TTY a ostatné TTY sú nastavené na prihlasovanie ďalších používateľov alebo nikoho.  Všimnite si, že jedného používateľa je možné automaticky prihlásiť k akémukoľvek TTY. Avšak, je lepšie vynechať @code{tty1}, ktorý je predvolene využívaný na zobrazovanie varovaných a chybových hlásení.

note: type: Plain text
en: Here is how one might set up auto login for one user to one tty:
sk: Takto je možné nastaviť automatické prihlásenie jedného používateľa k jednému TTY:

note: type: Plain text
en: One could also @code{compose} (@pxref{Higher-Order Functions,,, guile, The Guile Reference Manual}) @code{auto-login-to-tty} to login multiple users to multiple ttys.
sk: Tiež je možné použiť @code{compose} (@pxref{Higher-Order Functions,,, guile, The Guile Reference Manual}) s @code{auto-login-to-tty} pre prihlásenie viacerých používateľov k viacerým TTY.

note: type: Plain text
en: Finally, here is a note of caution.  Setting up auto login to a TTY, means that anyone can turn on your computer and run commands as your regular user.  However, if you have an encrypted root partition, and thus already need to enter a passphrase when the system boots, auto-login might be a convenient option.
sk: Varovanie na koniec.  Nastavenie automatického prihlásenia k TTY znamená, že ktokoľvek môže zapnúť váš počítač a spúšťať príkazy ako zvyčajný používateľ.  Hoci, ak používate zašifrovaný koreňový systém a pri spustení systému je nutné zadať heslo, automatické prihlásenie predstavuje praktickú možnosť.

note: type: Plain text
en: Guix is, at its core, a source based distribution with substitutes (@pxref{Substitutes,,, guix, GNU Guix Reference Manual}), and as such building packages from their source code is an expected part of regular package installations and upgrades.  Given this starting point, it makes sense that efforts are made to reduce the amount of time spent compiling packages, and recent changes and upgrades to the building and distribution of substitutes continues to be a topic of discussion within Guix.
sk: Guix je, vo svojom jadre, distribúcia založená na zdrojových súboroch a náhradách (@pxref{Substitutes,,, guix, GNU Guix Reference Manual}).  Zostavovanie balíkov z ich zdrojových súborov je teda prirodzenou súčasťou inštalácie a aktualizácie balíkov.  Vzhľadom na túto skutočnosť dáva zmysel snaha o zníženie množstva času potrebného na zostavenie balíkov a nedávne zmeny v zostavovaní a šírení náhrad sú aj naďalej súčasťou rozhovorov vrámci projektu Guix.

note: type: Plain text
en: The kernel, while not requiring an overabundance of RAM to build, does take a rather long time on an average machine.  The official kernel configuration, as is the case with many GNU/Linux distributions, errs on the side of inclusiveness, and this is really what causes the build to take such a long time when the kernel is built from source.
sk: Aj keď nevyžaduje veľké množstvo pamäte RAM, zostavenie jadra na priemerných počítačoch môže trvať veľmi dlho.  Oficiálne nastavenie jadra, tak ako je to v prípade mnohých iných distribúcií GNU/Linuxu, sa prikláňa k širšej ponuke súčastí a to je to, čo spôsobuje, že zostavenie jadra zo zdrojových súborov trvá tak dlho.

note: type: Plain text
en: The Linux kernel, however, can also just be described as a regular old package, and as such can be customized just like any other package.  The procedure is a little bit different, although this is primarily due to the nature of how the package definition is written.
sk: Avšak, aj samotné jadro Linuxu možno opísať ako balík a teda prispôsobiť ho rovnako ako hociktorý iný balík.  Postup je mierne odlišný, aj keď hlavne kvôli tomu ako je zadanie balíka napísané.

note: type: Plain text
en: The @code{linux-libre} kernel package definition is actually a procedure which creates a package.
sk: Balík jadra @code{linux-libre} je vlastne funkcia tvoriaca balík.

note: type: lisp
en: (define* (make-linux-libre* version gnu-revision source supported-systems
                                #:key
                                (extra-version #f)
                                ;; A function that takes an arch and a variant.
                                ;; See kernel-config for an example.
                                (configuration-file #f)
                                (defconfig "defconfig")
                                (extra-options %default-extra-linux-options))
      ...)
sk: (define* (make-linux-libre* version gnu-revision source supported-systems
                                #:key
                                (extra-version #f)
                                ;; Funkcia vyžadujúca označenie a druh architektúry.
                                ;; Viď príklad v kernel-config.
                                (configuration-file #f)
                                (defconfig "defconfig")
                                (extra-options %default-extra-linux-options))
      ...)

note: type: Plain text
en: The current @code{linux-libre} package is for the 5.15.x series, and is declared like this:
sk: Terajší balík @code{linux-libre} pre vydania 5.15.x je zadaný nasledovne:

note: type: Plain text
en: Any keys which are not assigned values inherit their default value from the @code{make-linux-libre} definition.  When comparing the two snippets above, notice the code comment that refers to @code{#:configuration-file}.  Because of this, it is not actually easy to include a custom kernel configuration from the definition, but don't worry, there are other ways to work with what we do have.
sk: Kľúče, ktoré nemajú pridelenú hodnotu dedia ich predvolenú hodnotu zo zadania @code{make-linux-libre}.  Pri porovnávaní vyššie uvedených úryvkov zdrojového kódu si všimnite komentár odvolávajúci sa na @code{#:configuration-file}.  Kvôli tomu vlastne nie je jednoduché zahrnúť do zadania svoje vlastné nastavenie jadra, ale nezúfajte, pretože jestvujú ďalšie spôsoby ako pracovať s tým čo máme.

note: type: Plain text
en: There are two ways to create a kernel with a custom kernel configuration.  The first is to provide a standard @file{.config} file during the build process by including an actual @file{.config} file as a native input to our custom kernel.  The following is a snippet from the custom @code{'configure} phase of the @code{make-linux-libre} package definition:
sk: Jestvujú dva spôsoby ako vytvoriť jadro s vlastným nastavením.  Prvý je poskytnúť zvyčajný súbor @file{.config} počas zostavenia zahrnutím tohto súboru do pôvodných vstupov nášho vlastného jadra.  Nižšie je uvedený úryvok kódu vlastného @code{'configure} kroku zo zadania balíka @code{make-linux-libre}:

note: type: lisp
en:   ;; Use a custom kernel configuration file or a default
      ;; configuration file.
      (if config
          (begin
            (copy-file config ".config")
            (chmod ".config" #o666))
          (invoke "make" ,defconfig)))
sk:   ;; Použiť vlastný alebo predvolený súbor
      ;; nastavenia jadra.
      (if config
          (begin
            (copy-file config ".config")
            (chmod ".config" #o666))
          (invoke "make" ,defconfig)))

note: type: Plain text
en: Below is a sample kernel package.  The @code{linux-libre} package is nothing special and can be inherited from and have its fields overridden like any other package:
sk: Tu je príklad balíka jadra. Balík @code{linux-libre} nie je ničím výnimočný, môžeme ho zdediť a nahradiť jeho pôvodné polia ako pri hociktorom inom balíku:

note: type: Plain text
en: In the same directory as the file defining @code{linux-libre-E2140} is a file named @file{E2140.config}, which is an actual kernel configuration file.  The @code{defconfig} keyword of @code{make-linux-libre} is left blank here, so the only kernel configuration in the package is the one which was included in the @code{native-inputs} field.
sk: V rovnakom priečinku, kde je súbor zadávajúci @code{linux-libre-E2140} je aj súbor s názvom @file{E2140.config}, ktorý predstavuje súbor nastavenia jadra.  Kľúčové slovo @code{defconfig} funkcie @code{make-linux-libre} je tu ponechané prázdne, takže jediné nastavenie jadra v balíku je to, ktoré bolo zahrnuté do poľa @code{native-inputs}.

note: type: Plain text
en: The second way to create a custom kernel is to pass a new value to the @code{extra-options} keyword of the @code{make-linux-libre} procedure.  The @code{extra-options} keyword works with another function defined right below it:
sk: Druhý spôsob ako vytvoriť vlastné jadro je dať novú hodnotu kľúčovému slovu @code{extra-options} funkcie @code{make-linux-libre}.  Kľúčové slovo @code{extra-options} funguje s inou funkciou zadanou nižšie:

note: type: lisp
en: (define %default-extra-linux-options
      `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
       ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #true)
       ;; Modules required for initrd:
       ("CONFIG_NET_9P" . m)
       ("CONFIG_NET_9P_VIRTIO" . m)
       ("CONFIG_VIRTIO_BLK" . m)
       ("CONFIG_VIRTIO_NET" . m)
       ("CONFIG_VIRTIO_PCI" . m)
       ("CONFIG_VIRTIO_BALLOON" . m)
       ("CONFIG_VIRTIO_MMIO" . m)
       ("CONFIG_FUSE_FS" . m)
       ("CONFIG_CIFS" . m)
       ("CONFIG_9P_FS" . m)))
sk: (define %default-extra-linux-options
      `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
       ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #true)
       ;; Moduly potrebné pre initrd:
       ("CONFIG_NET_9P" . m)
       ("CONFIG_NET_9P_VIRTIO" . m)
       ("CONFIG_VIRTIO_BLK" . m)
       ("CONFIG_VIRTIO_NET" . m)
       ("CONFIG_VIRTIO_PCI" . m)
       ("CONFIG_VIRTIO_BALLOON" . m)
       ("CONFIG_VIRTIO_MMIO" . m)
       ("CONFIG_FUSE_FS" . m)
       ("CONFIG_CIFS" . m)
       ("CONFIG_9P_FS" . m)))

note: type: Plain text
en: And in the custom configure script from the `make-linux-libre` package:
sk: A vo vlastnom „configure“ skripte balíka „make-linux-libre“:

note: type: lisp
en: ;; Appending works even when the option wasn't in the
    ;; file.  The last one prevails if duplicated.
    (let ((port (open-file ".config" "a"))
          (extra-configuration ,(config->string extra-options)))
      (display extra-configuration port)
      (close-port port))
sk: ;; Vkladanie na koniec funguje aj keď voľba v súbore nebola.
    ;; Pri viacnásobnom uvedení prevažuje to posledné.
    (let ((port (open-file ".config" "a"))
          (extra-configuration ,(config->string extra-options)))
      (display extra-configuration port)
      (close-port port))

note: type: Plain text
en: So by not providing a configuration-file the @file{.config} starts blank, and then we write into it the collection of flags that we want.  Here's another custom kernel:
sk: Takže, neposkytnutie súboru nastavenia spôsobí, že je súbor @file{.config} spočiatku prázdny. Potom doň zapíšeme voľby, ktoré chceme.  Viď ďalšie vlastné zadanie jadra:

note: type: lisp
en: (define-public linux-libre-macbook41
      ;; XXX: Access the internal 'make-linux-libre*' procedure, which is
      ;; private and unexported, and is liable to change in the future.
      ((@@@@ (gnu packages linux) make-linux-libre*)
       (@@@@ (gnu packages linux) linux-libre-version)
       (@@@@ (gnu packages linux) linux-libre-gnu-revision)
       (@@@@ (gnu packages linux) linux-libre-source)
       '("x86_64-linux")
       #:extra-version "macbook41"
       #:extra-options %macbook41-config-options))
sk: (define-public linux-libre-macbook41
      ;; XXX: Prístup k funkcii „make-linux-libre*“, ktorá je súkromná,
      ;; neexportuje sa a v budúcnosti by sa mohla zmeniť.
      ((@@@@ (gnu packages linux) make-linux-libre*)
       (@@@@ (gnu packages linux) linux-libre-version)
       (@@@@ (gnu packages linux) linux-libre-gnu-revision)
       (@@@@ (gnu packages linux) linux-libre-source)
       '("x86_64-linux")
       #:extra-version "macbook41"
       #:extra-options %macbook41-config-options))

note: type: Plain text
en: In the above example @code{%file-systems} is a collection of flags enabling different file system support, @code{%efi-support} enables EFI support and @code{%emulation} enables a x86_64-linux machine to act in 32-bit mode also.  @code{%default-extra-linux-options} are the ones quoted above, which had to be added in since they were replaced in the @code{extra-options} keyword.
sk: V hore uvedenom príklade je @code{%file-systems} zbierkou volieb povoľujúcich podporu rôznych systémov súborov, @code{%efi-support} povoľuje podporu EFI a @code{%emulation} povoľuje strojom x86_64-linux pracovať v 32-bitovom režime.  Voľby @code{%default-extra-linux-options} sú tie citované vyššie, ktoré bolo treba pridať, keďže boli prepísané v kľúčovom slove @code{extra-options}.

note: type: Plain text
en: This all sounds like it should be doable, but how does one even know which modules are required for a particular system? Two places that can be helpful in trying to answer this question is the @uref{https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel, Gentoo Handbook} and the @uref{https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig, documentation from the kernel itself}.  From the kernel documentation, it seems that @code{make localmodconfig} is the command we want.
sk: Všetko toto znie veľmi dobre, ale ako zistiť, ktoré moduly vyžaduje určitý systém? Na túto otázku nám môžu pomôcť odpovedať dva zdroje: @uref{https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel, Príručka Gentoo} a @uref{https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig, dokumentácia samotného jadra}.  Podľa dokumentácie jadra sa zdá, že @code{make localmodconfig} je príkaz, ktorý hľadáme.

note: type: Plain text
en: In order to actually run @code{make localmodconfig} we first need to get and unpack the kernel source code:
sk: Skôr ako budeme môcť spustiť @code{make localmodconfig}, musíme stiahnuť a rozbaliť zdrojové súbory jadra:

note: type: Plain text
en: Once inside the directory containing the source code run @code{touch .config} to create an initial, empty @file{.config} to start with.  @code{make localmodconfig} works by seeing what you already have in @file{.config} and letting you know what you're missing.  If the file is blank then you're missing everything.  The next step is to run:
sk: V priečinku obsahujúcom zdrojové súbory spustite @code{touch .config} pre vytvorenie počiatočného prázdneho @file{.config} súboru.  @code{make localmodconfig} funguje tak, že zistí, čo ste už zadali do @file{.config} a povie vám, čo vám ešte chýba.  Ak je súbor prázdny, tak vám chýba všetko.  Ďalším krokom je spustiť:

note: type: Plain text
en: and note the output.  Do note that the @file{.config} file is still empty.  The output generally contains two types of warnings.  The first start with "WARNING" and can actually be ignored in our case.  The second read:
sk: a pozrite si výstup.  Všimnite si, že súbor @file{.config} je stále prázdny.  Výstup obvykle obsahuje dva druhy varovných správ.  Prvá začína slovom „WARNING“ a v našom prípade si ju nemusíme všímať.  Druhá správa nám hovorí, že:

note: type: Plain text
en: For each of these lines, copy the @code{CONFIG_XXXX_XXXX} portion into the @file{.config} in the directory, and append @code{=m}, so in the end it looks like this:
sk: Pre každý z týchto riadkov skopírujte časť @code{CONFIG_XXXX_XXXX} do @file{.config} súboru priečinka a pridajte @code{=m} tak, aby nakoniec vyzeral takto:

note: type: Plain text
en: After copying all the configuration options, run @code{make localmodconfig} again to make sure that you don't have any output starting with ``module''.  After all of these machine specific modules there are a couple more left that are also needed.  @code{CONFIG_MODULES} is necessary so that you can build and load modules separately and not have everything built into the kernel.  @code{CONFIG_BLK_DEV_SD} is required for reading from hard drives.  It is possible that there are other modules which you will need.
sk: Po skopírovaní všetkých volieb nastavenia znova spustite @code{make localmodconfig}, aby ste sa uistili, že výstup už neobsahuje žiadne správy začínajúce slovom „module“.  Okrem všetkých týchto modulov vzťahujúcich sa k stroju nám ostáva ešte niekoľko ďalších dôležitých modulov.  @code{CONFIG_MODULES} umožňuje zostavovať a načítavať moduly oddelene, aby nemuseli byť zabudované do jadra.  @code{CONFIG_BLK_DEV_SD} umožňuje čítať pevné disky.  Je tiež možné, že budete potrebovať aj iné moduly.

note: type: Plain text
en: This post does not aim to be a guide to configuring your own kernel however, so if you do decide to build a custom kernel you'll have to seek out other guides to create a kernel which is just right for your needs.
sk: Tento príspevok nemá za úlohu vás previesť nastavením vášho vlastného jadra. Ak sa rozhodnete zostaviť si vlastné jadro, budete si musieť nájsť iné návody na vytvorenie jadra, ktoré vám bude vyhovovať.

note: type: Plain text
en: The second way to setup the kernel configuration makes more use of Guix's features and allows you to share configuration segments between different kernels.  For example, all machines using EFI to boot have a number of EFI configuration flags that they need.  It is likely that all the kernels will share a list of file systems to support.  By using variables it is easier to see at a glance what features are enabled and to make sure you don't have features in one kernel but missing in another.
sk: Druhý spôsob nastavenia jadra využíva funkcie Guixu vo väčšej miere a umožňuje vám zdieľať časti nastavenia medzi rôznymi jadrami.  Napríklad, všetky stroje používajúce na zavádzanie EFI vyžadujú určitý počet volieb nastavenia EFI.  Je tiež pravdepodobné, že viaceré jadrá budú zdieľať podporu niekoľkých súborových systémov.  Použitím premenných je jednoduchšie spozorovať, ktoré súčasti sú povolené a uistiť sa, či nie sú niektoré z nich prítomné v jednom jadre ale v druhom chýbajú.

note: type: Plain text
en: Left undiscussed however, is Guix's initrd and its customization.  It is likely that you'll need to modify the initrd on a machine using a custom kernel, since certain modules which are expected to be built may not be available for inclusion into the initrd.
sk: Nepozreli sme sa však na initrd a jeho prispôsobenie.  Je pravdepodobné, že budete potrebovať prispôsobiť initrd na stroji s vlastným jadrom, keďže niektoré moduly nemusia byť dostupné pre zahrnutie do initrd.

note: type: Plain text
en: Historically, Guix System is centered around an @code{operating-system} structure.  This structure contains various fields ranging from the bootloader and kernel declaration to the services to install.
sk: Z dejinného pohľadu je systém Guix sústredený okolo štruktúry @code{operating-system}.  Táto štruktúra obsahuje rôzne polia počínajúc zadaním zavádzača a jadra až k službám, ktoré sa majú nainštalovať.

note: type: Plain text
en: Depending on the target machine, that can go from a standard @code{x86_64} machine to a small ARM single board computer such as the Pine64, the image constraints can vary a lot.  The hardware manufacturers will impose different image formats with various partition sizes and offsets.
sk: Požiadavky na obraz sa môžu značne líšiť v závislosti na cieľovom stroji, čo môže byť obvyklý @code{x86_64} alebo malý jednodoskový počítač ako Pine64. Výrobcovia technického vybavenia presadzujú rôzne formáty obrazov s rôznymi veľkosťami a umiestneniami oddielov.

note: type: Plain text
en: To create images suitable for all those machines, a new abstraction is necessary: that's the goal of the @code{image} record.  This record contains all the required information to be transformed into a standalone image, that can be directly booted on any target machine.
sk: Na vytváranie obrazov vhodných pre všetky tieto stroje je nevyhnutné ďalšie zovšeobecnenie, čo je cieľom záznamu @code{image}.  Tento záznam obsahuje všetky potrebné údaje k premene na samostatný obraz, ktorý je možno priamo zaviesť na hocijakom cieľovom stroji.

note: type: Plain text
en: This record contains the operating-system to instantiate. The @code{format} field defines the image type and can be @code{efi-raw}, @code{qcow2} or @code{iso9660} for instance. In the future, it could be extended to @code{docker} or other image types.
sk: Tento záznam obsahuje operačný systém na zostavenie. Pole @code{format} určuje druh obrazu a medzi jeho platné hodnoty patria @code{efi-raw}, @code{qcow2} alebo @code{iso9660}. V budúcnosti by sa mohli rozšíriť o @code{docker} a ďalšie druhy obrazov.

note: type: Plain text
en: A new directory in the Guix sources is dedicated to images definition. For now there are four files:
sk: Na zadávanie obrazov bol spomedzi zdrojových súborov Guixu vyhradený nový priečinok. Zatiaľ sa v ňom nachádzajú štyri súbory:

note: type: Plain text
en: Let's have a look to @file{pine64.scm}. It contains the @code{pine64-barebones-os} variable which is a minimal definition of an operating-system dedicated to the @b{Pine A64 LTS} board.
sk: Pozrime sa na @file{pine64.scm}. Obsahuje premennú @code{pine64-barebones-os} predstavujúcu najmenšie možné zadanie operačného systému určeného pre dosku @b{Pine A64 LTS}.

note: type: lisp
en: (define pine64-barebones-os
      (operating-system
       (host-name "vignemale")
       (timezone "Europe/Paris")
       (locale "en_US.utf8")
       (bootloader (bootloader-configuration
                    (bootloader u-boot-pine64-lts-bootloader)
                    (targets '("/dev/vda"))))
       (initrd-modules '())
       (kernel linux-libre-arm64-generic)
       (file-systems (cons (file-system
                            (device (file-system-label "my-root"))
                            (mount-point "/")
                            (type "ext4"))
                           %base-file-systems))
       (services (cons (service agetty-service-type
                                (agetty-configuration
                                 (extra-options '("-L")) ; no carrier detect
                                 (baud-rate "115200")
                                 (term "vt100")
                                 (tty "ttyS0")))
                       %base-services))))
sk: (define pine64-barebones-os
      (operating-system
       (host-name "vignemale")
       (timezone "Europe/Bratislava")
       (locale "sk_SK.utf8")
       (bootloader (bootloader-configuration
                    (bootloader u-boot-pine64-lts-bootloader)
                    (targets '("/dev/vda"))))
       (initrd-modules '())
       (kernel linux-libre-arm64-generic)
       (file-systems (cons (file-system
                            (device (file-system-label "moj-korenovy-system"))
                            (mount-point "/")
                            (type "ext4"))
                           %base-file-systems))
       (services (cons (service agetty-service-type
                                (agetty-configuration
                                 (extra-options '("-L")) ; bez zisťovania nosného signálu
                                 (baud-rate "115200")
                                 (term "vt100")
                                 (tty "ttyS0")))
                       %base-services))))

note: type: Plain text
en: The @code{kernel} and @code{bootloader} fields are pointing to packages dedicated to this board.
sk: Polia @code{kernel} a @code{bootloader} odkazujú na balíky určené pre túto dosku.

note: type: Plain text
en: Right below, the @code{pine64-image-type} variable is also defined.
sk: Tesne pod nimi je zadaná aj premenná @code{pine64-image-type}.

note: type: Plain text
en: It's using a record we haven't talked about yet, the @code{image-type} record, defined this way:
sk: Využíva záznam, o ktorom sme ešte nehovorili, a teda @code{image-type}, zadaný nasledovne:

note: type: lisp
en: (define-record-type* <image-type>
      image-type make-image-type
      image-type?
      (name           image-type-name) ;symbol
      (constructor    image-type-constructor)) ;<operating-system> -> <image>
sk: (define-record-type* <image-type>
      image-type make-image-type
      image-type?
      (name           image-type-name) ; znak
      (constructor    image-type-constructor)) ; <operating-system> -> <image>

note: type: Plain text
en: The main purpose of this record is to associate a name to a procedure transforming an @code{operating-system} to an image.  To understand why it is necessary, let's have a look to the command producing an image from an @code{operating-system} configuration file:
sk: Hlavným účelom tohto záznamu je priradiť názov funkcii pretvárajúcej @code{operating-system} na obraz.  Aby sme pochopili, prečo je to dôležité, pozrime sa na príkaz vytvárajúci obraz zo súboru nastavení @code{operating-system}:

note: type: example
en: guix system image my-os.scm
sk: guix system image moj-os.scm

note: type: Plain text
en: This command expects an @code{operating-system} configuration but how should we indicate that we want an image targeting a Pine64 board? We need to provide an extra information, the @code{image-type}, by passing the @code{--image-type} or @code{-t} flag, this way:
sk: Tento príkaz očakáva nastavenie druhu @code{operating-system}, ale ako by sme mali určiť, že chceme obraz pre dosku Pine64? Musíme poskytnúť doplňujúci údaj, @code{image-type}, pomocou voľby @code{--image-type} alebo @code{-t} a to takto:

note: type: example
en: guix system image --image-type=pine64-raw my-os.scm
sk: guix system image --image-type=pine64-raw moj-os.scm

note: type: quotation
en: Warning
sk: Upozornenie

note: type: itemize
en: Games.
sk: Hry.

note: type: subsection
en: Required packages
sk: Požadované balíky
