# SOME DESCRIPTIVE TITLE
# Copyright (C) 2021 the authors of Guix (msgids) and the following authors (msgstr)
# This file is distributed under the same license as the guix manual package.
# Nicolo Balzarotti <nicolo@nixo.xyz>, 2021.
# Nathan <nathan95@live.it>, 2021, 2022.
# Fernandez Alonso Alberto Mario <albialonso7@icloud.com>, 2022.
# Giacomo Leidi <therewasa@fishinthecalculator.me>, 2023.
# Marco Rimoldi <marco.rimoldi@pm.me>, 2024.
# francesco p lovergine <frankie@fsfe.org>, 2024.
# Florian Pelz <pelzflorian@pelzflorian.de>, 2024, 2025.
# Salvatore Cocuzza <info@salvatorecocuzza.it>, 2025.
msgid ""
msgstr ""
"Project-Id-Version: guix manual checkout\n"
"Report-Msgid-Bugs-To: bug-guix@gnu.org\n"
"POT-Creation-Date: 2026-03-15 03:18+0000\n"
"PO-Revision-Date: 2026-03-29 11:50+0000\n"
"Last-Translator: pelzflorian <pelzflorian@noreply.codeberg.org>\n"
"Language-Team: Italian <https://translate.codeberg.org/projects/guix/documentation-manual/it/>\n"
"Language: it\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Weblate 5.16.2\n"

msgid "Contributing"
msgstr "Contribuire"

msgid "This project is a cooperative effort, and we need your help to make it grow! Please get in touch with us on @email{guix-devel@@gnu.org} and @code{#guix} on the Libera Chat IRC network.  We welcome ideas, bug reports, patches, and anything that may be helpful to the project.  We particularly welcome help on packaging (@pxref{Packaging Guidelines})."
msgstr "Questo progetto è frutto di un lavoro cooperativo, e abbiamo bisogno del tuo aiuto per farlo crescere! Per favore mettiti in contatto con noi attraverso @email{guix-devel@@gnu.org} e @code{#guix} sulla rete IRC di Libera Chat.  Accogliamo idee, segnalazioni di bug, patch, e qualsiasi cosa possa dare una mano progetto.  È benvenuto in particolare un aiuto nel creare pacchetti (@pxref{Packaging Guidelines})."

msgid "code of conduct, of contributors"
msgstr "codice di condotta, dei contributori"

msgid "contributor covenant"
msgstr "patto del collaboratore"

msgid "We want to provide a warm, friendly, and harassment-free environment, so that anyone can contribute to the best of their abilities.  To this end our project uses a ``Contributor Covenant'', which was adapted from @url{https://contributor-covenant.org/}.  You can find a local version in the @file{CODE-OF-CONDUCT} file in the source tree."
msgstr "Vogliamo fornire un ambiente aperto, amichevole e senza molestie, in modo che chiunque possa contribuire al meglio delle proprie capacità.  A questo scopo il nostro progetto usa un ``Patto del collaboratore'', che è stato adattato da @url{https://contributor-covenant.org/}.  Puoi trovare una versione locale nel file @file{CODE-OF-CONDUCT} nell'albero dei sorgenti."

msgid "Contributors are not required to use their legal name in patches and on-line communication; they can use any name or pseudonym of their choice."
msgstr "I contributori non sono tenuti a usare il loro nome legale nelle patch e nelle comunicazioni on-line; possono usare qualsiasi nome o alias di loro scelta."

msgid "Requirements"
msgstr "Requisiti"

msgid "Software needed to build and run Guix."
msgstr "Software necessari per assemblare ed eseguire Guix."

msgid "Building from Git"
msgstr "Costruire da Git"

msgid "The latest and greatest."
msgstr "Il più recente e migliore."

msgid "Running the Test Suite"
msgstr "Eseguire la suite dei test"

msgid "Testing Guix."
msgstr "Provare Guix."

msgid "Running Guix Before It Is Installed"
msgstr "Eseguire Guix prima di installarlo"

msgid "Hacker tricks."
msgstr "Trucchi da hacker."

msgid "The Perfect Setup"
msgstr "L'impostazione perfetta"

msgid "The right tools."
msgstr "Gli strumenti giusti."

msgid "Source Tree Structure"
msgstr "Struttura dell'albero dei sorgenti"

msgid "Source code guided tour."
msgstr "Tour guidato nel codice sorgente."

msgid "Packaging Guidelines"
msgstr "Linee-guida per pacchettizzare"

msgid "Growing the distribution."
msgstr "Gli strumenti giusti."

msgid "Coding Style"
msgstr "Stile del codice"

msgid "Hygiene of the contributor."
msgstr "Igiene del contributore."

msgid "Submitting Patches"
msgstr "Invia delle patches"

msgid "Share your work."
msgstr "Condividi il tuo lavoro."

msgid "Tracking Bugs and Changes"
msgstr "Tracciare bug e modifiche"

msgid "Keeping it all organized."
msgstr "Tenere il tutto organizzato."

msgid "Teams"
msgstr "Gruppi"

msgid "Coordinating efforts."
msgstr "Coordinare gli sforzi."

msgid "Making Decisions"
msgstr "Prendere decisioni"

msgid "Collectively choosing the way forward."
msgstr "Scegliere collettivamente la strada da seguire."

msgid "Commit Access"
msgstr "Acesso commit"

msgid "Pushing to the official repository."
msgstr "Pushing sul repository ufficiale."

msgid "Reviewing the Work of Others"
msgstr "Commentare il lavoro di altri"

msgid "Some guidelines for sharing reviews."
msgstr "Alcune linee-guida per condividere commenti."

msgid "Updating the Guix Package"
msgstr "Aggiornamento del pacchetto Guix"

msgid "Updating the Guix package definition."
msgstr "Aggiornamento della definizione del pacchetto Guix."

msgid "Deprecation Policy"
msgstr "logica di deprecazione"

msgid "Commitments and tools for deprecation."
msgstr "Impegni e strumenti per la deprecazione."

msgid "Writing Documentation"
msgstr "Scrivere documentazione"

msgid "Improving documentation in GNU Guix."
msgstr "Migliorare la documentazione di GNU Guix."

msgid "Translating Guix"
msgstr "Tradurre Guix"

msgid "Make Guix speak your native language."
msgstr "Fai in modo che Guix parli la tua lingua madre."

msgid "Contributing to Guix's Infrastructure"
msgstr "Contribuire all'infrastruttura di Guix"

msgid "Make Guix ecosystem work better."
msgstr "Migliorare il funzionamento dell'ecosistema Guix."

msgid "You can easily hack on Guix itself using Guix and Git, which we use for version control (@pxref{Building from Git})."
msgstr "Puoi facilmente hackerare su Guix stesso usando Guix e Git, che usiamo per il controllo di versione (@pxref{Building from Git})."

msgid "But when packaging Guix for foreign distros or when bootstrapping on systems without Guix, and if you decide to not just trust and install our readily made binary (@pxref{Binary Installation}), you can download a release version of our reproducible source tarball and read on."
msgstr "Ma quando si pacchettizza Guix per distribuzioni terze o quando si effettua il bootstrap su sistemi senza Guix, e se decidi di non fidarti e installare il nostro binario già pronto (@pxref{Binary Installation}), puoi scaricare una versione di rilascio del nostro tarball sorgente riproducibile e continuare a leggere."

msgid "This section lists requirements when building Guix from source.  The build procedure for Guix is the same as for other GNU software, and is not covered here.  Please see the files @file{README} and @file{INSTALL} in the Guix source tree for additional details."
msgstr "Questa sezione elenca i requisiti per costruire Guix dai sorgenti. La procedura di compilazione per Guix è la stessa di altri software GNU, e non è trattata qui. Per maggiori dettagli, fare riferimento ai file @file{README} e @file{INSTALL} nell'albero dei sorgenti di Guix."

msgid "official website"
msgstr "sito web ufficiale"

msgid "GNU Guix is available for download from its website at @url{https://guix.gnu.org}."
msgstr "GNU Guix è disponibile per il download dal suo sito web a @url{https://guix.gnu.org}."

msgid "GNU Guix depends on the following packages:"
msgstr "GNU Guix dipende dai seguenti pacchetti:"

msgid "@url{https://gnu.org/software/guile/, GNU Guile}, version 3.0.x,"
msgstr "@url{https://gnu.org/software/guile/, GNU Guile}, versione 3.0.x,"

msgid "@url{https://codeberg.org/guile-gcrypt/guile-gcrypt, Guile-Gcrypt}, version"
msgstr "@url{https://codeberg.org/guile-gcrypt/guile-gcrypt, Guile-Gcrypt}, versione"

msgid "0.1.0 or later;"
msgstr "0.1.0 o successiva;"

msgid "@uref{https://gitlab.com/gnutls/guile/, Guile-GnuTLS} (@pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile})@footnote{The Guile bindings to @uref{https://gnutls.org/, GnuTLS} were distributed as part of GnuTLS until version 3.7.8 included.};"
msgstr "@uref{https://gitlab.com/gnutls/guile/, Guile-GnuTLS} (@pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile})@footnote{I collegamenti Guile a @uref{https://gnutls.org/, GnuTLS} erano distribuiti come parte di GnuTLS fino alla versione 3.7.8 inclusa.};"

msgid "@uref{https://codeberg.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, version 0.1.0 or later;"
msgstr "@uref{https://codeberg.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, versione 0.1.0 o successiva;"

msgid "version 0.1.0 or later;"
msgstr "versione 0.1.0 o successiva;"

msgid "@uref{https://codeberg.org/guile-compression/guile-lzlib, Guile-lzlib};"
msgstr "@uref{https://codeberg.org/guile-compression/guile-lzlib, Guile-lzlib};"

msgid "@uref{https://www.nongnu.org/guile-avahi/, Guile-Avahi};"
msgstr "@uref{https://www.nongnu.org/guile-avahi/, Guile-Avahi};"

msgid "@uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, version 0.10.0 or later;"
msgstr "@uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, versione 0.10.0 o successiva;"

msgid "@uref{https://git-scm.com, Git} (yes, both!);"
msgstr "@uref{https://git-scm.com, Git} (sì, entrambi!);"

msgid "@uref{https://github.com/aconchillo/guile-json, Guile-JSON}"
msgstr "@uref{https://github.com/aconchillo/guile-json, Guile-JSON}"

msgid "4.3.0 or later;"
msgstr "4.3.0 o successiva;"

msgid "@url{https://www.gnu.org/software/make/, GNU Make}."
msgstr "@url{https://www.gnu.org/software/make/, GNU Make}."

msgid "The following dependencies are optional:"
msgstr "Le seguenti dipendenze sono opzionali:"

msgid "Support for build offloading (@pxref{Daemon Offload Setup}) and @command{guix copy} (@pxref{Invoking guix copy}) depends on @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH}, version 0.13.0 or later."
msgstr "Il supporto per il build offloading (@pxref{Daemon Offload Setup}) e @command{guix copy} (@pxref{Invoking guix copy}) dipende da @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH}, versione 0.13.0 o successiva."

msgid "@uref{https://codeberg.org/guile-compression/guile-zstd, Guile-zstd}, for zstd compression and decompression in @command{guix publish} and for substitutes (@pxref{Invoking guix publish})."
msgstr "@uref{https://codeberg.org/guile-compression/guile-zstd, Guile-zstd}, per la compressione e decompressione zstd in @command{guix publish} e per i sostituti (@pxref{Invoking guix publish})."

msgid "@uref{https://ngyro.com/software/guile-semver.html, Guile-Semver} for the @code{crate} importer (@pxref{Invoking guix import})."
msgstr "@uref{https://ngyro.com/software/guile-semver.html, Guile-Semver} per l'importatore @code{crate} (@pxref{Invoking guix import})."

msgid "@uref{https://www.nongnu.org/guile-lib/doc/ref/htmlprag/, Guile-Lib} for the @code{go} importer (@pxref{Invoking guix import}) and for some of the ``updaters'' (@pxref{Invoking guix refresh})."
msgstr "@uref{https://www.nongnu.org/guile-lib/doc/ref/htmlprag/, Guile-Lib} per l'importatore @code{go} (@pxref{Invoking guix import}) e per alcuni degli ``aggiornatori'' (@pxref{Invoking guix refresh})."

msgid "When @url{http://www.bzip.org, libbz2} is available, @command{guix-daemon} can use it to compress build logs."
msgstr "Quando @url{http://www.bzip.org, libbz2} è disponibile, @command{guix-daemon} può usarla per comprimere i log di compilazione."

msgid "Unless @option{--disable-daemon} was passed to @command{configure}, the following packages are also needed:"
msgstr "A meno che @option{--disable-daemon} non sia stato passato a @command{configure}, sono necessari anche i seguenti pacchetti:"

msgid "@url{https://gnupg.org/, GNU libgcrypt};"
msgstr "@url{https://gnupg.org/, GNU libgcrypt};"

msgid "@url{https://sqlite.org, SQLite 3};"
msgstr "@url{https://sqlite.org, SQLite 3};"

msgid "@url{https://gcc.gnu.org, GCC's g++}, with support for the"
msgstr "@url{https://gcc.gnu.org, il g++ di GCC}, con supporto per lo"

msgid "C++11 standard."
msgstr "standard C++11."

msgid "authentication, of a Guix checkout"
msgstr "autenticazione, di un checkout Guix"

msgid "How do you ensure that you obtained a genuine copy of the repository? To do that, run @command{guix git authenticate}, passing it the commit and OpenPGP fingerprint of the @dfn{channel introduction} (@pxref{Invoking guix git authenticate}):"
msgstr "Come assicurarti di avere una copia genuina del repository? Per farlo, esegui @command{guix git authenticate}, passandogli il commit e l'impronta OpenPGP della @dfn{channel introduction} (@pxref{Invoking guix git authenticate}):"

msgid ""
"git fetch origin keyring:keyring\n"
"guix git authenticate 9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"
msgstr ""
"git fetch origin keyring:keyring\n"
"guix git authenticate 9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"

msgid "This command completes with exit code zero on success; it prints an error message and exits with a non-zero code otherwise."
msgstr "Questo comando termina con un codice di uscita zero in caso di successo; altrimenti, stampa un messaggio di errore ed esce con un codice diverso da zero."

msgid "As you can see, there is a chicken-and-egg problem: you first need to have Guix installed.  Typically you would install Guix System (@pxref{System Installation}) or Guix on top of another distro (@pxref{Binary Installation}); in either case, you would verify the OpenPGP signature on the installation medium.  This ``bootstraps'' the trust chain."
msgstr "Come si può vedere, c'è un problema dell'uovo e della gallina: è prima necessario avere Guix installato. Tipicamente, si installerebbe Guix System (@pxref{System Installation}) o Guix sopra un'altra distribuzione (@pxref{Binary Installation}); in entrambi i casi, si verificherebbe la firma OpenPGP sul supporto di installazione. Questo dà inizio alla catena di fiducia."

msgid "The easiest way to set up a development environment for Guix is, of course, by using Guix! The following command starts a new shell where all the dependencies and appropriate environment variables are set up to hack on Guix:"
msgstr "Il modo più semplice per impostare un ambiente di sviluppo per Guix è, naturalmente, usare Guix! Il seguente comando avvia una nuova shell dove tutte le dipendenze e le variabili d'ambiente appropriate sono impostate per hackerare su Guix:"

msgid "guix shell -D guix -CPW\n"
msgstr "guix shell -D guix -CPW\n"

msgid "or even, from within a Git worktree for Guix:"
msgstr "o anche, da un albero di lavoro Git per Guix:"

msgid "If @option{-C} (short for @option{--container}) is not supported on your system, try @command{--pure} instead of @option{-CPW}.  @xref{Invoking guix shell}, for more information on that command."
msgstr "Se @option{-C} (abbreviazione di @option{--container}) non è supportato sul tuo sistema, prova @command{--pure} invece di @option{-CPW}. @xref{Invoking guix shell}, per maggiori informazioni su questo comando."

msgid "If you are unable to use Guix when building Guix from a checkout, the following are the required packages in addition to those mentioned in the installation instructions (@pxref{Requirements})."
msgstr "Se non sei in grado di usare Guix quando compili Guix da un checkout, i seguenti sono i pacchetti richiesti in aggiunta a quelli menzionati nelle istruzioni di installazione (@pxref{Requirements})."

msgid "@url{https://gnu.org/software/autoconf/, GNU Autoconf};"
msgstr "@url{https://gnu.org/software/autoconf/, GNU Autoconf};"

msgid "@url{https://gnu.org/software/automake/, GNU Automake};"
msgstr "@url{https://gnu.org/software/automake/, GNU Automake};"

msgid "@url{https://gnu.org/software/gettext/, GNU Gettext};"
msgstr "@url{https://gnu.org/software/gettext/, GNU Gettext};"

msgid "@url{https://gnu.org/software/texinfo/, GNU Texinfo};"
msgstr "@url{https://gnu.org/software/texinfo/, GNU Texinfo};"

msgid "@url{https://www.graphviz.org/, Graphviz};"
msgstr "@url{https://www.graphviz.org/, Graphviz};"

msgid "@url{https://www.gnu.org/software/help2man/, GNU Help2man (optional)}."
msgstr "@url{https://www.gnu.org/software/help2man/, GNU Help2man (opzionale)}."

msgid "From there you can generate the build system infrastructure using Autoconf and Automake:"
msgstr "Da lì puoi generare l'infrastruttura del sistema di compilazione usando Autoconf e Automake:"

msgid "./bootstrap\n"
msgstr "./bootstrap\n"

msgid "If you get an error like this one:"
msgstr "Se ricevi un errore come questo:"

msgid "configure.ac:46: error: possibly undefined macro: PKG_CHECK_MODULES\n"
msgstr "configure.ac:46: error: possibly undefined macro: PKG_CHECK_MODULES\n"

msgid "it probably means that Autoconf couldn’t find @file{pkg.m4}, which is provided by pkg-config.  Make sure that @file{pkg.m4} is available.  The same holds for the @file{guile.m4} set of macros provided by Guile.  For instance, if you installed Automake in @file{/usr/local}, it wouldn’t look for @file{.m4} files in @file{/usr/share}.  In that case, you have to invoke the following command:"
msgstr "probabilmente significa che Autoconf non è riuscito a trovare @file{pkg.m4}, che è fornito da pkg-config. Assicurati che @file{pkg.m4} sia disponibile. Lo stesso vale per il set di macro @file{guile.m4} fornito da Guile. Ad esempio, se hai installato Automake in @file{/usr/local}, non cercherà i file @file{.m4} in @file{/usr/share}. In tal caso, devi invocare il seguente comando:"

msgid "export ACLOCAL_PATH=/usr/share/aclocal\n"
msgstr "export ACLOCAL_PATH=/usr/share/aclocal\n"

msgid "@xref{Macro Search Path,,, automake, The GNU Automake Manual}, for more information."
msgstr "@xref{Macro Search Path,,, automake, The GNU Automake Manual}, per maggiori informazioni."

msgid "state directory"
msgstr "directory di stato"

msgid "localstatedir"
msgstr "localstatedir"

msgid "sysconfdir"
msgstr "sysconfdir"

msgid "Then, run:"
msgstr "Quindi, esegui:"

msgid "./configure\n"
msgstr "./configure\n"

msgid "Optionally, @code{--localstatedir} and @code{--sysconfdir} can also be provided as arguments.  By default, @code{localstatedir} is @file{/var} (@pxref{The Store}, for information about this) and @code{sysconfdir} is @file{/etc}.  Note that you will probably not run @command{make install} at the end (you don't have to) but it's still important to pass the right @code{localstatedir} and @code{sysconfdir} values, which get recorded in the @code{(guix config)} Guile module."
msgstr "Opzionalmente, @code{--localstatedir} e @code{--sysconfdir} possono essere forniti come argomenti. Per impostazione predefinita, @code{localstatedir} è @file{/var} (@pxref{The Store}, per informazioni a riguardo) e @code{sysconfdir} è @file{/etc}. Nota che probabilmente non eseguirai @command{make install} alla fine (non è necessario), ma è comunque importante passare i valori corretti di @code{localstatedir} e @code{sysconfdir}, che vengono registrati nel modulo Guile @code{(guix config)}."

msgid "Finally, you can build Guix and, if you feel so inclined, run the tests (@pxref{Running the Test Suite}):"
msgstr "Infine, puoi costruire Guix e, se te la senti, eseguire i test (@pxref{Running the Test Suite}):"

msgid ""
"make\n"
"make check\n"
msgstr ""
"make\n"
"make check\n"

msgid "If anything fails, take a look at installation instructions (@pxref{Installation}) or send a message to the @email{guix-devel@@gnu.org, mailing list}."
msgstr "Se qualcosa va storto, dai un'occhiata alle istruzioni di installazione (@pxref{Installation}) o invia un messaggio alla @email{guix-devel@@gnu.org, mailing list}."

msgid "From there on, you can authenticate all the commits included in your checkout by running:"
msgstr "Da qui in poi, puoi autenticare tutti i commit inclusi nel tuo checkout eseguendo:"

msgid ""
"guix git authenticate \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"
msgstr ""
"guix git authenticate \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"

msgid "The first run takes a couple of minutes, but subsequent runs are faster.  On subsequent runs, you can run the command without any arguments since the @dfn{introduction} (the commit ID and OpenPGP fingerprints above)  will have been recorded@footnote{This requires a recent version of Guix, from May 2024 or more recent.}:"
msgstr "La prima esecuzione richiede un paio di minuti, ma le esecuzioni successive sono più veloci. Nelle esecuzioni successive, puoi eseguire il comando senza argomenti poiché l'@dfn{introduction} (l'ID del commit e le impronte OpenPGP sopra) sarà stata registrata@footnote{Questo richiede una versione recente di Guix, da maggio 2024 o successiva.}:"

msgid "When your configuration for your local Git repository doesn't match the default one, you can provide the reference for the @code{keyring} branch @i{via} the @option{-k} option.  The following example assumes that you have a Git remote called @samp{myremote} pointing to the official repository:"
msgstr "Quando la configurazione del tuo repository Git locale non corrisponde a quella predefinita, puoi fornire il riferimento per il ramo @code{keyring} @i{via} l'opzione @option{-k}. L'esempio seguente presume che tu abbia un remote Git chiamato @samp{myremote} che punta al repository ufficiale:"

msgid ""
"guix git authenticate \\\n"
"  -k myremote/keyring \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"
msgstr ""
"guix git authenticate \\\n"
"  -k myremote/keyring \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"

msgid "@xref{Invoking guix git authenticate}, for more information on this command."
msgstr "@xref{Invoking guix git authenticate}, per maggiori informazioni su questo comando."

msgid "Note"
msgstr "Nota"

msgid "By default, hooks are installed such that @command{guix git authenticate} is invoked anytime you run @command{git pull} or @command{git push}."
msgstr "Per impostazione predefinita, gli hook sono installati in modo che @command{guix git authenticate} venga invocato ogni volta che esegui @command{git pull} o @command{git push}."

msgid "After updating the repository, @command{make} might fail with an error similar to the following example:"
msgstr "Dopo aver aggiornato il repository, @command{make} potrebbe fallire con un errore simile al seguente esempio:"

msgid ""
"error: failed to load 'gnu/packages/linux.scm':\n"
"ice-9/eval.scm:293:34: In procedure abi-check: #<record-type <origin>>: record ABI mismatch; recompilation needed\n"
msgstr ""
"error: failed to load 'gnu/packages/linux.scm':\n"
"ice-9/eval.scm:293:34: In procedure abi-check: #<record-type <origin>>: record ABI mismatch; recompilation needed\n"

msgid "This means that one of the record types that Guix defines (in this example, the @code{origin} record) has changed, and all of guix needs to be recompiled to take that change into account.  To do so, run @command{make clean-go} followed by @command{make}."
msgstr "Questo significa che uno dei tipi di record che Guix definisce (in questo esempio, il record @code{origin}) è cambiato, e tutto guix deve essere ricompilato per tenere conto di questa modifica. Per farlo, esegui @command{make clean-go} seguito da @command{make}."

msgid "Should @command{make} fail with an Automake error message after updating, you need to repeat the steps outlined in this section, commencing with @command{./bootstrap}."
msgstr "Se @command{make} fallisce con un messaggio di errore di Automake dopo un aggiornamento, è necessario ripetere i passaggi descritti in questa sezione, a partire da @command{./bootstrap}."

msgid "test suite"
msgstr "suite di test"

msgid "After a successful @command{configure} and @code{make} run, it is a good idea to run the test suite.  It can help catch issues with the setup or environment, or bugs in Guix itself---and really, reporting test failures is a good way to help improve the software.  To run the test suite, type:"
msgstr "Dopo un'esecuzione di successo di @command{configure} e @code{make}, è una buona idea eseguire la suite di test. Può aiutare a individuare problemi con la configurazione o l'ambiente, o bug in Guix stesso --- e, in realtà, segnalare i fallimenti dei test è un buon modo per contribuire a migliorare il software. Per eseguire la suite di test, digita:"

msgid "make check\n"
msgstr "make check\n"

msgid "Test cases can run in parallel: you can use the @code{-j} option of GNU@tie{}make to speed things up.  The first run may take a few minutes on a recent machine; subsequent runs will be faster because the store that is created for test purposes will already have various things in cache."
msgstr "I casi di test possono essere eseguiti in parallelo: puoi usare l'opzione @code{-j} di GNU@tie{}make per velocizzare. La prima esecuzione potrebbe richiedere alcuni minuti su una macchina recente; le esecuzioni successive saranno più veloci perché lo store creato per i test avrà già diverse cose in cache."

msgid "It is also possible to run a subset of the tests by defining the @code{TESTS} makefile variable as in this example:"
msgstr "È anche possibile eseguire un sottoinsieme dei test definendo la variabile del makefile @code{TESTS} come in questo esempio:"

msgid "make check TESTS=\"tests/store.scm tests/cpio.scm\"\n"
msgstr "make check TESTS=\"tests/store.scm tests/cpio.scm\"\n"

msgid "By default, tests results are displayed at a file level.  In order to see the details of every individual test cases, it is possible to define the @code{SCM_LOG_DRIVER_FLAGS} makefile variable as in this example:"
msgstr "Per impostazione predefinita, i risultati dei test sono visualizzati a livello di file. Per vedere i dettagli di ogni singolo caso di test, è possibile definire la variabile del makefile @code{SCM_LOG_DRIVER_FLAGS} come in questo esempio:"

msgid "make check TESTS=\"tests/base64.scm\" SCM_LOG_DRIVER_FLAGS=\"--brief=no\"\n"
msgstr "make check TESTS=\"tests/base64.scm\" SCM_LOG_DRIVER_FLAGS=\"--brief=no\"\n"

msgid "The underlying SRFI 64 custom Automake test driver used for the 'check' test suite (located at @file{build-aux/test-driver.scm}) also allows selecting which test cases to run at a finer level, via its @option{--select} and @option{--exclude} options.  Here's an example, to run all the test cases from the @file{tests/packages.scm} test file whose names start with ``transaction-upgrade-entry'':"
msgstr "Il driver di test personalizzato Automake SRFI 64 sottostante, utilizzato per la suite di test 'check' (che si trova in @file{build-aux/test-driver.scm}), consente anche di selezionare quali casi di test eseguire a un livello più fine, tramite le sue opzioni @option{--select} e @option{--exclude}. Ecco un esempio per eseguire tutti i casi di test dal file di test @file{tests/packages.scm} i cui nomi iniziano con ``transaction-upgrade-entry'':"

msgid ""
"export SCM_LOG_DRIVER_FLAGS=\"--select=^transaction-upgrade-entry\"\n"
"make check TESTS=\"tests/packages.scm\"\n"
msgstr ""
"export SCM_LOG_DRIVER_FLAGS=\"--select=^transaction-upgrade-entry\"\n"
"make check TESTS=\"tests/packages.scm\"\n"

msgid "Those wishing to inspect the results of failed tests directly from the command line can add the @option{--errors-only=yes} option to the @code{SCM_LOG_DRIVER_FLAGS} makefile variable and set the @code{VERBOSE} Automake makefile variable, as in:"
msgstr "Coloro che desiderano ispezionare i risultati dei test falliti direttamente dalla riga di comando possono aggiungere l'opzione @option{--errors-only=yes} alla variabile del makefile @code{SCM_LOG_DRIVER_FLAGS} e impostare la variabile del makefile di Automake @code{VERBOSE}, come in:"

msgid "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --errors-only=yes\" VERBOSE=1\n"
msgstr "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --errors-only=yes\" VERBOSE=1\n"

msgid "The @option{--show-duration=yes} option can be used to print the duration of the individual test cases, when used in combination with @option{--brief=no}:"
msgstr "L'opzione @option{--show-duration=yes} può essere usata per stampare la durata dei singoli casi di test, se usata in combinazione con @option{--brief=no}:"

msgid "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --show-duration=yes\"\n"
msgstr "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --show-duration=yes\"\n"

msgid "@xref{Parallel Test Harness,,,automake,GNU Automake} for more information about the Automake Parallel Test Harness."
msgstr "@xref{Parallel Test Harness,,,automake,GNU Automake} per maggiori informazioni sull'Automake Parallel Test Harness."

msgid "Upon failure, please email @email{bug-guix@@gnu.org} and attach the @file{test-suite.log} file.  Please specify the Guix version being used as well as version numbers of the dependencies (@pxref{Requirements}) in your message."
msgstr "In caso di fallimento, invia un'email a @email{bug-guix@@gnu.org} e allega il file @file{test-suite.log}. Specifica nel tuo messaggio la versione di Guix utilizzata e i numeri di versione delle dipendenze (@pxref{Requirements})."

msgid "Guix also comes with a whole-system test suite that tests complete Guix System instances.  It can only run on systems where Guix is already installed, using:"
msgstr "Guix include anche una suite di test a livello di sistema che testa istanze complete di Guix System. Può essere eseguita solo su sistemi dove Guix è già installato, usando:"

msgid "make check-system\n"
msgstr "make check-system\n"

msgid "or, again, by defining @code{TESTS} to select a subset of tests to run:"
msgstr "o, di nuovo, definendo @code{TESTS} per selezionare un sottoinsieme di test da eseguire:"

msgid "make check-system TESTS=\"basic mcron\"\n"
msgstr "make check-system TESTS=\"basic mcron\"\n"

msgid "These system tests are defined in the @code{(gnu tests @dots{})} modules.  They work by running the operating systems under test with lightweight instrumentation in a virtual machine (VM).  They can be computationally intensive or rather cheap, depending on whether substitutes are available for their dependencies (@pxref{Substitutes}).  Some of them require a lot of storage space to hold VM images."
msgstr "Questi test di sistema sono definiti nei moduli @code{(gnu tests @dots{})}. Funzionano eseguendo i sistemi operativi in prova con una strumentazione leggera in una macchina virtuale (VM). Possono essere computazionalmente intensivi o piuttosto economici, a seconda della disponibilità di sostituti per le loro dipendenze (@pxref{Substitutes}). Alcuni di essi richiedono molto spazio di archiviazione per contenere le immagini della VM."

msgid "If you encounter an error like:"
msgstr "Se incontri un errore come:"

msgid ""
"Compiling Scheme modules...\n"
"ice-9/eval.scm:142:16: In procedure compile-top-call:\n"
"error: all-system-tests: unbound variable\n"
"hint: Did you forget `(use-modules (gnu tests))'?\n"
msgstr ""
"Compiling Scheme modules...\n"
"ice-9/eval.scm:142:16: In procedure compile-top-call:\n"
"error: all-system-tests: unbound variable\n"
"hint: Did you forget `(use-modules (gnu tests))'?\n"

msgid "there may be inconsistencies in the work tree from previous builds.  To resolve this, try running @command{make clean-go} followed by @command{make}."
msgstr "potrebbero esserci delle incongruenze nell'albero di lavoro dovute a compilazioni precedenti. Per risolvere, prova a eseguire @command{make clean-go} seguito da @command{make}."

msgid "Again in case of test failures, please send @email{bug-guix@@gnu.org} all the details."
msgstr "Ancora una volta, in caso di fallimento dei test, invia tutti i dettagli a @email{bug-guix@@gnu.org}."

msgid "In order to keep a sane working environment, you will find it useful to test the changes made in your local source tree checkout without actually installing them.  So that you can distinguish between your ``end-user'' hat and your ``motley'' costume."
msgstr "Per mantenere un ambiente di lavoro sano, troverai utile testare le modifiche apportate nel tuo checkout locale dell'albero dei sorgenti senza installarle effettivamente. Così puoi distinguere tra il tuo ruolo di ``utente finale'' e il tuo costume ``arlecchino''."

msgid "To that end, all the command-line tools can be used even if you have not run @code{make install}.  To do that, you first need to have an environment with all the dependencies available (@pxref{Building from Git}), and then simply prefix each command with @command{./pre-inst-env} (the @file{pre-inst-env} script lives in the top build tree of Guix; @pxref{Building from Git} to generate it).  As an example, here is how you would build the @code{hello} package as defined in your working tree (this assumes @command{guix-daemon} is already running on your system; it's OK if it's a different version):"
msgstr "A tal fine, tutti gli strumenti a riga di comando possono essere usati anche se non hai eseguito @code{make install}. Per farlo, devi prima avere un ambiente con tutte le dipendenze disponibili (@pxref{Building from Git}), e poi semplicemente anteporre a ogni comando @command{./pre-inst-env} (lo script @file{pre-inst-env} si trova nella directory di compilazione principale di Guix; @pxref{Building from Git} per generarlo). Ad esempio, ecco come costruiresti il pacchetto @code{hello} come definito nel tuo albero di lavoro (questo presume che @command{guix-daemon} sia già in esecuzione sul tuo sistema; non importa se è una versione diversa):"

msgid "$ ./pre-inst-env guix build hello\n"
msgstr "$ ./pre-inst-env guix build hello\n"

msgid "Similarly, an example for a Guile session using the Guix modules:"
msgstr "Allo stesso modo, un esempio per una sessione Guile che usa i moduli Guix:"

msgid ""
"$ ./pre-inst-env guile -c '(use-modules (guix utils)) (pk (%current-system))'\n"
"\n"
msgstr ""
"$ ./pre-inst-env guile -c '(use-modules (guix utils)) (pk (%current-system))'\n"
"\n"

msgid ";;; (\"x86_64-linux\")\n"
msgstr ";;; (\"x86_64-linux\")\n"

msgid "REPL"
msgstr "REPL"

msgid "read-eval-print loop"
msgstr "read-eval-print loop"

msgid "@dots{} and for a REPL (@pxref{Using Guix Interactively}):"
msgstr "@dots{} e per un REPL (@pxref{Using Guix Interactively}):"

msgid ""
"$ ./pre-inst-env guile\n"
"scheme@@(guile-user)> ,use(guix)\n"
"scheme@@(guile-user)> ,use(gnu)\n"
"scheme@@(guile-user)> (define snakes\n"
"                       (fold-packages\n"
"                         (lambda (package lst)\n"
"                           (if (string-prefix? \"python\"\n"
"                                               (package-name package))\n"
"                               (cons package lst)\n"
"                               lst))\n"
"                         '()))\n"
"scheme@@(guile-user)> (length snakes)\n"
"$1 = 361\n"
msgstr ""
"$ ./pre-inst-env guile\n"
"scheme@@(guile-user)> ,use(guix)\n"
"scheme@@(guile-user)> ,use(gnu)\n"
"scheme@@(guile-user)> (define snakes\n"
"                       (fold-packages\n"
"                         (lambda (package lst)\n"
"                           (if (string-prefix? \"python\"\n"
"                                               (package-name package))\n"
"                               (cons package lst)\n"
"                               lst))\n"
"                         '()))\n"
"scheme@@(guile-user)> (length snakes)\n"
"$1 = 361\n"

msgid "If you are hacking on the daemon and its supporting code or if @command{guix-daemon} is not already running on your system, you can launch it straight from the build tree@footnote{The @option{-E} flag to @command{sudo} guarantees that @code{GUILE_LOAD_PATH} is correctly set such that @command{guix-daemon} and the tools it uses can find the Guile modules they need.}:"
msgstr "Se stai hackerando il demone e il suo codice di supporto o se @command{guix-daemon} non è già in esecuzione sul tuo sistema, puoi lanciarlo direttamente dall'albero di compilazione@footnote{Il flag @option{-E} a @command{sudo} garantisce che @code{GUILE_LOAD_PATH} sia impostato correttamente in modo che @command{guix-daemon} e gli strumenti che usa possano trovare i moduli Guile di cui hanno bisogno.}:"

msgid "$ sudo -E ./pre-inst-env guix-daemon --build-users-group=guixbuild\n"
msgstr "$ sudo -E ./pre-inst-env guix-daemon --build-users-group=guixbuild\n"

msgid "The @command{pre-inst-env} script sets up all the environment variables necessary to support this, including @env{PATH} and @env{GUILE_LOAD_PATH}."
msgstr "Lo script @command{pre-inst-env} imposta tutte le variabili d'ambiente necessarie per supportare questo, incluse @env{PATH} e @env{GUILE_LOAD_PATH}."

msgid "Note that @command{./pre-inst-env guix pull} does @emph{not} upgrade the local source tree; it simply updates the @file{~/.config/guix/current} symlink (@pxref{Invoking guix pull}).  Run @command{git pull} instead if you want to upgrade your local source tree."
msgstr "Nota che @command{./pre-inst-env guix pull} @emph{not} aggiorna l'albero dei sorgenti locale; aggiorna semplicemente il collegamento simbolico @file{~/.config/guix/current} (@pxref{Invoking guix pull}). Esegui invece @command{git pull} se vuoi aggiornare il tuo albero dei sorgenti locale."

msgid "Sometimes, especially if you have recently updated your repository, running @command{./pre-inst-env} will print a message similar to the following example:"
msgstr "A volte, specialmente se hai aggiornato di recente il tuo repository, l'esecuzione di @command{./pre-inst-env} stamperà un messaggio simile al seguente esempio:"

msgid ""
";;; note: source file /home/user/projects/guix/guix/progress.scm\n"
";;;       newer than compiled /home/user/projects/guix/guix/progress.go\n"
msgstr ""
";;; note: source file /home/user/projects/guix/guix/progress.scm\n"
";;;       newer than compiled /home/user/projects/guix/guix/progress.go\n"

msgid "This is only a note and you can safely ignore it.  You can get rid of the message by running @command{make -j4}.  Until you do, Guile will run slightly slower because it will interpret the code instead of using prepared Guile object (@file{.go}) files."
msgstr "Questa è solo una nota e puoi tranquillamente ignorarla. Puoi eliminare il messaggio eseguendo @command{make -j4}. Finché non lo fai, Guile funzionerà leggermente più lentamente perché interpreterà il codice invece di usare i file oggetto Guile preparati (@file{.go})."

msgid "You can run @command{make} automatically as you work using @command{watchexec} from the @code{watchexec} package.  For example, to build again each time you update a package file, run @samp{watchexec -w gnu/packages -- make -j4}."
msgstr "Puoi eseguire @command{make} automaticamente mentre lavori usando @command{watchexec} dal pacchetto @code{watchexec}. Ad esempio, per ricostruire ogni volta che aggiorni un file di pacchetto, esegui @samp{watchexec -w gnu/packages -- make -j4}."

msgid "Guile Studio"
msgstr "Guile Studio"

msgid "First step in your transition to Emacs."
msgstr "Primo passo nella tua transizione a Emacs."

msgid "Vim and NeoVim"
msgstr "Vim e NeoVim"

msgid "Geiser allows for interactive and incremental development from within Emacs: code compilation and evaluation from within buffers, access to on-line documentation (docstrings), context-sensitive completion, @kbd{M-.} to jump to an object definition, a REPL to try out your code, and more (@pxref{Introduction,,, geiser, Geiser User Manual}).  If you allow Emacs to load the @file{.dir-locals.el} file at the root of the project checkout, it will cause Geiser to automatically add the local Guix sources to the Guile load path."
msgstr "Geiser permette uno sviluppo interattivo e incrementale dall'interno di Emacs: compilazione e valutazione del codice dai buffer, accesso alla documentazione online (docstring), completamento contestuale, @kbd{M-.} per saltare alla definizione di un oggetto, un REPL per provare il tuo codice, e altro ancora (@pxref{Introduction,,, geiser, Geiser User Manual}). Se permetti a Emacs di caricare il file @file{.dir-locals.el} nella radice del checkout del progetto, Geiser aggiungerà automaticamente i sorgenti locali di Guix al percorso di caricamento di Guile."

msgid "To actually edit the code, Emacs already has a neat Scheme mode.  But in addition to that, you must not miss @url{https://www.emacswiki.org/emacs/ParEdit, Paredit}.  It provides facilities to directly operate on the syntax tree, such as raising an s-expression or wrapping it, swallowing or rejecting the following s-expression, etc."
msgstr "Per modificare effettivamente il codice, Emacs ha già una buona modalità Scheme. Ma in aggiunta a ciò, non puoi farti mancare @url{https://www.emacswiki.org/emacs/ParEdit, Paredit}. Fornisce funzionalità per operare direttamente sull'albero di sintassi, come elevare una s-expression o avvolgerla, inglobare o espellere la s-expression successiva, ecc."

msgid "code snippets"
msgstr "frammenti di codice"

msgid "templates"
msgstr "modelli"

msgid "reducing boilerplate"
msgstr "ridurre il boilerplate"

msgid "We also provide templates for common git commit messages and package definitions in the @file{etc/snippets} directory.  These templates can be used to expand short trigger strings to interactive text snippets. If you use @url{https://joaotavora.github.io/yasnippet/, YASnippet}, you may want to add the @file{etc/snippets/yas} snippets directory to the @var{yas-snippet-dirs} variable.  If you use @url{https://github.com/minad/tempel/, Tempel}, you may want to add the @file{etc/snippets/tempel/*} path to the @var{tempel-path} variable in Emacs."
msgstr "Forniamo anche dei modelli per i messaggi di commit git comuni e per le definizioni di pacchetto nella directory @file{etc/snippets}. Questi modelli possono essere usati per espandere brevi stringhe di attivazione in frammenti di testo interattivi. Se usi @url{https://joaotavora.github.io/yasnippet/, YASnippet}, potresti voler aggiungere la directory dei frammenti @file{etc/snippets/yas} alla variabile @var{yas-snippet-dirs}. Se usi @url{https://github.com/minad/tempel/, Tempel}, potresti voler aggiungere il percorso @file{etc/snippets/tempel/*} alla variabile @var{tempel-path} in Emacs."

msgid ""
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
";; @r{Yasnippet configuration}\n"
"(with-eval-after-load 'yasnippet\n"
"  (add-to-list 'yas-snippet-dirs \"~/src/guix/etc/snippets/yas\"))\n"
";; @r{Tempel configuration}\n"
"(with-eval-after-load 'tempel\n"
"   ;; Ensure tempel-path is a list -- it may also be a string.\n"
"   (unless (listp 'tempel-path)\n"
"     (setq tempel-path (list tempel-path)))\n"
"   (add-to-list 'tempel-path \"~/src/guix/etc/snippets/tempel/*\"))\n"
msgstr ""
";; @r{Assumendo che il checkout di Guix sia in ~/src/guix.}\n"
";; @r{Configurazione di Yasnippet}\n"
"(with-eval-after-load 'yasnippet\n"
"  (add-to-list 'yas-snippet-dirs \"~/src/guix/etc/snippets/yas\"))\n"
";; @r{Configurazione di Tempel}\n"
"(with-eval-after-load 'tempel\n"
"   ;; Assicura che tempel-path sia una lista -- potrebbe anche essere una stringa.\n"
"   (unless (listp 'tempel-path)\n"
"     (setq tempel-path (list tempel-path)))\n"
"   (add-to-list 'tempel-path \"~/src/guix/etc/snippets/tempel/*\"))\n"

msgid "The commit message snippets depend on @url{https://magit.vc/, Magit} to display staged files.  When editing a commit message type @code{add} followed by @kbd{TAB} to insert a commit message template for adding a package; type @code{update} followed by @kbd{TAB} to insert a template for updating a package; type @code{https} followed by @kbd{TAB} to insert a template for changing the home page URI of a package to HTTPS."
msgstr "I frammenti di messaggio di commit dipendono da @url{https://magit.vc/, Magit} per visualizzare i file in staging. Quando modifichi un messaggio di commit, digita @code{add} seguito da @kbd{TAB} per inserire un modello di messaggio di commit per l'aggiunta di un pacchetto; digita @code{update} seguito da @kbd{TAB} per inserire un modello per l'aggiornamento di un pacchetto; digita @code{https} seguito da @kbd{TAB} per inserire un modello per cambiare l'URI della pagina iniziale di un pacchetto a HTTPS."

msgid "The main snippet for @code{scheme-mode} is triggered by typing @code{package...} followed by @kbd{TAB}.  This snippet also inserts the trigger string @code{origin...}, which can be expanded further.  The @code{origin} snippet in turn may insert other trigger strings ending on @code{...}, which also can be expanded further."
msgstr "Lo snippet principale per @code{scheme-mode} viene attivato digitando @code{package...} seguito da @kbd{TAB}. Questo snippet inserisce anche la stringa di attivazione @code{origin...}, che può essere espansa ulteriormente. Lo snippet @code{origin} a sua volta può inserire altre stringhe di attivazione che terminano con @code{...}, che possono essere anch'esse espanse."

msgid "insert or update copyright"
msgstr "inserire o aggiornare copyright"

msgid "M-x guix-copyright"
msgstr "M-x guix-copyright"

msgid "M-x copyright-update"
msgstr "M-x copyright-update"

msgid "We additionally provide insertion and automatic update of a copyright in @file{etc/copyright.el}.  You may want to set your full name, mail, and load a file."
msgstr "Forniamo inoltre l'inserimento e l'aggiornamento automatico del copyright in @file{etc/copyright.el}. Potrebbe essere necessario impostare il proprio nome completo, l'email e caricare un file."

msgid ""
"(setq user-full-name \"Alice Doe\")\n"
"(setq user-mail-address \"alice@@mail.org\")\n"
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
"(load-file \"~/src/guix/etc/copyright.el\")\n"
msgstr ""
"(setq user-full-name \"Alice Doe\")\n"
"(setq user-mail-address \"alice@@mail.org\")\n"
";; @r{Assumendo che il checkout di Guix sia in ~/src/guix.}\n"
"(load-file \"~/src/guix/etc/copyright.el\")\n"

msgid "To insert a copyright at the current line invoke @code{M-x guix-copyright}."
msgstr "Per inserire un copyright alla riga corrente, invoca @code{M-x guix-copyright}."

msgid "To update a copyright you need to specify a @code{copyright-names-regexp}."
msgstr "Per aggiornare un copyright, è necessario specificare un @code{copyright-names-regexp}."

msgid ""
"(setq copyright-names-regexp\n"
"      (format \"%s <%s>\" user-full-name user-mail-address))\n"
msgstr ""
"(setq copyright-names-regexp\n"
"      (format \"%s <%s>\" user-full-name user-mail-address))\n"

msgid "You can check if your copyright is up to date by evaluating @code{M-x copyright-update}.  If you want to do it automatically after each buffer save then add @code{(add-hook 'after-save-hook 'copyright-update)} in Emacs."
msgstr "Puoi verificare se il tuo copyright è aggiornato valutando @code{M-x copyright-update}. Se vuoi farlo automaticamente dopo ogni salvataggio del buffer, aggiungi @code{(add-hook 'after-save-hook 'copyright-update)} in Emacs."

msgid "Guile Studio is a pre-configured Emacs with mostly everything you need to start hacking in Guile. If you are not familiar with Emacs it makes the transition easier for you."
msgstr "Guile Studio è un Emacs pre-configurato con quasi tutto ciò di cui hai bisogno per iniziare a hackerare in Guile. Se non hai familiarità con Emacs, rende la transizione più facile per te."

msgid "guix install guile-studio\n"
msgstr "guix install guile-studio\n"

msgid "Guile Studio comes with Geiser preinstalled and prepared for action."
msgstr "Guile Studio viene fornito con Geiser preinstallato e pronto all'azione."

msgid "guix install vim\n"
msgstr "guix install vim\n"

msgid "If you want to enjoy a similar development experience to that in the perfect setup, you should install several plugins to configure the editor. Vim (and NeoVim) have the equivalent to Paredit, @uref{https://www.vim.org/scripts/script.php?script_id=3998, @code{paredit.vim}}, that will help you with the structural editing of Scheme files (the support for very large files is not great, though)."
msgstr "Se vuoi godere di un'esperienza di sviluppo simile a quella della configurazione perfetta, dovresti installare diversi plugin per configurare l'editor. Vim (e NeoVim) hanno l'equivalente di Paredit, @uref{https://www.vim.org/scripts/script.php?script_id=3998, @code{paredit.vim}}, che ti aiuterà con la modifica strutturale dei file Scheme (il supporto per file molto grandi non è eccezionale, però)."

msgid "guix install vim-paredit\n"
msgstr "guix install vim-paredit\n"

msgid "We also recommend that you run @code{:set autoindent} so that your code is automatically indented as you type."
msgstr "Raccomandiamo anche di eseguire @code{:set autoindent} in modo che il tuo codice venga indentato automaticamente mentre scrivi."

msgid "For the interaction with Git, @uref{https://www.vim.org/scripts/script.php?script_id=2975, @code{fugitive.vim}} is the most commonly used plugin:"
msgstr "Per l'interazione con Git, @uref{https://www.vim.org/scripts/script.php?script_id=2975, @code{fugitive.vim}} è il plugin più comunemente usato:"

msgid "guix install vim-fugitive\n"
msgstr "guix install vim-fugitive\n"

msgid "And of course if you want to interact with Guix directly from inside of vim, using the built-in terminal emulator, we have our very own @code{guix.vim} package!"
msgstr "E ovviamente se vuoi interagire con Guix direttamente dall'interno di vim, usando l'emulatore di terminale integrato, abbiamo il nostro pacchetto @code{guix.vim}!"

msgid "guix install vim-guix-vim\n"
msgstr "guix install vim-guix-vim\n"

msgid "In NeoVim you can even make a similar setup to Geiser using @url{https://conjure.fun/, Conjure} that lets you connect to a running Guile process and inject your code there live (sadly it's not packaged in Guix yet)."
msgstr "In NeoVim puoi persino creare una configurazione simile a Geiser usando @url{https://conjure.fun/, Conjure} che ti permette di connetterti a un processo Guile in esecuzione e di iniettare il tuo codice lì in tempo reale (purtroppo non è ancora pacchettizzato in Guix)."

msgid "structure, of the source tree"
msgstr "struttura, dell'albero dei sorgenti"

msgid "If you're willing to contribute to Guix beyond packages, or if you'd like to learn how it all fits together, this section provides a guided tour in the code base that you may find useful."
msgstr "Se sei disposto a contribuire a Guix oltre ai pacchetti, o se vuoi imparare come tutto si incastra, questa sezione fornisce una visita guidata alla base di codice che potresti trovare utile."

msgid "Overall, the Guix source tree contains almost exclusively Guile @dfn{modules}, each of which can be seen as an independent library (@pxref{Modules,,, guile, GNU Guile Reference Manual})."
msgstr "In generale, l'albero dei sorgenti di Guix contiene quasi esclusivamente @dfn{modules} Guile, ognuno dei quali può essere visto come una libreria indipendente (@pxref{Modules,,, guile, GNU Guile Reference Manual})."

msgid "The following table gives an overview of the main directories and what they contain.  Remember that in Guile, each module name is derived from its file name---e.g., the module in file @file{guix/packages.scm} is called @code{(guix packages)}."
msgstr "La seguente tabella offre una panoramica delle directory principali e del loro contenuto. Ricorda che in Guile, ogni nome di modulo deriva dal nome del suo file --- ad esempio, il modulo nel file @file{guix/packages.scm} si chiama @code{(guix packages)}."

msgid "guix"
msgstr "guix"

msgid "This is the location of core Guix mechanisms.  To illustrate what is meant by ``core'', here are a few examples, starting from low-level tools and going towards higher-level tools:"
msgstr "Questa è la posizione dei meccanismi principali di Guix. Per illustrare cosa si intende per ``core'', ecco alcuni esempi, partendo dagli strumenti a basso livello e procedendo verso quelli di livello superiore:"

msgid "Connecting to and interacting with the build daemon (@pxref{The Store})."
msgstr "Connessione e interazione con il demone di compilazione (@pxref{The Store})."

msgid "Creating derivations (@pxref{Derivations})."
msgstr "Creazione di derivazioni (@pxref{Derivations})."

msgid "(guix gexps)"
msgstr "(guix gexps)"

msgid "Writing G-expressions (@pxref{G-Expressions})."
msgstr "Scrittura di G-expressions (@pxref{G-Expressions})."

msgid "Defining packages and origins (@pxref{package Reference})."
msgstr "Definizione di pacchetti e origini (@pxref{package Reference})."

msgid "(guix download)"
msgstr "(guix download)"

msgid "(guix git-download)"
msgstr "(guix git-download)"

msgid "The @code{url-fetch} and @code{git-fetch} origin download methods (@pxref{origin Reference})."
msgstr "I metodi di download dell'origine @code{url-fetch} e @code{git-fetch} (@pxref{origin Reference})."

msgid "(guix swh)"
msgstr "(guix swh)"

msgid "Fetching source code from the @uref{https://archive.softwareheritage.org,Software Heritage archive}."
msgstr "Recupero del codice sorgente dall'archivio @uref{https://archive.softwareheritage.org,Software Heritage}."

msgid "(guix search-paths)"
msgstr "(guix search-paths)"

msgid "Implementing search paths (@pxref{Search Paths})."
msgstr "Implementazione dei percorsi di ricerca (@pxref{Search Paths})."

msgid "The build system interface (@pxref{Build Systems})."
msgstr "L'interfaccia del sistema di compilazione (@pxref{Build Systems})."

msgid "Implementing profiles."
msgstr "Implementazione dei profili."

msgid "build system, directory structure"
msgstr "sistema di compilazione, struttura della directory"

msgid "This directory contains specific build system implementations (@pxref{Build Systems}), such as:"
msgstr "Questa directory contiene implementazioni specifiche del sistema di compilazione (@pxref{Build Systems}), come:"

msgid "The Python ``pyproject'' build system."
msgstr "Il sistema di compilazione ``pyproject'' di Python."

msgid "guix/build"
msgstr "guix/build"

msgid "This contains code generally used on the ``build side'' (@pxref{G-Expressions, strata of code}).  This includes code used to build packages or other operating system components, as well as utilities:"
msgstr "Contiene codice generalmente usato sul ``lato build'' (@pxref{G-Expressions, strata of code}). Questo include codice usato per costruire pacchetti o altri componenti del sistema operativo, così come utility:"

msgid "(guix build utils)"
msgstr "(guix build utils)"

msgid "Utilities for package definitions and more (@pxref{Build Utilities})."
msgstr "Utility per le definizioni di pacchetti e altro (@pxref{Build Utilities})."

msgid "Implementation of build systems, and in particular definition of their build phases (@pxref{Build Phases})."
msgstr "Implementazione dei sistemi di compilazione, e in particolare la definizione delle loro fasi di compilazione (@pxref{Build Phases})."

msgid "(guix build syscalls)"
msgstr "(guix build syscalls)"

msgid "Interface to the C library and to Linux system calls."
msgstr "Interfaccia alla libreria C e alle chiamate di sistema Linux."

msgid "command-line tools, as Guile modules"
msgstr "strumenti a riga di comando, come moduli Guile"

msgid "guix/scripts"
msgstr "guix/scripts"

msgid "This contains modules corresponding to @command{guix} sub-commands.  For example, the @code{(guix scripts shell)} module exports the @code{guix-shell} procedure, which directly corresponds to the @command{guix shell} command (@pxref{Invoking guix shell})."
msgstr "Contiene moduli corrispondenti ai sotto-comandi di @command{guix}. Ad esempio, il modulo @code{(guix scripts shell)} esporta la procedura @code{guix-shell}, che corrisponde direttamente al comando @command{guix shell} (@pxref{Invoking guix shell})."

msgid "guix/import"
msgstr "guix/import"

msgid "This contains supporting code for the importers and updaters (@pxref{Invoking guix import}, and @pxref{Invoking guix refresh}).  For example, @code{(guix import pypi)} defines the interface to PyPI, which is used by the @command{guix import pypi} command."
msgstr "Contiene codice di supporto per gli importatori e gli aggiornatori (@pxref{Invoking guix import}, e @pxref{Invoking guix refresh}). Ad esempio, @code{(guix import pypi)} definisce l'interfaccia a PyPI, che è usata dal comando @command{guix import pypi}."

msgid "The directories we have seen so far all live under @file{guix/}.  The other important place is the @file{gnu/} directory, which contains primarily package definitions as well as libraries and tools for Guix System (@pxref{System Configuration}) and Guix Home (@pxref{Home Configuration}), all of which build upon functionality provided by @code{(guix @dots{})} modules@footnote{For this reason, @code{(guix @dots{})} modules must generally not depend on @code{(gnu @dots{})} modules, with notable exceptions: @code{(guix build-system @dots{})} modules may look up packages at run time---e.g., @code{(guix build-system cmake)} needs to access the @code{cmake} variable at run time---, @code{(guix scripts @dots{})} often rely on @code{(gnu @dots{})} modules, and the same goes for some of the @code{(guix import @dots{})} modules.}."
msgstr "Le directory che abbiamo visto finora si trovano tutte sotto @file{guix/}. L'altro posto importante è la directory @file{gnu/}, che contiene principalmente definizioni di pacchetti, nonché librerie e strumenti per Guix System (@pxref{System Configuration}) e Guix Home (@pxref{Home Configuration}), tutti basati su funzionalità fornite dai moduli @code{(guix @dots{})}@footnote{Per questo motivo, i moduli @code{(guix @dots{})} non devono generalmente dipendere dai moduli @code{(gnu @dots{})}, con alcune eccezioni notevoli: i moduli @code{(guix build-system @dots{})} possono cercare pacchetti a runtime---ad esempio, @code{(guix build-system cmake)} deve accedere alla variabile @code{cmake} a runtime---, i moduli @code{(guix scripts @dots{})} si basano spesso sui moduli @code{(gnu @dots{})}, e lo stesso vale per alcuni dei moduli @code{(guix import @dots{})}.}."

msgid "package modules"
msgstr "moduli di pacchetti"

msgid "This is by far the most crowded directory of the source tree: it contains @dfn{package modules} that export package definitions (@pxref{Package Modules}).  A few examples:"
msgstr "Questa è di gran lunga la directory più affollata dell'albero dei sorgenti: contiene @dfn{moduli di pacchetti} che esportano definizioni di pacchetti (@pxref{Package Modules}). Alcuni esempi:"

msgid "(gnu packages base)"
msgstr "(gnu packages base)"

msgid "Module providing ``base'' packages: @code{glibc}, @code{coreutils}, @code{grep}, etc."
msgstr "Modulo che fornisce i pacchetti di ``base'': @code{glibc}, @code{coreutils}, @code{grep}, ecc."

msgid "(gnu packages guile)"
msgstr "(gnu packages guile)"

msgid "Guile and core Guile packages."
msgstr "Guile e pacchetti Guile principali."

msgid "(gnu packages linux)"
msgstr "(gnu packages linux)"

msgid "The Linux-libre kernel and related packages."
msgstr "Il kernel Linux-libre e i pacchetti correlati."

msgid "(gnu packages python)"
msgstr "(gnu packages python)"

msgid "Python and core Python packages."
msgstr "Python e pacchetti Python principali."

msgid "(gnu packages python-xyz)"
msgstr "(gnu packages python-xyz)"

msgid "Miscellaneous Python packages (we were not very creative)."
msgstr "Pacchetti Python vari (non siamo stati molto creativi)."

msgid "In any case, you can jump to a package definition using @command{guix edit} (@pxref{Invoking guix edit}) and view its location with @command{guix show} (@pxref{Invoking guix package})."
msgstr "In ogni caso, puoi saltare alla definizione di un pacchetto usando @command{guix edit} (@pxref{Invoking guix edit}) e visualizzare la sua posizione con @command{guix show} (@pxref{Invoking guix package})."

msgid "gnu/packages/patches"
msgstr "gnu/packages/patches"

msgid "This directory contains patches applied against packages and obtained using the @code{search-patches} procedure."
msgstr "Questa directory contiene le patch applicate ai pacchetti e ottenute usando la procedura @code{search-patches}."

msgid "This contains service definitions, primarily for Guix System (@pxref{Services}) but some of them are adapted and reused for Guix Home as we will see below.  Examples:"
msgstr "Contiene definizioni di servizi, principalmente per Guix System (@pxref{Services}) ma alcuni di essi sono adattati e riutilizzati per Guix Home, come vedremo più avanti. Esempi:"

msgid "The service framework itself, which defines the service and service type data types (@pxref{Service Composition})."
msgstr "Il framework dei servizi stesso, che definisce i tipi di dati di servizio e di tipo di servizio (@pxref{Service Composition})."

msgid "(gnu services base)"
msgstr "(gnu services base)"

msgid "``Base'' services (@pxref{Base Services})."
msgstr "Servizi di ``base'' (@pxref{Base Services})."

msgid "(gnu services shepherd)"
msgstr "(gnu services shepherd)"

msgid "Support for Shepherd services (@pxref{Shepherd Services})."
msgstr "Supporto per i servizi Shepherd (@pxref{Shepherd Services})."

msgid "You can jump to a service definition using @command{guix system edit} and view its location with @command{guix system search} (@pxref{Invoking guix system})."
msgstr "Puoi saltare alla definizione di un servizio usando @command{guix system edit} e visualizzare la sua posizione con @command{guix system search} (@pxref{Invoking guix system})."

msgid "These are core Guix System modules, such as:"
msgstr "Questi sono i moduli principali di Guix System, come:"

msgid "Defines @code{operating-system} (@pxref{operating-system Reference})."
msgstr "Definisce @code{operating-system} (@pxref{operating-system Reference})."

msgid "Defines @code{file-system} (@pxref{File Systems})."
msgstr "Definisce @code{file-system} (@pxref{File Systems})."

msgid "(gnu system mapped-devices)"
msgstr "(gnu system mapped-devices)"

msgid "Defines @code{mapped-device} (@pxref{Mapped Devices})."
msgstr "Definisce @code{mapped-device} (@pxref{Mapped Devices})."

msgid "These are modules that are either used on the ``build side'' when building operating systems or packages, or at run time by operating systems."
msgstr "Questi sono moduli usati sul ``lato build'' quando si costruiscono sistemi operativi o pacchetti, o a runtime dai sistemi operativi."

msgid "(gnu build accounts)"
msgstr "(gnu build accounts)"

msgid "Creating @file{/etc/passwd}, @file{/etc/shadow}, etc. (@pxref{User Accounts})."
msgstr "Creazione di @file{/etc/passwd}, @file{/etc/shadow}, ecc. (@pxref{User Accounts})."

msgid "(gnu build activation)"
msgstr "(gnu build activation)"

msgid "Activating an operating system at boot time or reconfiguration time."
msgstr "Attivazione di un sistema operativo all'avvio o durante la riconfigurazione."

msgid "Searching, checking, and mounting file systems."
msgstr "Ricerca, controllo e montaggio dei file system."

msgid "(gnu build linux-boot)"
msgstr "(gnu build linux-boot)"

msgid "(gnu build hurd-boot)"
msgstr "(gnu build hurd-boot)"

msgid "Booting GNU/Linux and GNU/Hurd operating systems."
msgstr "Avvio dei sistemi operativi GNU/Linux e GNU/Hurd."

msgid "(gnu build linux-initrd)"
msgstr "(gnu build linux-initrd)"

msgid "Creating a Linux initial RAM disk (@pxref{Initial RAM Disk})."
msgstr "Creazione di un disco RAM iniziale di Linux (@pxref{Initial RAM Disk})."

msgid "gnu/home"
msgstr "gnu/home"

msgid "This contains all things Guix Home (@pxref{Home Configuration}); examples:"
msgstr "Contiene tutto ciò che riguarda Guix Home (@pxref{Home Configuration}); esempi:"

msgid "SSH-related services (@pxref{Secure Shell})."
msgstr "Servizi relativi a SSH (@pxref{Secure Shell})."

msgid "gnu/installer"
msgstr "gnu/installer"

msgid "This contains the text-mode graphical system installer (@pxref{Guided Graphical Installation})."
msgstr "Contiene l'installatore di sistema grafico in modalità testo (@pxref{Guided Graphical Installation})."

msgid "gnu/machine"
msgstr "gnu/machine"

msgid "These are the @dfn{machine abstractions} used by @command{guix deploy} (@pxref{Invoking guix deploy})."
msgstr "Queste sono le @dfn{astrazioni di macchina} usate da @command{guix deploy} (@pxref{Invoking guix deploy})."

msgid "gnu/tests"
msgstr "gnu/tests"

msgid "This contains system tests---tests that spawn virtual machines to check that system services work as expected (@pxref{Running the Test Suite})."
msgstr "Contiene i test di sistema --- test che avviano macchine virtuali per verificare che i servizi di sistema funzionino come previsto (@pxref{Running the Test Suite})."

msgid "Last, there's also a few directories that contain files that are @emph{not} Guile modules:"
msgstr "Infine, ci sono anche alcune directory che contengono file che @emph{not} sono moduli Guile:"

msgid "nix"
msgstr "nix"

msgid "This is the C++ implementation of @command{guix-daemon}, inherited from Nix (@pxref{Invoking guix-daemon})."
msgstr "Questa è l'implementazione C++ di @command{guix-daemon}, ereditata da Nix (@pxref{Invoking guix-daemon})."

msgid "tests"
msgstr "tests"

msgid "These are unit tests, each file corresponding more or less to one module, in particular @code{(guix @dots{})} modules (@pxref{Running the Test Suite})."
msgstr "Questi sono i test unitari, ogni file corrisponde più o meno a un modulo, in particolare ai moduli @code{(guix @dots{})} (@pxref{Running the Test Suite})."

msgid "doc"
msgstr "doc"

msgid "This is the documentation in the form of Texinfo files: this manual and the Cookbook.  @xref{Writing a Texinfo File,,, texinfo, GNU Texinfo}, for information on Texinfo markup language."
msgstr "Questa è la documentazione in forma di file Texinfo: questo manuale e il Cookbook. @xref{Writing a Texinfo File,,, texinfo, GNU Texinfo}, per informazioni sul linguaggio di markup Texinfo."

msgid "po"
msgstr "po"

msgid "This is the location of translations of Guix itself, of package synopses and descriptions, of the manual, and of the cookbook.  Note that @file{.po} files that live here are pulled directly from Weblate (@pxref{Translating Guix})."
msgstr "Questa è la posizione delle traduzioni di Guix stesso, delle sinossi e descrizioni dei pacchetti, del manuale e del cookbook. Nota che i file @file{.po} che si trovano qui sono prelevati direttamente da Weblate (@pxref{Translating Guix})."

msgid "etc"
msgstr "etc"

msgid "Miscellaneous files: shell completions, support for systemd and other init systems, Git hooks, etc."
msgstr "File vari: completamenti della shell, supporto per systemd e altri sistemi di init, hook di Git, ecc."

msgid "With all this, a fair chunk of your operating system is at your fingertips! Beyond @command{grep} and @command{git grep}, @pxref{The Perfect Setup} on how to navigate code from your editor, and @pxref{Using Guix Interactively} for information on how to use Scheme modules interactively.  Enjoy!"
msgstr "Con tutto questo, una buona parte del tuo sistema operativo è a portata di mano! Oltre a @command{grep} e @command{git grep}, @pxref{The Perfect Setup} su come navigare nel codice dal tuo editor, e @pxref{Using Guix Interactively} per informazioni su come usare i moduli Scheme in modo interattivo. Divertiti!"

msgid "packages, creating"
msgstr "pacchetti, creazione"

msgid "The GNU distribution is nascent and may well lack some of your favorite packages.  This section describes how you can help make the distribution grow."
msgstr "La distribuzione GNU è nascente e potrebbe mancare di alcuni dei tuoi pacchetti preferiti. Questa sezione descrive come puoi contribuire a far crescere la distribuzione."

msgid "Free software packages are usually distributed in the form of @dfn{source code tarballs}---typically @file{tar.gz} files that contain all the source files.  Adding a package to the distribution means essentially two things: adding a @dfn{recipe} that describes how to build the package, including a list of other packages required to build it, and adding @dfn{package metadata} along with that recipe, such as a description and licensing information."
msgstr "I pacchetti di software libero sono solitamente distribuiti sotto forma di @dfn{tarball di codice sorgente}---tipicamente file @file{tar.gz} che contengono tutti i file sorgente. Aggiungere un pacchetto alla distribuzione significa essenzialmente due cose: aggiungere una @dfn{recipe} che descrive come costruire il pacchetto, inclusa una lista di altri pacchetti richiesti per costruirlo, e aggiungere @dfn{metadati del pacchetto} insieme a quella ricetta, come una descrizione e informazioni sulla licenza."

msgid "In Guix all this information is embodied in @dfn{package definitions}.  Package definitions provide a high-level view of the package.  They are written using the syntax of the Scheme programming language; in fact, for each package we define a variable bound to the package definition, and export that variable from a module (@pxref{Package Modules}).  However, in-depth Scheme knowledge is @emph{not} a prerequisite for creating packages.  For more information on package definitions, @pxref{Defining Packages}."
msgstr "In Guix tutte queste informazioni sono incarnate nelle @dfn{definizioni di pacchetto}. Le definizioni di pacchetto forniscono una visione di alto livello del pacchetto. Sono scritte usando la sintassi del linguaggio di programmazione Scheme; infatti, per ogni pacchetto definiamo una variabile associata alla definizione del pacchetto, e esportiamo quella variabile da un modulo (@pxref{Package Modules}). Tuttavia, una conoscenza approfondita di Scheme @emph{non} è un prerequisito per creare pacchetti. Per maggiori informazioni sulle definizioni di pacchetto, @pxref{Defining Packages}."

msgid "Once a package definition is in place, stored in a file in the Guix source tree, it can be tested using the @command{guix build} command (@pxref{Invoking guix build}).  For example, assuming the new package is called @code{gnew}, you may run this command from the Guix build tree (@pxref{Running Guix Before It Is Installed}):"
msgstr "Una volta che una definizione di pacchetto è al suo posto, salvata in un file nell'albero dei sorgenti di Guix, può essere testata usando il comando @command{guix build} (@pxref{Invoking guix build}). Ad esempio, assumendo che il nuovo pacchetto si chiami @code{gnew}, puoi eseguire questo comando dall'albero di compilazione di Guix (@pxref{Running Guix Before It Is Installed}):"

msgid "./pre-inst-env guix build gnew --keep-failed\n"
msgstr "./pre-inst-env guix build gnew --keep-failed\n"

msgid "Using @code{--keep-failed} makes it easier to debug build failures since it provides access to the failed build tree.  Another useful command-line option when debugging is @code{--log-file}, to access the build log."
msgstr "L'uso di @code{--keep-failed} rende più facile il debug dei fallimenti di compilazione poiché fornisce accesso all'albero di compilazione fallito. Un'altra opzione utile della riga di comando durante il debug è @code{--log-file}, per accedere al log di compilazione."

msgid "If the package is unknown to the @command{guix} command, it may be that the source file contains a syntax error, or lacks a @code{define-public} clause to export the package variable.  To figure it out, you may load the module from Guile to get more information about the actual error:"
msgstr "Se il pacchetto è sconosciuto al comando @command{guix}, potrebbe essere che il file sorgente contenga un errore di sintassi, o manchi una clausola @code{define-public} per esportare la variabile del pacchetto. Per capirlo, puoi caricare il modulo da Guile per ottenere maggiori informazioni sull'errore effettivo:"

msgid "./pre-inst-env guile -c '(use-modules (gnu packages gnew))'\n"
msgstr "./pre-inst-env guile -c '(use-modules (gnu packages gnew))'\n"

msgid "Once your package builds correctly, please send us a patch (@pxref{Submitting Patches}).  Well, if you need help, we will be happy to help you too.  Once the patch is committed in the Guix repository, the new package automatically gets built on the supported platforms by @url{https://@value{SUBSTITUTE-SERVER-1}, our continuous integration system}."
msgstr "Una volta che il tuo pacchetto si compila correttamente, inviaci una patch (@pxref{Submitting Patches}). Beh, se hai bisogno di aiuto, saremo felici di aiutarti anche noi. Una volta che la patch è stata committata nel repository di Guix, il nuovo pacchetto viene automaticamente costruito sulle piattaforme supportate da @url{https://@value{SUBSTITUTE-SERVER-1}, il nostro sistema di integrazione continua}."

msgid "substituter"
msgstr "sostituto"

msgid "Users can obtain the new package definition simply by running @command{guix pull} (@pxref{Invoking guix pull}).  When @code{@value{SUBSTITUTE-SERVER-1}} is done building the package, installing the package automatically downloads binaries from there (@pxref{Substitutes}).  The only place where human intervention is needed is to review and apply the patch."
msgstr "Gli utenti possono ottenere la nuova definizione di pacchetto semplicemente eseguendo @command{guix pull} (@pxref{Invoking guix pull}). Quando @code{@value{SUBSTITUTE-SERVER-1}} ha finito di costruire il pacchetto, l'installazione del pacchetto scarica automaticamente i binari da lì (@pxref{Substitutes}). L'unico punto in cui è necessario l'intervento umano è per la revisione e l'applicazione della patch."

msgid "Software Freedom"
msgstr "Libertà del software"

msgid "What may go into the distribution."
msgstr "Cosa può essere incluso nella distribuzione."

msgid "Package Naming"
msgstr "Denominazione dei pacchetti"

msgid "What's in a name?"
msgstr "Cosa c'è in un nome?"

msgid "Version Numbers"
msgstr "Numeri di versione"

msgid "When the name is not enough."
msgstr "Quando il nome non basta."

msgid "Synopses and Descriptions"
msgstr "Sinossi e descrizioni"

msgid "Helping users find the right package."
msgstr "Aiutare gli utenti a trovare il pacchetto giusto."

msgid "Snippets versus Phases"
msgstr "Snippet contro fasi"

msgid "Whether to use a snippet, or a build phase."
msgstr "Se usare uno snippet o una fase di compilazione."

msgid "Cyclic Module Dependencies"
msgstr "Dipendenze cicliche tra moduli"

msgid "Going full circle."
msgstr "Chiudere il cerchio."

msgid "Emacs Packages"
msgstr "Pacchetti Emacs"

msgid "Your Elisp fix."
msgstr "La tua dose di Elisp."

msgid "Python Modules"
msgstr "Moduli Python"

msgid "A touch of British comedy."
msgstr "Un tocco di commedia britannica."

msgid "Perl Modules"
msgstr "Moduli Perl"

msgid "Little pearls."
msgstr "Piccole perle."

msgid "Java Packages"
msgstr "Pacchetti Java"

msgid "Coffee break."
msgstr "Pausa caffè."

msgid "Rust Crates"
msgstr "Crate Rust"

msgid "Beware of oxidation."
msgstr "Attenzione all'ossidazione."

msgid "Elm Packages"
msgstr "Pacchetti Elm"

msgid "Trees of browser code"
msgstr "Alberi di codice per browser"

msgid "Fonts"
msgstr "Font"

msgid "Fond of fonts."
msgstr "Amante dei font."

msgid "free software"
msgstr "software libero"

msgid "The GNU operating system has been developed so that users can have freedom in their computing.  GNU is @dfn{free software}, meaning that users have the @url{https://www.gnu.org/philosophy/free-sw.html,four essential freedoms}: to run the program, to study and change the program in source code form, to redistribute exact copies, and to distribute modified versions.  Packages found in the GNU distribution provide only software that conveys these four freedoms."
msgstr "Il sistema operativo GNU è stato sviluppato affinché gli utenti possano avere libertà nella loro informatica. GNU è @dfn{software libero}, il che significa che gli utenti hanno le @url{https://www.gnu.org/philosophy/free-sw.html, quattro libertà essenziali}: eseguire il programma, studiare e modificare il programma in forma di codice sorgente, ridistribuire copie esatte e distribuire versioni modificate. I pacchetti trovati nella distribuzione GNU forniscono solo software che trasmette queste quattro libertà."

msgid "In addition, the GNU distribution follow the @url{https://www.gnu.org/distros/free-system-distribution-guidelines.html,free software distribution guidelines}.  Among other things, these guidelines reject non-free firmware, recommendations of non-free software, and discuss ways to deal with trademarks and patents."
msgstr "Inoltre, la distribuzione GNU segue le @url{https://www.gnu.org/distros/free-system-distribution-guidelines.html, linee guida per la distribuzione di software libero}. Tra le altre cose, queste linee guida rifiutano il firmware non libero, le raccomandazioni di software non libero, e discutono i modi per affrontare i marchi e i brevetti."

msgid "Some otherwise free upstream package sources contain a small and optional subset that violates the above guidelines, for instance because this subset is itself non-free code.  When that happens, the offending items are removed with appropriate patches or code snippets in the @code{origin} form of the package (@pxref{Defining Packages}).  This way, @code{guix build --source} returns the ``freed'' source rather than the unmodified upstream source."
msgstr "Alcuni pacchetti sorgente upstream, altrimenti liberi, contengono un piccolo sottoinsieme opzionale che viola le linee guida sopra menzionate, ad esempio perché questo sottoinsieme è esso stesso codice non libero. Quando ciò accade, gli elementi problematici vengono rimossi con patch o frammenti di codice appropriati nel modulo @code{origin} del pacchetto (@pxref{Defining Packages}). In questo modo, @code{guix build --source} restituisce il codice sorgente ``liberato'' piuttosto che il codice sorgente upstream non modificato."

msgid "package name"
msgstr "nome del pacchetto"

msgid "A package actually has two names associated with it.  First, there is the name of the @emph{Scheme variable}, the one following @code{define-public}.  By this name, the package can be made known in the Scheme code, for instance as input to another package.  Second, there is the string in the @code{name} field of a package definition.  This name is used by package management commands such as @command{guix package} and @command{guix build}."
msgstr "Un pacchetto ha in realtà due nomi associati. Innanzitutto, c'è il nome della @emph{variabile Scheme}, quella che segue @code{define-public}. Con questo nome, il pacchetto può essere reso noto nel codice Scheme, ad esempio come input per un altro pacchetto. In secondo luogo, c'è la stringa nel campo @code{name} di una definizione di pacchetto. Questo nome è usato dai comandi di gestione dei pacchetti come @command{guix package} e @command{guix build}."

msgid "Both are usually the same and correspond to the lowercase conversion of the project name chosen upstream, with underscores replaced with hyphens.  For instance, GNUnet is available as @code{gnunet}, and SDL_net as @code{sdl-net}."
msgstr "Entrambi sono di solito uguali e corrispondono alla conversione in minuscolo del nome del progetto scelto upstream, con i trattini bassi sostituiti da trattini. Ad esempio, GNUnet è disponibile come @code{gnunet}, e SDL_net come @code{sdl-net}."

msgid "A noteworthy exception to this rule is when the project name is only a single character, or if an older maintained project with the same name already exists---regardless of whether it has already been packaged for Guix.  Use common sense to make such names unambiguous and meaningful.  For example, Guix's package for the shell called ``s'' upstream is @code{s-shell} and @emph{not} @code{s}.  Feel free to ask your fellow hackers for inspiration."
msgstr "Un'eccezione degna di nota a questa regola è quando il nome del progetto è un singolo carattere, o se esiste già un progetto più vecchio mantenuto con lo stesso nome --- indipendentemente dal fatto che sia già stato pacchettizzato per Guix. Usa il buon senso per rendere tali nomi non ambigui e significativi. Ad esempio, il pacchetto di Guix per la shell chiamata ``s'' upstream è @code{s-shell} e @emph{not} @code{s}. Sentiti libero di chiedere ispirazione ai tuoi compagni hacker."

msgid "We do not add @code{lib} prefixes for library packages, unless these are already part of the official project name.  But @pxref{Python Modules} and @ref{Perl Modules} for special rules concerning modules for the Python and Perl languages."
msgstr "Non aggiungiamo prefissi @code{lib} per i pacchetti di librerie, a meno che non facciano già parte del nome ufficiale del progetto. Ma vedi @pxref{Python Modules} e @ref{Perl Modules} per le regole speciali riguardanti i moduli per i linguaggi Python e Perl."

msgid "Font package names are handled differently, @pxref{Fonts}."
msgstr "I nomi dei pacchetti di font sono gestiti in modo diverso, @pxref{Fonts}."

msgid "package version"
msgstr "versione del pacchetto"

msgid "We usually package only the latest version of a given free software project.  But sometimes, for instance for incompatible library versions, two (or more) versions of the same package are needed.  These require different Scheme variable names.  We use the name as defined in @ref{Package Naming} for the most recent version; previous versions use the same name, suffixed by @code{-} and the smallest prefix of the version number that may distinguish the two versions."
msgstr "Di solito pacchettizziamo solo l'ultima versione di un dato progetto di software libero. Ma a volte, ad esempio per versioni di librerie incompatibili, sono necessarie due (o più) versioni dello stesso pacchetto. Queste richiedono nomi di variabili Scheme diversi. Usiamo il nome come definito in @ref{Package Naming} per la versione più recente; le versioni precedenti usano lo stesso nome, con suffisso @code{-} e il più piccolo prefisso del numero di versione che può distinguere le due versioni."

msgid "The name inside the package definition is the same for all versions of a package and does not contain any version number."
msgstr "Il nome all'interno della definizione del pacchetto è lo stesso per tutte le versioni di un pacchetto e non contiene alcun numero di versione."

msgid "For instance, the versions 2.24.20 and 3.9.12 of GTK+ may be packaged as follows:"
msgstr "Ad esempio, le versioni 2.24.20 e 3.9.12 di GTK+ possono essere pacchettizzate come segue:"

msgid ""
"(define-public gtk+\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.9.12\")\n"
"    ...))\n"
"(define-public gtk+-2\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"2.24.20\")\n"
"    ...))\n"
msgstr ""
"(define-public gtk+\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.9.12\")\n"
"    ...))\n"
"(define-public gtk+-2\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"2.24.20\")\n"
"    ...))\n"

msgid "If we also wanted GTK+ 3.8.2, this would be packaged as"
msgstr "Se volessimo anche GTK+ 3.8.2, sarebbe pacchettizzato come"

msgid ""
"(define-public gtk+-3.8\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.8.2\")\n"
"    ...))\n"
msgstr ""
"(define-public gtk+-3.8\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.8.2\")\n"
"    ...))\n"

msgid "version number, for VCS snapshots"
msgstr "numero di versione, per le istantanee VCS"

msgid "Occasionally, we package snapshots of upstream's version control system (VCS) instead of formal releases.  This should remain exceptional, because it is up to upstream developers to clarify what the stable release is.  Yet, it is sometimes necessary.  So, what should we put in the @code{version} field?"
msgstr "Occasionalmente, pacchettizziamo istantanee del sistema di controllo di versione (VCS) di upstream invece di rilasci formali. Questo dovrebbe rimanere un'eccezione, perché spetta agli sviluppatori upstream chiarire qual è la versione stabile. Tuttavia, a volte è necessario. Quindi, cosa dovremmo mettere nel campo @code{version}?"

msgid "Clearly, we need to make the commit identifier of the VCS snapshot visible in the version string, but we also need to make sure that the version string is monotonically increasing so that @command{guix package --upgrade} can determine which version is newer.  Since commit identifiers, notably with Git, are not monotonically increasing, we add a revision number that we increase each time we upgrade to a newer snapshot.  The resulting version string looks like this:"
msgstr "Chiaramente, dobbiamo rendere visibile l'identificatore del commit della istantanea VCS nella stringa di versione, ma dobbiamo anche assicurarci che la stringa di versione sia monotonicamente crescente in modo che @command{guix package --upgrade} possa determinare quale versione è più recente. Poiché gli identificatori di commit, in particolare con Git, non sono monotonicamente crescenti, aggiungiamo un numero di revisione che incrementiamo ogni volta che aggiorniamo a una nuova istantanea. La stringa di versione risultante assomiglia a questa:"

msgid ""
"2.0.11-3.cabba9e\n"
"  ^    ^    ^\n"
"  |    |    `-- upstream commit ID\n"
"  |    |\n"
"  |    `--- Guix package revision\n"
"  |\n"
"latest upstream version\n"
msgstr ""
"2.0.11-3.cabba9e\n"
"  ^    ^    ^\n"
"  |    |    `-- ID commit upstream\n"
"  |    |\n"
"  |    `--- Revisione pacchetto Guix\n"
"  |\n"
"ultima versione upstream\n"

msgid "It is a good idea to strip commit identifiers in the @code{version} field to, say, 7 digits.  It avoids an aesthetic annoyance (assuming aesthetics have a role to play here) as well as problems related to OS limits such as the maximum shebang length (127 bytes for the Linux kernel).  There are helper functions for doing this for packages using @code{git-fetch} or @code{hg-fetch} (see below).  It is best to use the full commit identifiers in @code{origin}s, though, to avoid ambiguities.  A typical package definition may look like this:"
msgstr "È una buona idea troncare gli identificatori di commit nel campo @code{version} a, diciamo, 7 cifre. Questo evita un fastidio estetico (supponendo che l'estetica abbia un ruolo qui) così come problemi legati ai limiti del SO come la lunghezza massima dello shebang (127 byte per il kernel Linux). Ci sono funzioni di aiuto per fare questo per i pacchetti che usano @code{git-fetch} o @code{hg-fetch} (vedi sotto). È meglio usare gli identificatori di commit completi negli @code{origin}, però, per evitare ambiguità. Una definizione di pacchetto tipica potrebbe assomigliare a questa:"

msgid ""
"(define my-package\n"
"  (let ((commit \"c3f29bc928d5900971f65965feaae59e1272a3f7\")\n"
"        (revision \"1\"))          ;Guix package revision\n"
"    (package\n"
"      (version (git-version \"0.9\" revision commit))\n"
"      (source (origin\n"
"                (method git-fetch)\n"
"                (uri (git-reference\n"
"                      (url \"git://example.org/my-package.git\")\n"
"                      (commit commit)))\n"
"                (sha256 (base32 \"1mbikn@dots{}\"))\n"
"                (file-name (git-file-name name version))))\n"
"      ;; @dots{}\n"
"      )))\n"
msgstr ""
"(define my-package\n"
"  (let ((commit \"c3f29bc928d5900971f65965feaae59e1272a3f7\")\n"
"        (revision \"1\"))          ;Revisione pacchetto Guix\n"
"    (package\n"
"      (version (git-version \"0.9\" revision commit))\n"
"      (source (origin\n"
"                (method git-fetch)\n"
"                (uri (git-reference\n"
"                      (url \"git://example.org/my-package.git\")\n"
"                      (commit commit)))\n"
"                (sha256 (base32 \"1mbikn@dots{}\"))\n"
"                (file-name (git-file-name name version))))\n"
"      ;; @dots{}\n"
"      )))\n"

msgid "{Procedure} git-version @var{VERSION} @var{REVISION} @var{COMMIT}"
msgstr "{Procedure} git-version @var{VERSION} @var{REVISION} @var{COMMIT}"

msgid "Return the version string for packages using @code{git-fetch}."
msgstr "Restituisce la stringa di versione per i pacchetti che usano @code{git-fetch}."

msgid ""
"(git-version \"0.2.3\" \"0\" \"93818c936ee7e2f1ba1b315578bde363a7d43d05\")\n"
"@result{} \"0.2.3-0.93818c9\"\n"
msgstr ""
"(git-version \"0.2.3\" \"0\" \"93818c936ee7e2f1ba1b315578bde363a7d43d05\")\n"
"@result{} \"0.2.3-0.93818c9\"\n"

msgid "{Procedure} hg-version @var{VERSION} @var{REVISION} @var{CHANGESET}"
msgstr "{Procedure} hg-version @var{VERSION} @var{REVISION} @var{CHANGESET}"

msgid "Return the version string for packages using @code{hg-fetch}.  It works in the same way as @code{git-version}."
msgstr "Restituisce la stringa di versione per i pacchetti che usano @code{hg-fetch}. Funziona allo stesso modo di @code{git-version}."

msgid "package description"
msgstr "descrizione del pacchetto"

msgid "package synopsis"
msgstr "sinossi del pacchetto"

msgid "As we have seen before, each package in GNU@tie{}Guix includes a synopsis and a description (@pxref{Defining Packages}).  Synopses and descriptions are important: They are what @command{guix package --search} searches, and a crucial piece of information to help users determine whether a given package suits their needs.  Consequently, packagers should pay attention to what goes into them."
msgstr "Come abbiamo visto prima, ogni pacchetto in GNU@tie{}Guix include una sinossi e una descrizione (@pxref{Defining Packages}). Sinossi e descrizioni sono importanti: sono ciò che @command{guix package --search} cerca, e un pezzo di informazione cruciale per aiutare gli utenti a determinare se un dato pacchetto soddisfa le loro esigenze. Di conseguenza, i pacchettizzatori dovrebbero prestare attenzione a ciò che vi inseriscono."

msgid "Synopses must start with a capital letter and must not end with a period.  They must not start with ``a'' or ``the'', which usually does not bring anything; for instance, prefer ``File-frobbing tool'' over ``A tool that frobs files''.  The synopsis should say what the package is---e.g., ``Core GNU utilities (file, text, shell)''---or what it is used for---e.g., the synopsis for GNU@tie{}grep is ``Print lines matching a pattern''."
msgstr "Le sinossi devono iniziare con una lettera maiuscola e non devono terminare con un punto. Non devono iniziare con articoli, che di solito non aggiungono nulla; ad esempio, preferire ``Strumento per manipolare file'' a ``Uno strumento che manipola file''. La sinossi dovrebbe dire cosa è il pacchetto --- ad esempio, ``Utilità GNU di base (file, testo, shell)'' --- o a cosa serve --- ad esempio, la sinossi per GNU@tie{}grep è ``Stampa le righe che corrispondono a un modello''."

msgid "Keep in mind that the synopsis must be meaningful for a very wide audience.  For example, ``Manipulate alignments in the SAM format'' might make sense for a seasoned bioinformatics researcher, but might be fairly unhelpful or even misleading to a non-specialized audience.  It is a good idea to come up with a synopsis that gives an idea of the application domain of the package.  In this example, this might give something like ``Manipulate nucleotide sequence alignments'', which hopefully gives the user a better idea of whether this is what they are looking for."
msgstr "Tieni presente che la sinossi deve essere significativa per un pubblico molto ampio. Ad esempio, ``Manipola allineamenti in formato SAM'' potrebbe avere senso per un ricercatore esperto di bioinformatica, ma potrebbe essere poco utile o addirittura fuorviante per un pubblico non specializzato. È una buona idea creare una sinossi che dia un'idea del dominio di applicazione del pacchetto. In questo esempio, si potrebbe ottenere qualcosa come ``Manipola allineamenti di sequenze nucleotidiche'', che si spera dia all'utente un'idea migliore se è quello che sta cercando."

msgid "Descriptions should take between five and ten lines.  Use full sentences, and avoid using acronyms without first introducing them.  Please avoid marketing phrases such as ``world-leading'', ``industrial-strength'', and ``next-generation'', and avoid superlatives like ``the most advanced''---they are not helpful to users looking for a package and may even sound suspicious.  Instead, try to be factual, mentioning use cases and features."
msgstr "Le descrizioni dovrebbero essere lunghe tra le cinque e le dieci righe. Usa frasi complete ed evita di usare acronimi senza averli prima introdotti. Evita frasi di marketing come ``leader mondiale'', ``di forza industriale'' e ``di nuova generazione'', ed evita superlativi come ``il più avanzato'' --- non sono utili agli utenti che cercano un pacchetto e possono persino suonare sospetti. Invece, cerca di essere fattuale, menzionando casi d'uso e funzionalità."

msgid "Texinfo markup, in package descriptions"
msgstr "Markup Texinfo, nelle descrizioni dei pacchetti"

msgid "Descriptions can include Texinfo markup, which is useful to introduce ornaments such as @code{@@code} or @code{@@dfn}, bullet lists, or hyperlinks (@pxref{Overview,,, texinfo, GNU Texinfo}).  However you should be careful when using some characters for example @samp{@@} and curly braces which are the basic special characters in Texinfo (@pxref{Special Characters,,, texinfo, GNU Texinfo}).  User interfaces such as @command{guix show} take care of rendering it appropriately."
msgstr "Le descrizioni possono includere il markup Texinfo, che è utile per introdurre ornamenti come @code{@@code} o @code{@@dfn}, elenchi puntati o collegamenti ipertestuali (@pxref{Overview,,, texinfo, GNU Texinfo}). Tuttavia, dovresti fare attenzione quando usi alcuni caratteri, ad esempio @samp{@@} e le parentesi graffe, che sono i caratteri speciali di base in Texinfo (@pxref{Special Characters,,, texinfo, GNU Texinfo}). Le interfacce utente come @command{guix show} si occupano di renderlo in modo appropriato."

msgid "Synopses and descriptions are translated by volunteers @uref{https://translate.codeberg.org/projects/guix/packages, at Weblate} so that as many users as possible can read them in their native language.  User interfaces search them and display them in the language specified by the current locale."
msgstr "Sinossi e descrizioni sono tradotte da volontari su @uref{https://translate.codeberg.org/projects/guix/packages, Weblate} in modo che il maggior numero possibile di utenti possa leggerle nella propria lingua madre. Le interfacce utente le cercano e le visualizzano nella lingua specificata dalla localizzazione corrente."

msgid "To allow @command{xgettext} to extract them as translatable strings, synopses and descriptions @emph{must be literal strings}.  This means that you cannot use @code{string-append} or @code{format} to construct these strings:"
msgstr "Per permettere a @command{xgettext} di estrarle come stringhe traducibili, le sinossi e le descrizioni @emph{devono essere stringhe letterali}. Questo significa che non puoi usare @code{string-append} o @code{format} per costruire queste stringhe:"

msgid ""
"(package\n"
"  ;; @dots{}\n"
"  (synopsis \"This is translatable\")\n"
"  (description (string-append \"This is \" \"*not*\" \" translatable.\")))\n"
msgstr ""
"(package\n"
"  ;; @dots{}\n"
"  (synopsis \"Questo è traducibile\")\n"
"  (description (string-append \"Questo \" \"*non*\" \" è traducibile.\")))\n"

msgid "Translation is a lot of work so, as a packager, please pay even more attention to your synopses and descriptions as every change may entail additional work for translators.  In order to help them, it is possible to make recommendations or instructions visible to them by inserting special comments like this (@pxref{xgettext Invocation,,, gettext, GNU Gettext}):"
msgstr "La traduzione è un lavoro impegnativo, quindi, come pacchettizzatore, ti preghiamo di prestare ancora più attenzione alle tue sinossi e descrizioni, poiché ogni modifica può comportare un lavoro aggiuntivo per i traduttori. Per aiutarli, è possibile rendere visibili raccomandazioni o istruzioni inserendo commenti speciali come questo (@pxref{xgettext Invocation,,, gettext, GNU Gettext}):"

msgid ""
";; TRANSLATORS: \"X11 resize-and-rotate\" should not be translated.\n"
"(description \"ARandR is designed to provide a simple visual front end\n"
"for the X11 resize-and-rotate (RandR) extension. @dots{}\")\n"
msgstr ""
";; TRANSLATORS: \"X11 resize-and-rotate\" non deve essere tradotto.\n"
"(description \"ARandR è progettato per fornire un semplice front-end visivo per l'estensione X11 resize-and-rotate (RandR). @dots{}\")\n"

msgid "snippets, when to use"
msgstr "snippet, quando usarli"

msgid "The boundary between using an origin snippet versus a build phase to modify the sources of a package can be elusive.  Origin snippets are typically used to remove unwanted files such as bundled libraries, nonfree sources, or to apply simple substitutions.  The source derived from an origin should produce a source that can be used to build the package on any system that the upstream package supports (i.e., act as the corresponding source).  In particular, origin snippets must not embed store items in the sources; such patching should rather be done using build phases.  Refer to the @code{origin} record documentation for more information (@pxref{origin Reference})."
msgstr "Il confine tra l'uso di uno snippet di origine e una fase di compilazione per modificare i sorgenti di un pacchetto può essere sfuggente. Gli snippet di origine sono tipicamente usati per rimuovere file indesiderati come librerie incluse, sorgenti non liberi o per applicare semplici sostituzioni. Il sorgente derivato da un'origine dovrebbe produrre un sorgente che può essere usato per costruire il pacchetto su qualsiasi sistema supportato dal pacchetto upstream (cioè, agire come sorgente corrispondente). In particolare, gli snippet di origine non devono incorporare elementi dello store nei sorgenti; tale patching dovrebbe essere fatto usando le fasi di compilazione. Fai riferimento alla documentazione del record @code{origin} per maggiori informazioni (@pxref{origin Reference})."

msgid "While there cannot be circular dependencies between packages, Guile's lax module loading mechanism allows circular dependencies between Guile modules, which doesn't cause problems as long as the following conditions are followed for two modules part of a dependency cycle:"
msgstr "Sebbene non possano esserci dipendenze circolari tra i pacchetti, il meccanismo di caricamento dei moduli di Guile, meno rigido, permette dipendenze circolari tra i moduli Guile, il che non causa problemi finché le seguenti condizioni sono rispettate per due moduli che fanno parte di un ciclo di dipendenze:"

msgid "rules to cope with circular module dependencies"
msgstr "regole per gestire le dipendenze circolari tra moduli"

msgid "Macros are not shared between the co-dependent modules"
msgstr "Le macro non sono condivise tra i moduli co-dipendenti"

msgid "Top-level variables are only referenced in delayed (@i{thunked}) package fields: @code{arguments}, @code{native-inputs}, @code{inputs}, @code{propagated-inputs} or @code{replacement}"
msgstr "Le variabili di primo livello sono referenziate solo nei campi di pacchetto ritardati (@i{thunked}): @code{arguments}, @code{native-inputs}, @code{inputs}, @code{propagated-inputs} o @code{replacement}"

msgid "Procedures referencing top-level variables from another module are not called at the top level of a module themselves."
msgstr "Le procedure che referenziano variabili di primo livello di un altro modulo non sono chiamate esse stesse a livello di primo livello di un modulo."

msgid "Straying away from the above rules may work while there are no dependency cycles between modules, but given such cycles are confusing and difficult to troubleshoot, it is best to follow the rules to avoid introducing problems down the line."
msgstr "Deviare dalle regole sopra indicate può funzionare finché non ci sono cicli di dipendenza tra i moduli, ma dato che tali cicli sono confusi e difficili da risolvere, è meglio seguire le regole per evitare di introdurre problemi in futuro."

msgid "Here is a common trap to avoid:"
msgstr "Ecco una trappola comune da evitare:"

msgid ""
"(define-public avr-binutils\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"
msgstr ""
"(define-public avr-binutils\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"

msgid "In the above example, the @code{avr-binutils} package was defined in the module @code{(gnu packages avr)}, and the @code{cross-binutils} procedure in @code{(gnu packages cross-base)}.  Because the @code{inherit} field is not delayed (thunked), it is evaluated at the top level at load time, which is problematic in the presence of module dependency cycles.  This could be resolved by turning the package into a procedure instead, like:"
msgstr "Nell'esempio sopra, il pacchetto @code{avr-binutils} è stato definito nel modulo @code{(gnu packages avr)}, e la procedura @code{cross-binutils} in @code{(gnu packages cross-base)}. Poiché il campo @code{inherit} non è ritardato (thunked), viene valutato a livello di primo livello al momento del caricamento, il che è problematico in presenza di cicli di dipendenza tra i moduli. Questo potrebbe essere risolto trasformando il pacchetto in una procedura, come:"

msgid ""
"(define (make-avr-binutils)\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"
msgstr ""
"(define (make-avr-binutils)\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"

msgid "Care would need to be taken to ensure the above procedure is only ever used in a package delayed fields or within another procedure also not called at the top level."
msgstr "Bisognerebbe fare attenzione per assicurarsi che la procedura sopra descritta venga usata solo nei campi ritardati di un pacchetto o all'interno di un'altra procedura che non venga anch'essa chiamata al livello più alto."

msgid "emacs, packaging"
msgstr "emacs, pacchettizzazione"

msgid "elisp, packaging"
msgstr "elisp, pacchettizzazione"

msgid "Emacs packages should preferably use the Emacs build system (@pxref{emacs-build-system}), for uniformity and the benefits provided by its build phases, such as the auto-generation of the autoloads file and the byte compilation of the sources.  Because there is no standardized way to run a test suite for Emacs packages, tests are disabled by default.  When a test suite is available, it should be enabled by setting the @code{#:tests?} argument to @code{#true}.  By default, the command to run the test is @command{make check}, but any command can be specified via the @code{#:test-command} argument.  The @code{#:test-command} argument expects a list containing a command and its arguments, to be invoked during the @code{check} phase."
msgstr "I pacchetti Emacs dovrebbero preferibilmente usare il sistema di compilazione Emacs (@pxref{emacs-build-system}), per uniformità e per i benefici forniti dalle sue fasi di compilazione, come la generazione automatica del file di autoload e la compilazione in bytecode dei sorgenti. Poiché non esiste un modo standardizzato per eseguire una suite di test per i pacchetti Emacs, i test sono disabilitati per impostazione predefinita. Quando una suite di test è disponibile, dovrebbe essere abilitata impostando l'argomento @code{#:tests?} a @code{#true}. Per impostazione predefinita, il comando per eseguire il test è @command{make check}, ma qualsiasi comando può essere specificato tramite l'argomento @code{#:test-command}. L'argomento @code{#:test-command} si aspetta una lista contenente un comando e i suoi argomenti, da invocare durante la fase @code{check}."

msgid "The Elisp dependencies of Emacs packages are typically provided as @code{propagated-inputs} when required at run time.  As for other packages, build or test dependencies should be specified as @code{native-inputs}."
msgstr "Le dipendenze Elisp dei pacchetti Emacs sono tipicamente fornite come @code{propagated-inputs} quando richieste a runtime. Come per altri pacchetti, le dipendenze di compilazione o di test dovrebbero essere specificate come @code{native-inputs}."

msgid "Emacs packages sometimes depend on resources directories that should be installed along the Elisp files.  The @code{#:include} argument can be used for that purpose, by specifying a list of regexps to match.  The best practice when using the @code{#:include} argument is to extend rather than override its default value (accessible via the @code{%default-include} variable).  As an example, a yasnippet extension package typically include a @file{snippets} directory, which could be copied to the installation directory using:"
msgstr "I pacchetti Emacs a volte dipendono da directory di risorse che dovrebbero essere installate insieme ai file Elisp. L'argomento @code{#:include} può essere usato a questo scopo, specificando una lista di espressioni regolari da corrispondere. La buona pratica quando si usa l'argomento @code{#:include} è di estendere piuttosto che sovrascrivere il suo valore predefinito (accessibile tramite la variabile @code{%default-include}). Ad esempio, un pacchetto di estensione yasnippet include tipicamente una directory @file{snippets}, che potrebbe essere copiata nella directory di installazione usando:"

msgid "#:include (cons \"^snippets/\" %default-include)\n"
msgstr "#:include (cons \"^snippets/\" %default-include)\n"

msgid "When encountering problems, it is wise to check for the presence of the @code{Package-Requires} extension header in the package main source file, and whether any dependencies and their versions listed therein are satisfied."
msgstr "Quando si incontrano problemi, è saggio verificare la presenza dell'header dell'estensione @code{Package-Requires} nel file sorgente principale del pacchetto, e se tutte le dipendenze e le loro versioni elencate lì sono soddisfatte."

msgid "python"
msgstr "python"

msgid "Specifying Dependencies"
msgstr "Specifica delle dipendenze"

msgid "inputs, for Python packages"
msgstr "input, per i pacchetti Python"

msgid "Dependency information for Python packages is usually available in the package source tree, with varying degrees of accuracy: in the @file{pyproject.toml} file, the @file{setup.py} file, in @file{requirements.txt}, or in @file{tox.ini} (the latter mostly for test dependencies)."
msgstr "Le informazioni sulle dipendenze per i pacchetti Python sono di solito disponibili nell'albero dei sorgenti del pacchetto, con vari gradi di precisione: nel file @file{pyproject.toml}, nel file @file{setup.py}, in @file{requirements.txt}, o in @file{tox.ini} (quest'ultimo principalmente per le dipendenze di test)."

msgid "Python dependencies required at run time go into @code{propagated-inputs}.  They are typically defined with the @code{install_requires} keyword in @file{setup.py}, or in the @file{requirements.txt} file."
msgstr "Le dipendenze Python richieste a runtime vanno in @code{propagated-inputs}. Sono tipicamente definite con la parola chiave @code{install_requires} in @file{setup.py}, o nel file @file{requirements.txt}."

msgid "Examples are the @code{pytest}, @code{mock}, and @code{stestr} test frameworks.  Of course if any of these packages is also required at run-time, it needs to go to @code{propagated-inputs}."
msgstr "Esempi sono i framework di test @code{pytest}, @code{mock} e @code{stestr}. Naturalmente, se uno di questi pacchetti è richiesto anche a runtime, deve andare in @code{propagated-inputs}."

msgid "Anything that does not fall in the previous categories goes to @code{inputs}, for example programs or C libraries required for building Python packages containing C extensions."
msgstr "Tutto ciò che non rientra nelle categorie precedenti va in @code{inputs}, ad esempio programmi o librerie C richiesti per la compilazione di pacchetti Python contenenti estensioni C."

msgid "If a Python package has optional dependencies (@code{extras_require}), it is up to you to decide whether to add them or not, based on their usefulness/overhead ratio (@pxref{Submitting Patches, @command{guix size}})."
msgstr "Se un pacchetto Python ha dipendenze opzionali (@code{extras_require}), sta a te decidere se aggiungerle o meno, in base al loro rapporto utilità/sovraccarico (@pxref{Submitting Patches, @command{guix size}})."

msgid "perl"
msgstr "perl"

msgid "Perl programs standing for themselves are named as any other package, using the lowercase upstream name.  For Perl packages containing a single class, we use the lowercase class name, replace all occurrences of @code{::} by dashes and prepend the prefix @code{perl-}.  So the class @code{XML::Parser} becomes @code{perl-xml-parser}.  Modules containing several classes keep their lowercase upstream name and are also prepended by @code{perl-}.  Such modules tend to have the word @code{perl} somewhere in their name, which gets dropped in favor of the prefix.  For instance, @code{libwww-perl} becomes @code{perl-libwww}."
msgstr "I programmi Perl autonomi sono nominati come qualsiasi altro pacchetto, usando il nome upstream in minuscolo. Per i pacchetti Perl che contengono una singola classe, usiamo il nome della classe in minuscolo, sostituiamo tutte le occorrenze di @code{::} con trattini e anteponiamo il prefisso @code{perl-}. Così la classe @code{XML::Parser} diventa @code{perl-xml-parser}. I moduli che contengono diverse classi mantengono il loro nome upstream in minuscolo e sono anch'essi preceduti da @code{perl-}. Tali moduli tendono ad avere la parola @code{perl} da qualche parte nel loro nome, che viene omessa in favore del prefisso. Ad esempio, @code{libwww-perl} diventa @code{perl-libwww}."

msgid "java"
msgstr "java"

msgid "Java programs standing for themselves are named as any other package, using the lowercase upstream name."
msgstr "I programmi Java autonomi sono nominati come qualsiasi altro pacchetto, usando il nome upstream in minuscolo."

msgid "To avoid confusion and naming clashes with other programming languages, it is desirable that the name of a package for a Java package is prefixed with @code{java-}.  If a project already contains the word @code{java}, we drop this; for instance, the package @code{ngsjava} is packaged under the name @code{java-ngs}."
msgstr "Per evitare confusione e conflitti di nomi con altri linguaggi di programmazione, è desiderabile che il nome di un pacchetto per un pacchetto Java sia preceduto dal prefisso @code{java-}. Se un progetto contiene già la parola @code{java}, la omettiamo; ad esempio, il pacchetto @code{ngsjava} è pacchettizzato con il nome @code{java-ngs}."

msgid "For Java packages containing a single class or a small class hierarchy, we use the lowercase class name, replace all occurrences of @code{.} by dashes and prepend the prefix @code{java-}.  So the class @code{apache.commons.cli} becomes package @code{java-apache-commons-cli}."
msgstr "Per i pacchetti Java che contengono una singola classe o una piccola gerarchia di classi, usiamo il nome della classe in minuscolo, sostituiamo tutte le occorrenze di @code{.} con trattini e anteponiamo il prefisso @code{java-}. Così la classe @code{apache.commons.cli} diventa il pacchetto @code{java-apache-commons-cli}."

msgid "rust"
msgstr "rust"

msgid "Elm"
msgstr "Elm"

msgid "Elm applications can be named like other software: their names need not mention Elm."
msgstr "Le applicazioni Elm possono essere nominate come altri software: i loro nomi non devono necessariamente menzionare Elm."

msgid "Packages in the Elm sense (see @code{elm-build-system} under @ref{Build Systems}) are required use names of the format @var{author}@code{/}@var{project}, where both the @var{author} and the @var{project} may contain hyphens internally, and the @var{author} sometimes contains uppercase letters."
msgstr "I pacchetti in senso Elm (vedi @code{elm-build-system} in @ref{Build Systems}) devono usare nomi nel formato @var{autore}@code{/}@var{progetto}, dove sia l'@var{autore} che il @var{progetto} possono contenere trattini al loro interno, e l'@var{author} a volte contiene lettere maiuscole."

msgid "To form the Guix package name from the upstream name, we follow a convention similar to Python packages (@pxref{Python Modules}), adding an @code{elm-} prefix unless the name would already begin with @code{elm-}."
msgstr "Per formare il nome del pacchetto Guix dal nome upstream, seguiamo una convenzione simile a quella dei pacchetti Python (@pxref{Python Modules}), aggiungendo un prefisso @code{elm-} a meno che il nome non inizi già con @code{elm-}."

msgid "In many cases we can reconstruct an Elm package's upstream name heuristically, but, since conversion to a Guix-style name involves a loss of information, this is not always possible.  Care should be taken to add the @code{'upstream-name} property when necessary so that @samp{guix import elm} will work correctly (@pxref{Invoking guix import}). The most notable scenarios when explicitly specifying the upstream name is necessary are:"
msgstr "In molti casi possiamo ricostruire euristicamente il nome upstream di un pacchetto Elm, ma, poiché la conversione a un nome in stile Guix comporta una perdita di informazioni, questo non è sempre possibile. Bisogna fare attenzione ad aggiungere la proprietà @code{'upstream-name} quando necessario, in modo che @samp{guix import elm} funzioni correttamente (@pxref{Invoking guix import}). Gli scenari più notevoli in cui è necessario specificare esplicitamente il nome upstream sono:"

msgid "When the @var{author} is @code{elm} and the @var{project} contains one or more hyphens, as with @code{elm/virtual-dom}; and"
msgstr "Quando l'@var{author} è @code{elm} e il @var{progetto} contiene uno o più trattini, come con @code{elm/virtual-dom}; e"

msgid "When the @var{author} contains hyphens or uppercase letters, as with @code{Elm-Canvas/raster-shapes}---unless the @var{author} is @code{elm-explorations}, which is handled as a special case, so packages like @code{elm-explorations/markdown} do @emph{not} need to use the @code{'upstream-name} property."
msgstr "Quando l'@var{author} contiene trattini o lettere maiuscole, come con @code{Elm-Canvas/raster-shapes} --- a meno che l'@var{autore} non sia @code{elm-explorations}, che è gestito come un caso speciale, quindi pacchetti come @code{elm-explorations/markdown} @emph{non} hanno bisogno di usare la proprietà @code{'upstream-name}."

msgid "The module @code{(guix build-system elm)} provides the following utilities for working with names and related conventions:"
msgstr "Il modulo @code{(guix build-system elm)} fornisce le seguenti utilità per lavorare con i nomi e le convenzioni correlate:"

msgid "{Procedure} elm-package-origin @var{elm-name} @var{version} @"
msgstr "{Procedure} elm-package-origin @var{elm-name} @var{version} @"

msgid "@var{hash} Returns a Git origin using the repository naming and tagging regime required for a published Elm package with the upstream name @var{elm-name} at version @var{version} with sha256 checksum @var{hash}."
msgstr "@var{hash} Restituisce un'origine Git usando il regime di denominazione e tagging del repository richiesto per un pacchetto Elm pubblicato con il nome upstream @var{elm-name} alla versione @var{version} con checksum sha256 @var{hash}."

msgid "For example:"
msgstr "Per esempio:"

msgid ""
"(package\n"
"  (name \"elm-html\")\n"
"  (version \"1.0.0\")\n"
"  (source\n"
"   (elm-package-origin\n"
"    \"elm/html\"\n"
"    version\n"
"    (base32 \"15k1679ja57vvlpinpv06znmrxy09lbhzfkzdc89i01qa8c4gb4a\")))\n"
"  ...)\n"
msgstr ""
"(package\n"
"  (name \"elm-html\")\n"
"  (version \"1.0.0\")\n"
"  (source\n"
"   (elm-package-origin\n"
"    \"elm/html\"\n"
"    version\n"
"    (base32 \"15k1679ja57vvlpinpv06znmrxy09lbhzfkzdc89i01qa8c4gb4a\")))\n"
"  ...)\n"

msgid "{Procedure} elm->package-name @var{elm-name}"
msgstr "{Procedure} elm->package-name @var{elm-name}"

msgid "Returns the Guix-style package name for an Elm package with upstream name @var{elm-name}."
msgstr "Restituisce il nome del pacchetto in stile Guix per un pacchetto Elm con nome upstream @var{elm-name}."

msgid "Note that there is more than one possible @var{elm-name} for which @code{elm->package-name} will produce a given result."
msgstr "Nota che c'è più di un possibile @var{elm-name} per cui @code{elm->package-name} produrrà un dato risultato."

msgid "{Procedure} guix-package->elm-name @var{package}"
msgstr "{Procedure} guix-package->elm-name @var{package}"

msgid "Given an Elm @var{package}, returns the possibly-inferred upstream name, or @code{#f} the upstream name is not specified via the @code{'upstream-name} property and can not be inferred by @code{infer-elm-package-name}."
msgstr "Dato un @var{package} Elm, restituisce il nome upstream possibilmente inferito, o @code{#f} se il nome upstream non è specificato tramite la proprietà @code{'upstream-name} e non può essere inferito da @code{infer-elm-package-name}."

msgid "{Procedure} infer-elm-package-name @var{guix-name}"
msgstr "{Procedure} infer-elm-package-name @var{guix-name}"

msgid "Given the @var{guix-name} of an Elm package, returns the inferred upstream name, or @code{#f} if the upstream name can't be inferred.  If the result is not @code{#f}, supplying it to @code{elm->package-name} would produce @var{guix-name}."
msgstr "Dato il @var{guix-name} di un pacchetto Elm, restituisce il nome upstream inferito, o @code{#f} se il nome upstream non può essere inferito. Se il risultato non è @code{#f}, fornendolo a @code{elm->package-name} si otterrebbe @var{guix-name}."

msgid "fonts"
msgstr "font"

msgid "For fonts that are in general not installed by a user for typesetting purposes, or that are distributed as part of a larger software package, we rely on the general packaging rules for software; for instance, this applies to the fonts delivered as part of the X.Org system or fonts that are part of TeX Live."
msgstr "Per i font che in generale non sono installati da un utente per scopi di composizione tipografica, o che sono distribuiti come parte di un pacchetto software più grande, ci basiamo sulle regole generali di pacchettizzazione per il software; ad esempio, questo si applica ai font forniti come parte del sistema X.Org o ai font che fanno parte di TeX Live."

msgid "To make it easier for a user to search for fonts, names for other packages containing only fonts are constructed as follows, independently of the upstream package name."
msgstr "Per facilitare la ricerca dei font da parte dell'utente, i nomi degli altri pacchetti che contengono solo font sono costruiti come segue, indipendentemente dal nome del pacchetto upstream."

msgid "The name of a package containing only one font family starts with @code{font-}; it is followed by the foundry name and a dash @code{-} if the foundry is known, and the font family name, in which spaces are replaced by dashes (and as usual, all upper case letters are transformed to lower case).  For example, the Gentium font family by SIL is packaged under the name @code{font-sil-gentium}."
msgstr "Il nome di un pacchetto che contiene una sola famiglia di font inizia con @code{font-}; è seguito dal nome della fonderia e da un trattino @code{-} se la fonderia è nota, e dal nome della famiglia di font, in cui gli spazi sono sostituiti da trattini (e come al solito, tutte le lettere maiuscole sono trasformate in minuscole). Ad esempio, la famiglia di font Gentium di SIL è pacchettizzata con il nome @code{font-sil-gentium}."

msgid "For a package containing several font families, the name of the collection is used in the place of the font family name.  For instance, the Liberation fonts consist of three families, Liberation Sans, Liberation Serif and Liberation Mono.  These could be packaged separately under the names @code{font-liberation-sans} and so on; but as they are distributed together under a common name, we prefer to package them together as @code{font-liberation}."
msgstr "Per un pacchetto che contiene diverse famiglie di font, il nome della collezione viene usato al posto del nome della famiglia di font. Ad esempio, i font Liberation consistono di tre famiglie, Liberation Sans, Liberation Serif e Liberation Mono. Questi potrebbero essere pacchettizzati separatamente con i nomi @code{font-liberation-sans} e così via; ma poiché sono distribuiti insieme sotto un nome comune, preferiamo pacchettizzarli insieme come @code{font-liberation}."

msgid "In the case where several formats of the same font family or font collection are packaged separately, a short form of the format, prepended by a dash, is added to the package name.  We use @code{-ttf} for TrueType fonts, @code{-otf} for OpenType fonts and @code{-type1} for PostScript Type 1 fonts."
msgstr "Nel caso in cui diversi formati della stessa famiglia di font o collezione di font siano pacchettizzati separatamente, una forma breve del formato, preceduta da un trattino, viene aggiunta al nome del pacchetto. Usiamo @code{-ttf} per i font TrueType, @code{-otf} per i font OpenType e @code{-type1} per i font PostScript Type 1."

msgid "In general our code follows the GNU Coding Standards (@pxref{Top,,, standards, GNU Coding Standards}).  However, they do not say much about Scheme, so here are some additional rules."
msgstr "In generale il nostro codice segue gli standard di codifica GNU (@pxref{Top,,, standards, GNU Coding Standards}). Tuttavia, non dicono molto su Scheme, quindi ecco alcune regole aggiuntive."

msgid "Programming Paradigm"
msgstr "Paradigma di programmazione"

msgid "How to compose your elements."
msgstr "Come comporre i tuoi elementi."

msgid "Modules"
msgstr "Moduli"

msgid "Where to store your code?"
msgstr "Dove conservare il tuo codice?"

msgid "Data Types and Pattern Matching"
msgstr "Tipi di dati e pattern matching"

msgid "Implementing data structures."
msgstr "Implementazione di strutture dati."

msgid "Formatting Code"
msgstr "Formattazione del codice"

msgid "Writing conventions."
msgstr "Convenzioni di scrittura."

msgid "Scheme code in Guix is written in a purely functional style.  One exception is code that involves input/output, and procedures that implement low-level concepts, such as the @code{memoize} procedure."
msgstr "Il codice Scheme in Guix è scritto in uno stile puramente funzionale. Un'eccezione è il codice che coinvolge l'input/output e le procedure che implementano concetti a basso livello, come la procedura @code{memoize}."

msgid "build-side modules"
msgstr "moduli lato-build"

msgid "host-side modules"
msgstr "moduli lato-host"

msgid "Guile modules that are meant to be used on the builder side must live in the @code{(guix build @dots{})} name space.  They must not refer to other Guix or GNU modules.  However, it is OK for a ``host-side'' module to use a build-side module.  As an example, the @code{(guix search-paths)} module should not be imported and used by a package since it isn't meant to be used as a ``build-side'' module.  It would also couple the module with the package's dependency graph, which is undesirable."
msgstr "I moduli Guile destinati a essere usati sul lato del costruttore devono vivere nello spazio dei nomi @code{(guix build @dots{})}. Non devono fare riferimento ad altri moduli Guix o GNU. Tuttavia, è accettabile che un modulo ``lato-host'' usi un modulo lato-build. Ad esempio, il modulo @code{(guix search-paths)} non dovrebbe essere importato e usato da un pacchetto poiché non è destinato a essere usato come un modulo ``lato-build''. Ciò accoppierebbe anche il modulo con il grafo delle dipendenze del pacchetto, il che è indesiderabile."

msgid "Modules that deal with the broader GNU system should be in the @code{(gnu @dots{})} name space rather than @code{(guix @dots{})}."
msgstr "I moduli che si occupano del sistema GNU più ampio dovrebbero trovarsi nello spazio dei nomi @code{(gnu @dots{})} piuttosto che in @code{(guix @dots{})}."

msgid "The tendency in classical Lisp is to use lists to represent everything, and then to browse them ``by hand'' using @code{car}, @code{cdr}, @code{cadr}, and co.  There are several problems with that style, notably the fact that it is hard to read, error-prone, and a hindrance to proper type error reports."
msgstr "La tendenza nel Lisp classico è di usare le liste per rappresentare tutto, e poi di sfogliarle ``a mano'' usando @code{car}, @code{cdr}, @code{cadr} e co. Ci sono diversi problemi con questo stile, in particolare il fatto che è difficile da leggere, incline a errori e un ostacolo a corrette segnalazioni di errore di tipo."

msgid "define-record-type*"
msgstr "define-record-type*"

msgid "match-record"
msgstr "match-record"

msgid "pattern matching"
msgstr "pattern matching"

msgid "Guix code should define appropriate data types (for instance, using @code{define-record-type*}) rather than abuse lists.  In addition, it should use pattern matching, via Guile’s @code{(ice-9 match)} module, especially when matching lists (@pxref{Pattern Matching,,, guile, GNU Guile Reference Manual}); pattern matching for records is better done using @code{match-record} from @code{(guix records)}, which, unlike @code{match}, verifies field names at macro-expansion time."
msgstr "Il codice Guix dovrebbe definire tipi di dati appropriati (ad esempio, usando @code{define-record-type*}) piuttosto che abusare delle liste. Inoltre, dovrebbe usare il pattern matching, tramite il modulo @code{(ice-9 match)} di Guile, specialmente quando si abbinano le liste (@pxref{Pattern Matching,,, guile, GNU Guile Reference Manual}); il pattern matching per i record è meglio farlo usando @code{match-record} da @code{(guix records)}, che, a differenza di @code{match}, verifica i nomi dei campi al momento dell'espansione della macro."

msgid "When defining a new record type, keep the @dfn{record type descriptor} (RTD) private (@pxref{Records,,, guile, GNU Guile Reference Manual}, for more on records and RTDs).  As an example, the @code{(guix packages)} module defines @code{<package>} as the RTD for package records but it does not export it; instead, it exports a type predicate, a constructor, and field accessors.  Exporting RTDs would make it harder to change the application binary interface (because code in other modules might be matching fields by position) and would make it trivial for users to forge records of that type, bypassing any checks we may have in the official constructor (such as ``field sanitizers'')."
msgstr "Quando si definisce un nuovo tipo di record, mantenere privato il @dfn{descrittore di tipo di record} (RTD) (@pxref{Records,,, guile, GNU Guile Reference Manual}, per maggiori informazioni sui record e sugli RTD). Ad esempio, il modulo @code{(guix packages)} definisce @code{<package>} come RTD per i record di pacchetto, ma non lo esporta; invece, esporta un predicato di tipo, un costruttore e degli accessor ai campi. L'esportazione degli RTD renderebbe più difficile cambiare l'interfaccia binaria dell'applicazione (perché il codice in altri moduli potrebbe abbinare i campi per posizione) e renderebbe banale per gli utenti forgiare record di quel tipo, bypassando qualsiasi controllo che potremmo avere nel costruttore ufficiale (come i ``sanitizer di campo'')."

msgid "formatting code"
msgstr "formattazione del codice"

msgid "coding style"
msgstr "stile di codifica"

msgid "When writing Scheme code, we follow common wisdom among Scheme programmers.  In general, we follow the @url{https://mumble.net/~campbell/scheme/style.txt, Riastradh's Lisp Style Rules}.  This document happens to describe the conventions mostly used in Guile’s code too.  It is very thoughtful and well written, so please do read it."
msgstr "Quando scriviamo codice Scheme, seguiamo la saggezza comune tra i programmatori Scheme. In generale, seguiamo le @url{https://mumble.net/~campbell/scheme/style.txt, Regole di stile Lisp di Riastradh}. Questo documento descrive anche le convenzioni più usate nel codice di Guile. È molto ben ponderato e ben scritto, quindi vi preghiamo di leggerlo."

msgid "Some special forms introduced in Guix, such as the @code{substitute*} macro, have special indentation rules.  These are defined in the @file{.dir-locals.el} file, which Emacs automatically uses.  Also note that Emacs-Guix provides @code{guix-devel-mode} mode that indents and highlights Guix code properly (@pxref{Development,,, emacs-guix, The Emacs-Guix Reference Manual})."
msgstr "Alcune forme speciali introdotte in Guix, come la macro @code{substitute*}, hanno regole di indentazione speciali. Queste sono definite nel file @file{.dir-locals.el}, che Emacs usa automaticamente. Nota anche che Emacs-Guix fornisce la modalità @code{guix-devel-mode} che indenta ed evidenzia il codice Guix correttamente (@pxref{Development,,, emacs-guix, The Emacs-Guix Reference Manual})."

msgid "indentation, of code"
msgstr "indentazione, del codice"

msgid "formatting, of code"
msgstr "formattazione, del codice"

msgid "If you do not use Emacs, please make sure your editor knows these rules.  To automatically indent a package definition, you can also run:"
msgstr "Se non usi Emacs, assicurati che il tuo editor conosca queste regole. Per indentare automaticamente una definizione di pacchetto, puoi anche eseguire:"

msgid "./pre-inst-env guix style @var{package}\n"
msgstr "./pre-inst-env guix style @var{package}\n"

msgid "@xref{Invoking guix style}, for more information."
msgstr "@xref{Invoking guix style}, per maggiori informazioni."

msgid "We require all top-level procedures to carry a docstring.  This requirement can be relaxed for simple private procedures in the @code{(guix build @dots{})} name space, though."
msgstr "Richiediamo che tutte le procedure di primo livello abbiano una docstring. Questo requisito può essere rilassato per semplici procedure private nello spazio dei nomi @code{(guix build @dots{})}, però."

msgid "Procedures should not have more than four positional parameters.  Use keyword parameters for procedures that take more than four parameters."
msgstr "Le procedure non dovrebbero avere più di quattro parametri posizionali. Usa parametri con parola chiave per le procedure che accettano più di quattro parametri."

msgid "Contributors are encouraged to take a moment to set some Git repository options (@pxref{Configuring Git}) first, which can improve the readability of patches.  Seasoned Guix developers may also want to look at the section on commit access (@pxref{Commit Access})."
msgstr "I contributori sono incoraggiati a dedicare un momento per impostare alcune opzioni del repository Git (@pxref{Configuring Git}) prima, il che può migliorare la leggibilità delle patch. Gli sviluppatori esperti di Guix potrebbero anche voler dare un'occhiata alla sezione sull'accesso ai commit (@pxref{Commit Access})."

msgid "Please write commit logs in the ChangeLog format (@pxref{Change Logs,,, standards, GNU Coding Standards}); you can check the commit history for examples."
msgstr "Per favore, scrivi i log dei commit nel formato ChangeLog (@pxref{Change Logs,,, standards, GNU Coding Standards}); puoi controllare la cronologia dei commit per degli esempi."

msgid "You can help make the review process more efficient, and increase the chance that your patch will be reviewed quickly, by describing the context of your patch and the impact you expect it to have.  For example, if your patch is fixing something that is broken, describe the problem and how your patch fixes it.  Tell us how you have tested your patch.  Will users of the code changed by your patch have to adjust their workflow at all? If so, tell us how.  In general, try to imagine what questions a reviewer will ask, and answer those questions in advance."
msgstr "Puoi contribuire a rendere il processo di revisione più efficiente e aumentare le possibilità che la tua patch venga revisionata rapidamente, descrivendo il contesto della tua patch e l'impatto che ti aspetti che abbia. Ad esempio, se la tua patch corregge qualcosa che non funziona, descrivi il problema e come la tua patch lo risolve. Dicci come hai testato la tua patch. Gli utenti del codice modificato dalla tua patch dovranno adeguare in qualche modo il loro flusso di lavoro? Se sì, dicci come. In generale, cerca di immaginare quali domande porrà un revisore e rispondi a quelle domande in anticipo."

msgid "Before submitting a patch that adds or modifies a package definition, please run through this check list:"
msgstr "Prima di inviare una patch che aggiunge o modifica una definizione di pacchetto, per favore segui questa lista di controllo:"

msgid "If the authors of the packaged software provide a cryptographic signature for the release tarball, make an effort to verify the authenticity of the archive.  For a detached GPG signature file this would be done with the @code{gpg --verify} command."
msgstr "Se gli autori del software pacchettizzato forniscono una firma crittografica per il tarball di rilascio, fai uno sforzo per verificare l'autenticità dell'archivio. Per un file di firma GPG distaccato, questo verrebbe fatto con il comando @code{gpg --verify}."

msgid "Take some time to provide an adequate synopsis and description for the package.  @xref{Synopses and Descriptions}, for some guidelines."
msgstr "Prenditi del tempo per fornire una sinossi e una descrizione adeguate per il pacchetto. @xref{Synopses and Descriptions}, per alcune linee guida."

msgid "Run @command{guix lint @var{package}}, where @var{package} is the name of the new or modified package, and fix any errors it reports (@pxref{Invoking guix lint})."
msgstr "Esegui @command{guix lint @var{package}}, dove @var{package} è il nome del pacchetto nuovo o modificato, e correggi eventuali errori segnalati (@pxref{Invoking guix lint})."

msgid "Run @command{guix style @var{package}} to format the new package definition according to the project's conventions (@pxref{Invoking guix style})."
msgstr "Esegui @command{guix style @var{package}} per formattare la nuova definizione di pacchetto secondo le convenzioni del progetto (@pxref{Invoking guix style})."

msgid "Make sure the package builds on your platform, using @command{guix build @var{package}}.  Also build at least its direct dependents with @command{guix build --dependents=1 @var{package}} (@pxref{build-dependents, @command{guix build}})."
msgstr "Assicurati che il pacchetto si compili sulla tua piattaforma, usando @command{guix build @var{package}}. Compila anche almeno i suoi dipendenti diretti con @command{guix build --dependents=1 @var{package}} (@pxref{build-dependents, @command{guix build}})."

msgid "We recommend you also try building the package on other supported platforms.  As you may not have access to actual hardware platforms, we recommend using the @code{qemu-binfmt-service-type} to emulate them.  In order to enable it, add the @code{virtualization} service module and the following service to the list of services in your @code{operating-system} configuration:"
msgstr "Ti consigliamo di provare a costruire il pacchetto anche su altre piattaforme supportate. Poiché potresti non avere accesso a piattaforme hardware reali, ti consigliamo di usare il @code{qemu-binfmt-service-type} per emularle. Per abilitarlo, aggiungi il modulo di servizio @code{virtualization} e il seguente servizio alla lista dei servizi nella tua configurazione @code{operating-system}:"

msgid ""
"(service qemu-binfmt-service-type\n"
" (qemu-binfmt-configuration\n"
"   (platforms (lookup-qemu-platforms \"arm\" \"aarch64\"))))\n"
msgstr ""
"(service qemu-binfmt-service-type\n"
" (qemu-binfmt-configuration\n"
"   (platforms (lookup-qemu-platforms \"arm\" \"aarch64\"))))\n"

msgid "Then reconfigure your system."
msgstr "Quindi, riconfigura il tuo sistema."

msgid "You can then build packages for different platforms by specifying the @code{--system} option.  For example, to build the \"hello\" package for the armhf or aarch64 architectures, you would run the following commands, respectively:"
msgstr "Puoi quindi costruire pacchetti per diverse piattaforme specificando l'opzione @code{--system}. Ad esempio, per costruire il pacchetto \"hello\" per le architetture armhf o aarch64, dovresti eseguire i seguenti comandi, rispettivamente:"

msgid ""
"guix build --system=armhf-linux --rounds=2 hello\n"
"guix build --system=aarch64-linux --rounds=2 hello\n"
msgstr ""
"guix build --system=armhf-linux --rounds=2 hello\n"
"guix build --system=aarch64-linux --rounds=2 hello\n"

msgid "bundling"
msgstr "raggruppamento"

msgid "Make sure the package does not use bundled copies of software already available as separate packages."
msgstr "Assicurati che il pacchetto non usi copie raggruppate di software già disponibili come pacchetti separati."

msgid "Sometimes, packages include copies of the source code of their dependencies as a convenience for users.  However, as a distribution, we want to make sure that such packages end up using the copy we already have in the distribution, if there is one.  This improves resource usage (the dependency is built and stored only once), and allows the distribution to make transverse changes such as applying security updates for a given software package in a single place and have them affect the whole system---something that bundled copies prevent."
msgstr "A volte, i pacchetti includono copie del codice sorgente delle loro dipendenze per comodità degli utenti. Tuttavia, come distribuzione, vogliamo assicurarci che tali pacchetti finiscano per usare la copia che abbiamo già nella distribuzione, se ce n'è una. Questo migliora l'uso delle risorse (la dipendenza viene costruita e archiviata solo una volta), e permette alla distribuzione di apportare modifiche trasversali come l'applicazione di aggiornamenti di sicurezza per un dato pacchetto software in un unico posto e far sì che influenzino l'intero sistema --- qualcosa che le copie incluse impediscono."

msgid "Take a look at the profile reported by @command{guix size} (@pxref{Invoking guix size}).  This will allow you to notice references to other packages unwillingly retained.  It may also help determine whether to split the package (@pxref{Packages with Multiple Outputs}), and which optional dependencies should be used.  In particular, avoid adding @code{texlive} as a dependency: because of its extreme size, use @code{texlive-local-tree} procedure instead."
msgstr "Dai un'occhiata al profilo riportato da @command{guix size} (@pxref{Invoking guix size}). Questo ti permetterà di notare riferimenti a altri pacchetti trattenuti involontariamente. Può anche aiutare a determinare se dividere il pacchetto (@pxref{Packages with Multiple Outputs}), e quali dipendenze opzionali dovrebbero essere usate. In particolare, evita di aggiungere @code{texlive} come dipendenza: a causa delle sue dimensioni estreme, usa invece la procedura @code{texlive-local-tree}."

msgid "Check that dependent packages (if applicable) are not affected by the change; @command{guix refresh --list-dependent @var{package}} will help you do that (@pxref{Invoking guix refresh})."
msgstr "Verifica che i pacchetti dipendenti (se applicabile) non siano influenzati dalla modifica; @command{guix refresh --list-dependent @var{package}} ti aiuterà a farlo (@pxref{Invoking guix refresh})."

msgid "determinism, of build processes"
msgstr "determinismo, dei processi di compilazione"

msgid "reproducible builds, checking"
msgstr "build riproducibili, controllo"

msgid "Check whether the package's build process is deterministic.  This typically means checking whether an independent build of the package yields the exact same result that you obtained, bit for bit."
msgstr "Verifica se il processo di compilazione del pacchetto è deterministico. Questo significa tipicamente verificare se una compilazione indipendente del pacchetto produce lo stesso identico risultato che hai ottenuto, bit per bit."

msgid "A simple way to do that is by building the same package several times in a row on your machine (@pxref{Invoking guix build}):"
msgstr "Un modo semplice per farlo è costruire lo stesso pacchetto più volte di seguito sulla tua macchina (@pxref{Invoking guix build}):"

msgid "guix build --rounds=2 my-package\n"
msgstr "guix build --rounds=2 mio-pacchetto\n"

msgid "This is enough to catch a class of common non-determinism issues, such as timestamps or randomly-generated output in the build result."
msgstr "Questo è sufficiente per catturare una classe di problemi comuni di non determinismo, come timestamp o output generato casualmente nel risultato della compilazione."

msgid "Another option is to use @command{guix challenge} (@pxref{Invoking guix challenge}).  You may run it once the package has been committed and built by @code{@value{SUBSTITUTE-SERVER-1}} to check whether it obtains the same result as you did.  Better yet: Find another machine that can build it and run @command{guix publish}.  Since the remote build machine is likely different from yours, this can catch non-determinism issues related to the hardware---e.g., use of different instruction set extensions---or to the operating system kernel---e.g., reliance on @code{uname} or @file{/proc} files."
msgstr "Un'altra opzione è usare @command{guix challenge} (@pxref{Invoking guix challenge}). Puoi eseguirlo una volta che il pacchetto è stato committato e compilato da @code{@value{SUBSTITUTE-SERVER-1}} per verificare se ottiene lo stesso risultato che hai ottenuto tu. Ancora meglio: trova un'altra macchina che possa compilarlo ed esegui @command{guix publish}. Poiché la macchina di compilazione remota è probabilmente diversa dalla tua, questo può rilevare problemi di non-determinismo legati all'hardware --- ad esempio, l'uso di diverse estensioni del set di istruzioni --- o al kernel del sistema operativo --- ad esempio, la dipendenza da @code{uname} o dai file di @file{/proc}."

msgid "When writing documentation, please use gender-neutral wording when referring to people, such as @uref{https://en.wikipedia.org/wiki/Singular_they, singular ``they''@comma{} ``their''@comma{} ``them''}, and so forth."
msgstr "Quando scrivi la documentazione, per favore usa un linguaggio neutro dal punto di vista del genere quando ti riferisci a persone, come @uref{https://en.wikipedia.org/wiki/Singular_they, il ``loro'' singolare}, ecc."

msgid "Verify that your patch contains only one set of related changes.  Bundling unrelated changes together makes reviewing harder and slower."
msgstr "Verifica che la tua patch contenga solo un insieme di modifiche correlate. Raggruppare modifiche non correlate rende la revisione più difficile e lenta."

msgid "Examples of unrelated changes include the addition of several packages, or a package update along with fixes to that package."
msgstr "Esempi di modifiche non correlate includono l'aggiunta di diversi pacchetti, o un aggiornamento di un pacchetto insieme a correzioni per quel pacchetto."

msgid "Please follow our code formatting rules, possibly running @command{guix style} script to do that automatically for you (@pxref{Formatting Code})."
msgstr "Per favore, segui le nostre regole di formattazione del codice, eventualmente eseguendo lo script @command{guix style} per farlo automaticamente per te (@pxref{Formatting Code})."

msgid "When possible, use mirrors in the source URL (@pxref{Invoking guix download}).  Use reliable URLs, not generated ones.  For instance, GitHub archives are not necessarily identical from one generation to the next, so in this case it's often better to clone the repository.  Don't use the @code{name} field in the URL: it is not very useful and if the name changes, the URL will probably be wrong."
msgstr "Quando possibile, usa i mirror nell'URL sorgente (@pxref{Invoking guix download}). Usa URL affidabili, non generati. Ad esempio, gli archivi di GitHub non sono necessariamente identici da una generazione all'altra, quindi in questo caso è spesso meglio clonare il repository. Non usare il campo @code{name} nell'URL: non è molto utile e se il nome cambia, l'URL sarà probabilmente sbagliato."

msgid "Check if Guix builds (@pxref{Building from Git}) and address the warnings, especially those about use of undefined symbols."
msgstr "Controlla se Guix si compila (@pxref{Building from Git}) e risolvi gli avvisi, specialmente quelli sull'uso di simboli non definiti."

msgid "Make sure your changes do not break Guix and simulate a @command{guix pull} with:"
msgstr "Assicurati che le tue modifiche non rompano Guix e simula un @command{guix pull} con:"

msgid "guix pull --url=/path/to/your/checkout --profile=/tmp/guix.master --disable-authentication\n"
msgstr "guix pull --url=/percorso/del/tuo/checkout --profile=/tmp/guix.master --disable-authentication\n"

msgid "Configuring Git"
msgstr "Configurazione di Git"

msgid "git configuration"
msgstr "configurazione di git"

msgid "If you have not done so already, you may wish to set a name and email that will be associated with your commits (@pxref{telling git your name, , Telling Git your name, git, Git User Manual}).  If you wish to use a different name or email just for commits in this repository, you can use @command{git config --local}, or edit @file{.git/config} in the repository instead of @file{~/.gitconfig}."
msgstr "Se non l'hai già fatto, potresti voler impostare un nome e un'email che saranno associati ai tuoi commit (@pxref{telling git your name, , Telling Git your name, git, Manuale Utente di Git}). Se desideri usare un nome o un'email diversi solo per i commit in questo repository, puoi usare @command{git config --local}, o modificare @file{.git/config} nel repository invece di @file{~/.gitconfig}."

msgid "commit-msg hook"
msgstr "hook commit-msg"

msgid "Other important Git configuration will automatically be configured when building the project (@pxref{Building from Git}).  A @file{.git/hooks/commit-msg} hook will be installed that embeds @samp{Change-Id} Git @emph{trailers} in your commit messages for traceability purposes.  It is important to preserve these when editing your commit messages, particularly if a first version of your proposed changes was already submitted for review.  If you have a @file{commit-msg} hook of your own you would like to use with Guix, you can place it under the @file{.git/hooks/commit-msg.d/} directory."
msgstr "Altre configurazioni importanti di Git verranno configurate automaticamente durante la compilazione del progetto (@pxref{Building from Git}). Verrà installato un hook @file{.git/hooks/commit-msg} che incorpora @emph{trailer} @samp{Change-Id} di Git nei messaggi di commit per scopi di tracciabilità. È importante preservare questi elementi durante la modifica dei messaggi di commit, specialmente se una prima versione delle modifiche proposte è già stata inviata per la revisione. Se hai un tuo hook @file{commit-msg} che desideri usare con Guix, puoi posizionarlo nella directory @file{.git/hooks/commit-msg.d/}."

msgid "This section describes how the Guix project tracks its bug reports, patch submissions and topic branches."
msgstr "Questa sezione descrive come il progetto Guix tiene traccia dei report di bug, delle sottomissioni di patch e dei rami tematici."

msgid "The Issue Tracker"
msgstr "Il Tracker degli Issue"

msgid "The official bug and patch tracker."
msgstr "Il tracker ufficiale di bug e patch."

msgid "Managing Patches and Branches"
msgstr "Gestione di Patch e Rami"

msgid "How changes to Guix are managed."
msgstr "Come vengono gestite le modifiche a Guix."

msgid "Debbugs User Interfaces"
msgstr "Interfacce Utente di Debbugs"

msgid "Ways to interact with Debbugs."
msgstr "Modi per interagire con Debbugs."

msgid "Cuirass Build Notifications"
msgstr "Notifiche di Build di Cuirass"

msgid "Be alerted of any breakage via RSS feeds."
msgstr "Essere avvisati di qualsiasi interruzione tramite feed RSS."

msgid "Debbugs, issue tracking system"
msgstr "Debbugs, sistema di tracciamento degli issue"

msgid "Bug reports (@dfn{issues}) and patch submissions (@dfn{pull requests})  are currently tracked at the @uref{https://codeberg.org/guix/guix, project's home at Codeberg}."
msgstr "Le segnalazioni di bug (@dfn{issues}) e l'invio di patch (@dfn{pull request}) sono attualmente tracciate sulla @uref{https://codeberg.org/guix/guix, pagina del progetto su Codeberg}."

msgid "branching strategy"
msgstr "strategia di branching"

msgid "rebuild scheduling strategy"
msgstr "strategia di pianificazione delle ricostruzioni"

msgid "Submitted patches are picked up and tested by the quality assurance service; the result of that testing eventually shows up on the dashboard at @indicateurl{https://qa.guix.gnu.org/issue/@var{ISSUE_NUMBER}}, where @var{ISSUE_NUMBER} is the number assigned by the issue tracker, currently Debbugs (work is in progress to support Codeberg pull requests).  Leave time for a review, without committing anything."
msgstr "Le patch inviate vengono raccolte e testate dal servizio di assicurazione qualità; il risultato di questi test appare infine sulla dashboard all'indirizzo @indicateurl{https://qa.guix.gnu.org/issue/@var{ISSUE_NUMBER}}, dove @var{ISSUE_NUMBER} è il numero assegnato dal sistema di tracciamento dei problemi, attualmente Debbugs (è in corso il lavoro per supportare le pull request di Codeberg). Lascia tempo per una revisione, senza fare commit di nulla."

msgid "As an exception, some changes considered ``trivial'' or ``obvious'' may be pushed directly to the @code{master} branch.  This includes changes to fix typos and reverting commits that caused immediate problems.  This is subject to being adjusted, allowing individuals to commit directly on non-controversial changes on parts they’re familiar with."
msgstr "Come eccezione, alcune modifiche considerate ``banali'' o ``ovvie'' possono essere inviate direttamente al ramo @code{master}. Questo include modifiche per correggere refusi e revert di commit che hanno causato problemi immediati. Questo è soggetto a modifiche, consentendo agli individui di effettuare commit direttamente su modifiche non controverse in parti con cui hanno familiarità."

msgid "Changes which affect more than 300 dependent packages (@pxref{Invoking guix refresh}) should first be pushed to a topic branch other than @code{master}; the set of changes should be consistent---e.g., ``GNOME update'', ``NumPy update'', etc.  This allows for testing: the branch will automatically show up at @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}}, with an indication of its build status on various platforms."
msgstr "Le modifiche che interessano più di 300 pacchetti dipendenti (@pxref{Invoking guix refresh}) dovrebbero prima essere inviate a un ramo tematico diverso da @code{master}; l'insieme delle modifiche dovrebbe essere coerente---ad esempio, ``Aggiornamento GNOME'', ``Aggiornamento NumPy'', ecc. Ciò consente di testare: il ramo apparirà automaticamente su @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}}, con un'indicazione del suo stato di build su varie piattaforme."

msgid "feature branches, coordination"
msgstr "rami di funzionalità, coordinamento"

msgid "To help coordinate the merging of branches, you must create a new guix-patches issue each time you create a branch (@pxref{The Issue Tracker}).  The title of the issue requesting to merge a branch should have the following format:"
msgstr "Per aiutare a coordinare la fusione dei rami, devi creare un nuovo issue guix-patches ogni volta che crei un ramo (@pxref{The Issue Tracker}). Il titolo dell'issue che richiede di unire un ramo dovrebbe avere il seguente formato:"

msgid "merge requests, template"
msgstr "richieste di merge, modello"

msgid "Request for merging \"@var{name}\" branch\n"
msgstr "Richiesta di unione del ramo \"@var{name}\"\n"

msgid "The @url{https://qa.guix.gnu.org/, QA infrastructure} recognizes such issues and lists the merge requests on its main page.  The following points apply to managing these branches:"
msgstr "L'infrastruttura QA @url{https://qa.guix.gnu.org/} riconosce tali issue ed elenca le richieste di merge nella sua pagina principale. I seguenti punti si applicano alla gestione di questi rami:"

msgid "The commits on the branch should be a combination of the patches relevant to the branch.  Patches not related to the topic of the branch should go elsewhere."
msgstr "I commit sul ramo dovrebbero essere una combinazione delle patch rilevanti per il ramo. Le patch non correlate all'argomento del ramo dovrebbero andare altrove."

msgid "Any changes that can be made on the master branch, should be made on the master branch.  If a commit can be split to apply part of the changes on master, this is good to do."
msgstr "Qualsiasi modifica che può essere fatta sul ramo master, dovrebbe essere fatta sul ramo master. Se un commit può essere suddiviso per applicare parte delle modifiche su master, è bene farlo."

msgid "It should be possible to re-create the branch by starting from master and applying the relevant patches."
msgstr "Dovrebbe essere possibile ricreare il ramo partendo da master e applicando le patch rilevanti."

msgid "Avoid merging master in to the branch.  Prefer rebasing or re-creating the branch on top of an updated master revision."
msgstr "Evita di unire master nel ramo. Preferisci il rebasing o la ricreazione del ramo sopra una revisione master aggiornata."

msgid "Minimise the changes on master that are missing on the branch prior to merging the branch in to master.  This means that the state of the branch better reflects the state of master should the branch be merged."
msgstr "Minimizza le modifiche su master che mancano sul ramo prima di unire il ramo in master. Ciò significa che lo stato del ramo riflette meglio lo stato di master nel caso in cui il ramo venga unito."

msgid "If you don't have commit access, create the ``Request for merging'' issue and request that someone creates the branch.  Include a list of issues/patches to include on the branch."
msgstr "Se non hai accesso in commit, crea l'issue ``Richiesta di unione'' e richiedi che qualcuno crei il ramo. Includi un elenco di issue/patch da includere nel ramo."

msgid "Normally branches will be merged in a ``first come, first merged'' manner, tracked through the guix-patches issues.  If you agree on a different order with those involved, you can track this by updating which issues block@footnote{You can mark an issue as blocked by another by emailing @email{control@@debbugs.gnu.org} with the following line in the body of the email: @code{block XXXXX by YYYYY}.  Where @code{XXXXX} is the number for the blocked issue, and @code{YYYYY} is the number for the issue blocking it.} which other issues.  Therefore, to know which branch is at the front of the queue, look for the oldest issue, or the issue that isn't @dfn{blocked} by any other branch merges.  An ordered list of branches with the open issues is available at @url{https://qa.guix.gnu.org}."
msgstr "Normalmente i rami vengono uniti in modo ``primo arrivato, primo unito'', tracciato attraverso gli issue guix-patches. Se concordi un ordine diverso con i coinvolti, puoi tracciarlo aggiornando quali issue bloccano@footnote{Puoi contrassegnare un issue come bloccato da un altro inviando un'email a @email{control@@debbugs.gnu.org} con la seguente riga nel corpo dell'email: @code{block XXXXX by YYYYY}. Dove @code{XXXXX} è il numero dell'issue bloccato e @code{YYYYY} è il numero dell'issue che lo blocca.} quali altri issue. Pertanto, per sapere quale ramo è in testa alla coda, cerca l'issue più vecchio o l'issue che non è @dfn{bloccato} da nessun altro merge di ramo. Un elenco ordinato dei rami con gli issue aperti è disponibile su @url{https://qa.guix.gnu.org}."

msgid "Once a branch is at the front of the queue, wait until sufficient time has passed for the build farms to have processed the changes, and for the necessary testing to have happened.  For example, you can check @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}} to see information on some builds and substitute availability."
msgstr "Una volta che un ramo è in testa alla coda, attendi che sia passato tempo sufficiente affinché le build farm elaborino le modifiche e siano stati effettuati i test necessari. Ad esempio, puoi controllare @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}} per vedere informazioni su alcune build e sulla disponibilità di sostituti."

msgid "Once the branch has been merged, the issue should be closed and the branch deleted."
msgstr "Una volta che il ramo è stato unito, l'issue dovrebbe essere chiuso e il ramo eliminato."

msgid "work-in-progress branches, wip"
msgstr "rami work-in-progress, wip"

msgid "wip branches"
msgstr "rami wip"

msgid "Sometimes, a branch may be a work in progress, for example for larger efforts such as updating the GNOME desktop.  In these cases, the branch name should reflect this by having the @samp{wip-} prefix.  The QA infrastructure will avoid building work-in-progress branches, so that the available resources can be better focused on building the branches that are ready to be merged.  When the branch is no longer a work in progress, it should be renamed, with the @samp{wip-} prefix removed, and only then should the merge requests be created, as documented earlier."
msgstr "A volte, un ramo potrebbe essere un lavoro in corso, ad esempio per sforzi maggiori come l'aggiornamento del desktop GNOME. In questi casi, il nome del ramo dovrebbe rifletterlo con il prefisso @samp{wip-}. L'infrastruttura QA eviterà di costruire rami work-in-progress, in modo che le risorse disponibili possano essere meglio concentrate sulla costruzione dei rami pronti per essere uniti. Quando il ramo non è più un lavoro in corso, dovrebbe essere rinominato, rimuovendo il prefisso @samp{wip-}, e solo allora dovrebbero essere create le richieste di merge, come documentato in precedenza."

msgid "Warning"
msgstr "Avviso"

msgid "Web interface"
msgstr "Interfaccia web"

msgid "mumi, web interface for issues"
msgstr "mumi, interfaccia web per gli issue"

msgid "A web interface (actually @emph{two} web interfaces!) are available to browse issues:"
msgstr "Un'interfaccia web (in realtà @emph{due} interfacce web!) è disponibile per sfogliare gli issue:"

msgid "@url{https://issues.guix.gnu.org} provides a pleasant interface powered by mumi@footnote{Mumi is a nice piece of software written in Guile, and you can help! See @url{https://codeberg.org/guix/mumi}.} to browse bug reports and patches, and to participate in discussions; mumi also has a command-line interface as we will see below;"
msgstr "@url{https://issues.guix.gnu.org} fornisce un'interfaccia piacevole alimentata da mumi@footnote{Mumi è un bel software scritto in Guile, e puoi aiutare! Vedi @url{https://codeberg.org/guix/mumi}.} per sfogliare report di bug e patch e partecipare alle discussioni; mumi ha anche un'interfaccia a riga di comando come vedremo sotto;"

msgid "@url{https://bugs.gnu.org/guix} lists bug reports;"
msgstr "@url{https://bugs.gnu.org/guix} elenca i report di bug;"

msgid "@url{https://bugs.gnu.org/guix-patches} lists patch submissions."
msgstr "@url{https://bugs.gnu.org/guix-patches} elenca le sottomissioni di patch."

msgid "To view discussions related to issue number @var{n}, go to @indicateurl{https://issues.guix.gnu.org/@var{n}} or @indicateurl{https://bugs.gnu.org/@var{n}}."
msgstr "Per visualizzare le discussioni relative all'issue numero @var{n}, vai su @indicateurl{https://issues.guix.gnu.org/@var{n}} o @indicateurl{https://bugs.gnu.org/@var{n}}."

msgid "Command-Line Interface"
msgstr "Interfaccia a Righe di Comando"

msgid "mumi command-line interface"
msgstr "interfaccia a riga di comando di mumi"

msgid "mumi am"
msgstr "mumi am"

msgid "mumi compose"
msgstr "mumi compose"

msgid "mumi send-email"
msgstr "mumi send-email"

msgid "mumi www"
msgstr "mumi www"

msgid "Mumi also comes with a command-line interface that can be used to search existing issues, open new issues, compose replies, apply and send patches.  You do not need to use Emacs to use the mumi command-line client.  You interact with it only on the command-line."
msgstr "Mumi include anche un'interfaccia a riga di comando che può essere usata per cercare issue esistenti, aprire nuovi issue, comporre risposte, applicare e inviare patch. Non è necessario usare Emacs per usare il client a riga di comando di mumi. Interagisci con esso solo dalla riga di comando."

msgid "To use the mumi command-line interface, navigate to a local clone of the Guix git repository, and drop into a shell with mumi, git and git:send-email installed."
msgstr "Per usare l'interfaccia a riga di comando di mumi, naviga in una copia locale del repository git di Guix ed entra in una shell con mumi, git e git:send-email installati."

msgid ""
"$ cd guix\n"
"~/guix$ guix shell mumi git git:send-email\n"
msgstr ""
"$ cd guix\n"
"~/guix$ guix shell mumi git git:send-email\n"

msgid "To search for issues, say all open issues about \"zig\", run"
msgstr "Per cercare issue, ad esempio tutti gli issue aperti su \"zig\", esegui"

msgid ""
"~/guix [env]$ mumi search zig is:open\n"
"\n"
msgstr ""
"~/guix [env]$ mumi search zig is:open\n"
"\n"

msgid ""
"#60889 Add zig-build-system\n"
"opened on 17 Jan 17:37 Z by Ekaitz Zarraga\n"
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"
"#39136 [PATCH] gnu: services: Add endlessh.\n"
"opened on 14 Jan 2020 21:21 by Nicol? Balzarotti\n"
"#60424 [PATCH] gnu: Add python-online-judge-tools\n"
"opened on 30 Dec 2022 07:03 by gemmaro\n"
"#45601 [PATCH 0/6] vlang 0.2 update\n"
"opened on  1 Jan 2021 19:23 by Ryan Prior\n"
msgstr ""
"#60889 Add zig-build-system\n"
"opened on 17 Jan 17:37 Z by Ekaitz Zarraga\n"
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"
"#39136 [PATCH] gnu: services: Add endlessh.\n"
"opened on 14 Jan 2020 21:21 by Nicol? Balzarotti\n"
"#60424 [PATCH] gnu: Add python-online-judge-tools\n"
"opened on 30 Dec 2022 07:03 by gemmaro\n"
"#45601 [PATCH 0/6] vlang 0.2 update\n"
"opened on  1 Jan 2021 19:23 by Ryan Prior\n"

msgid "Pick an issue and make it the \"current\" issue."
msgstr "Scegli un issue e rendilo l'issue \"corrente\"."

msgid ""
"~/guix [env]$ mumi current 61036\n"
"\n"
msgstr ""
"~/guix [env]$ mumi current 61036\n"
"\n"

msgid ""
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"
msgstr ""
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"

msgid "Once an issue is the current issue, you can open the issue in a web browser, compose replies, apply patches, send patches, etc. with short succinct commands."
msgstr "Una volta che un issue è l'issue corrente, puoi aprirlo in un browser web, comporre risposte, applicare patch, inviare patch, ecc. con comandi brevi e succinti."

msgid "Open the issue in your web browser using"
msgstr "Apri l'issue nel tuo browser web usando"

msgid "~/guix [env]$ mumi www\n"
msgstr "~/guix [env]$ mumi www\n"

msgid "Compose a reply using"
msgstr "Componi una risposta usando"

msgid "~/guix [env]$ mumi compose\n"
msgstr "~/guix [env]$ mumi compose\n"

msgid "Compose a reply and close the issue using"
msgstr "Componi una risposta e chiudi l'issue usando"

msgid "~/guix [env]$ mumi compose --close\n"
msgstr "~/guix [env]$ mumi compose --close\n"

msgid "@command{mumi compose} opens your mail client by passing @samp{mailto:} URIs to @command{xdg-open}.  So, you need to have @command{xdg-open} set up to open your mail client correctly."
msgstr "@command{mumi compose} apre il tuo client di posta passando URI @samp{mailto:} a @command{xdg-open}. Quindi, devi avere @command{xdg-open} configurato per aprire correttamente il tuo client di posta."

msgid "Apply the latest patchset from the issue using"
msgstr "Applica l'ultimo set di patch dall'issue usando"

msgid "~/guix [env]$ mumi am\n"
msgstr "~/guix [env]$ mumi am\n"

msgid "You may also apply a patchset of a specific version (say, v3) using"
msgstr "Puoi anche applicare un set di patch di una versione specifica (ad esempio, v3) usando"

msgid "~/guix [env]$ mumi am v3\n"
msgstr "~/guix [env]$ mumi am v3\n"

msgid "Or, you may apply a patch from a specific e-mail message.  For example, to apply the patch from the 4th message (message index starts from 0), run"
msgstr "Oppure, puoi applicare una patch da un messaggio email specifico. Ad esempio, per applicare la patch dal 4° messaggio (l'indice del messaggio inizia da 0), esegui"

msgid "~/guix [env]$ mumi am @@4\n"
msgstr "~/guix [env]$ mumi am @@4\n"

msgid "@command{mumi am} is a wrapper around @command{git am}.  You can pass @command{git am} arguments to it after a @samp{--}.  For example, to add a Signed-off-by trailer, run"
msgstr "@command{mumi am} è un wrapper attorno a @command{git am}. Puoi passare argomenti di @command{git am} dopo un @samp{--}. Ad esempio, per aggiungere un trailer Signed-off-by, esegui"

msgid "~/guix [env]$ mumi am -- -s\n"
msgstr "~/guix [env]$ mumi am -- -s\n"

msgid "Create and send patches to the issue using"
msgstr "Crea e invia patch all'issue usando"

msgid ""
"~/guix [env]$ git format-patch origin/master\n"
"~/guix [env]$ mumi send-email foo.patch bar.patch\n"
msgstr ""
"~/guix [env]$ git format-patch origin/master\n"
"~/guix [env]$ mumi send-email foo.patch bar.patch\n"

msgid "Note that you do not have to pass in @samp{--to} or @samp{--cc} arguments to @command{git format-patch}.  @command{mumi send-email} will put them in correctly when sending the patches."
msgstr "Nota che non devi passare argomenti @samp{--to} o @samp{--cc} a @command{git format-patch}. @command{mumi send-email} li inserirà correttamente quando invia le patch."

msgid "To open a new issue, run"
msgstr "Per aprire un nuovo issue, esegui"

msgid "~/guix [env]$ mumi new\n"
msgstr "~/guix [env]$ mumi new\n"

msgid "and send an email (using @command{mumi compose}) or patches (using @command{mumi send-email})."
msgstr "e invia un'email (usando @command{mumi compose}) o patch (usando @command{mumi send-email})."

msgid "@command{mumi send-email} is really a wrapper around @command{git send-email} that automates away all the nitty-gritty of sending patches.  It uses the current issue state to automatically figure out the correct @samp{To} address to send to, other participants to @samp{Cc}, headers to add, etc."
msgstr "@command{mumi send-email} è in realtà un wrapper attorno a @command{git send-email} che automatizza tutti i dettagli tecnici dell'invio di patch. Usa lo stato corrente dell'issue per capire automaticamente il corretto indirizzo @samp{To} a cui inviare, altri partecipanti a @samp{Cc}, intestazioni da aggiungere, ecc."

msgid "Also note that, unlike @command{git send-email}, @command{mumi send-email} works perfectly well with single and multiple patches alike.  It automates away the debbugs dance of sending the first patch, waiting for a response from debbugs and sending the remaining patches.  It does so by sending the first patch, polling the server for a response, and then sending the remaining patches.  This polling can unfortunately take a few minutes.  So, please be patient."
msgstr "Nota inoltre che, a differenza di @command{git send-email}, @command{mumi send-email} funziona perfettamente sia con patch singole che multiple. Automatizza la danza di debbugs di inviare la prima patch, attendere una risposta da debbugs e inviare le patch rimanenti. Lo fa inviando la prima patch, interrogando il server per una risposta e poi inviando le patch rimanenti. Sfortunatamente, questo polling può richiedere alcuni minuti. Quindi, per favore sii paziente."

msgid "Emacs Interface"
msgstr "Interfaccia Emacs"

msgid "If you use Emacs, you may find it more convenient to interact with issues using @file{debbugs.el}, which you can install with:"
msgstr "Se usi Emacs, potresti trovarlo più conveniente per interagire con gli issue usando @file{debbugs.el}, che puoi installare con:"

msgid "guix install emacs-debbugs\n"
msgstr "guix install emacs-debbugs\n"

msgid "For example, to list all open issues on @code{guix-patches}, hit:"
msgstr "Ad esempio, per elencare tutti gli issue aperti su @code{guix-patches}, premi:"

msgid "@kbd{C-u} @kbd{M-x} debbugs-gnu @kbd{RET} @kbd{RET} guix-patches @kbd{RET} n y\n"
msgstr "@kbd{C-u} @kbd{M-x} debbugs-gnu @kbd{RET} @kbd{RET} guix-patches @kbd{RET} n y\n"

msgid "To search for bugs, @samp{@kbd{M-x} debbugs-gnu-guix-search} can be used."
msgstr "Per cercare bug, può essere usato @samp{@kbd{M-x} debbugs-gnu-guix-search}."

msgid "@xref{Top,,, debbugs-ug, Debbugs User Guide}, for more information on this nifty tool!"
msgstr "@xref{Top,,, debbugs-ug, Debbugs User Guide}, per maggiori informazioni su questo utile strumento!"

msgid "build event notifications, RSS feed"
msgstr "notifiche di eventi di build, feed RSS"

msgid "notifications, build events"
msgstr "notifiche, eventi di build"

msgid "Cuirass includes @acronym{RSS, Really Simple Syndication} feeds as one of its features (@pxref{Notifications,,,cuirass}).  Since @url{https://ci.guix.gnu.org/, Berlin} runs an instance of Cuirass, this feature can be used to keep track of recently broken or fixed packages caused by changes pushed to the Guix git repository.  Any RSS client can be used.  A good one, included with Emacs, is @xref{Gnus,,,gnus}.  To register the feed, copy its URL, then from the main Gnus buffer, @samp{*Group*}, do the following:"
msgstr "Cuirass include feed @acronym{RSS, Really Simple Syndication} come una delle sue funzionalità (@pxref{Notifications,,,cuirass}). Poiché @url{https://ci.guix.gnu.org/, Berlin} esegue un'istanza di Cuirass, questa funzionalità può essere usata per tenere traccia dei pacchetti recentemente rotti o riparati causati da modifiche inviate al repository git di Guix. Qualsiasi client RSS può essere usato. Uno buono, incluso in Emacs, è @xref{Gnus,,,gnus}. Per registrare il feed, copia il suo URL, quindi dal buffer principale di Gnus, @samp{*Group*}, fai quanto segue:"

msgid "Gnus, configuration to read CI RSS feeds"
msgstr "Gnus, configurazione per leggere i feed RSS CI"

msgid ""
"@kbd{G R} https://ci.guix.gnu.org/events/rss/?specification=master RET\n"
"Guix CI - master RET Build events for specification master. RET\n"
msgstr ""
"@kbd{G R} https://ci.guix.gnu.org/events/rss/?specification=master INVIO\n"
"Guix CI - master INVIO Build events for specification master. INVIO\n"

msgid "Then, back at the @samp{*Group*} buffer, press @kbd{s} to save the newly added RSS group.  As for any other Gnus group, you can update its content by pressing the @kbd{g} key.  You should now receive notifications that read like:"
msgstr "Quindi, tornando al buffer @samp{*Group*}, premi @kbd{s} per salvare il gruppo RSS appena aggiunto. Come per qualsiasi altro gruppo Gnus, puoi aggiornare il suo contenuto premendo il tasto @kbd{g}. Dovresti ora ricevere notifiche che recitano così:"

msgid ""
" . [ ?: Cuirass ] Build tree-sitter-meson.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.x86_64-linux on master is fixed.\n"
msgstr ""
" . [ ?: Cuirass ] Build tree-sitter-meson.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.x86_64-linux on master is fixed.\n"

msgid "where each RSS entry contains a link to the Cuirass build details page of the associated build."
msgstr "dove ogni voce RSS contiene un collegamento alla pagina dei dettagli della build di Cuirass per la build associata."

msgid "teams"
msgstr "team"

msgid "To organize work on Guix, including but not just development efforts, the project has a set of @dfn{teams}.  Each team has its own focus and interests and is the primary contact point for questions and contributions in those areas.  A team's primary mission is to coordinate and review the work of individuals in its scope (@pxref{Reviewing the Work of Others}); it can make decisions within its scope, in agreement with other teams whenever there is overlap or a close connection, and in accordance with other project rules such as seeking consensus (@pxref{Making Decisions})."
msgstr "Per organizzare il lavoro su Guix, inclusi ma non solo gli sforzi di sviluppo, il progetto ha un insieme di @dfn{team}. Ogni team ha il proprio focus e interessi ed è il punto di contatto principale per domande e contributi in quelle aree. La missione principale di un team è coordinare e revisionare il lavoro degli individui nel suo ambito (@pxref{Reviewing the Work of Others}); può prendere decisioni nel suo ambito, in accordo con altri team ogni volta che c'è sovrapposizione o una stretta connessione, e in conformità con altre regole del progetto come la ricerca del consenso (@pxref{Making Decisions})."

msgid "As an example, the Python team is responsible for core Python packaging matters; it can decide to upgrade core Python packages in a dedicated @code{python-team} branch, in collaboration with any team whose scope is directly dependent on Python---e.g., the Science team---and following branching rules (@pxref{Managing Patches and Branches}).  The Documentation team helps review changes to the documentation and can initiate overarching documentation changes.  The Translations team organizes translation of Guix and its manual and coordinates efforts in that area.  The Core team is responsible for the development of core functionality and interfaces of Guix; because of its central nature, some of its work may require soliciting input from the community at large and seeking consensus before enacting decisions that would affect the entire community."
msgstr "Ad esempio, il team Python è responsabile delle questioni fondamentali di packaging Python; può decidere di aggiornare i pacchetti Python di base in un ramo dedicato @code{python-team}, in collaborazione con qualsiasi team il cui ambito dipende direttamente da Python---ad esempio, il team Scientifico---e seguendo le regole di branching (@pxref{Managing Patches and Branches}). Il team Documentazione aiuta a revisionare le modifiche alla documentazione e può avviare modifiche documentali generali. Il team Traduzioni organizza la traduzione di Guix e del suo manuale e coordina gli sforzi in quell'area. Il team Core è responsabile dello sviluppo delle funzionalità fondamentali e delle interfacce di Guix; a causa della sua natura centrale, parte del suo lavoro potrebbe richiedere la richiesta di input dalla comunità in generale e la ricerca del consenso prima di emanare decisioni che influenzerebbero l'intera comunità."

msgid "Teams are defined in the @file{etc/teams.scm} file in the Guix repository.  The scope of each team is defined, when applicable, as a set of files or as a regular expression matching file names."
msgstr "I team sono definiti nel file @file{etc/teams.scm} nel repository di Guix. L'ambito di ogni team è definito, quando applicabile, come un insieme di file o come un'espressione regolare che corrisponde ai nomi dei file."

msgid "team membership"
msgstr "appartenenza al team"

msgid "Anyone with interest in a team's domain and willing to contribute to its work can apply to become a member by contacting current members by email; commit access is not a precondition.  Membership is formalized by adding the person's name and email address to @file{etc/teams.scm}.  Members who have not been participating in the team's work for one year or more may be removed; they are free to reapply for membership later."
msgstr "Chiunque sia interessato al dominio di un team e disposto a contribuire al suo lavoro può candidarsi per diventare membro contattando i membri attuali via email; l'accesso in commit non è un prerequisito. L'appartenenza è formalizzata aggiungendo il nome e l'indirizzo email della persona a @file{etc/teams.scm}. I membri che non hanno partecipato al lavoro del team per un anno o più possono essere rimossi; sono liberi di ricandidarsi per l'appartenenza in seguito."

msgid "One or more people may propose the creation of a new team by reaching out to the community by email at @email{guix-devel@@gnu.org}, clarifying the intended scope and purpose.  When consensus is reached on the creation of this team, someone with commit access formalizes its creation by adding it and its initial members to @file{etc/teams.scm}."
msgstr "Una o più persone possono proporre la creazione di un nuovo team contattando la comunità via email a @email{guix-devel@@gnu.org}, chiarendo l'ambito e lo scopo previsti. Quando si raggiunge il consenso sulla creazione di questo team, qualcuno con accesso in commit formalizza la sua creazione aggiungendo esso e i suoi membri iniziali a @file{etc/teams.scm}."

msgid "To list existing teams, run the following command from a Guix checkout:"
msgstr "Per elencare i team esistenti, esegui il seguente comando da un checkout di Guix:"

msgid ""
"$ ./etc/teams.scm list-teams\n"
"id: mentors\n"
"name: Mentors\n"
"description: A group of mentors who chaperone contributions by newcomers.\n"
"members:\n"
"+ Charlie Smith <charlie@@example.org>\n"
"@dots{}\n"
msgstr ""
"$ ./etc/teams.scm list-teams\n"
"id: mentors\n"
"name: Mentors\n"
"description: Un gruppo di mentori che accompagnano i contributi dei nuovi arrivati.\n"
"members:\n"
"+ Charlie Smith <charlie@@example.org>\n"
"@dots{}\n"

msgid "mentoring"
msgstr "mentoring"

msgid "You can run the following command to have the Mentors team put in CC of a patch series:"
msgstr "Puoi eseguire il seguente comando per includere il team Mentori in CC di una serie di patch:"

msgid ""
"$ git send-email --to=@var{ISSUE_NUMBER}@@debbugs.gnu.org \\\n"
"  --header-cmd='etc/teams.scm cc-mentors-header-cmd' *.patch\n"
msgstr ""
"$ git send-email --to=@var{ISSUE_NUMBER}@@debbugs.gnu.org \\\n"
"  --header-cmd='etc/teams.scm cc-mentors-header-cmd' *.patch\n"

msgid "The appropriate team or teams can also be inferred from the modified files.  For instance, if you want to send the two latest commits of the current Git repository to review, you can run:"
msgstr "Il team o i team appropriati possono anche essere dedotti dai file modificati. Ad esempio, se vuoi inviare gli ultimi due commit del repository Git corrente per la revisione, puoi eseguire:"

msgid ""
"$ guix shell -D guix\n"
"[env]$ git send-email --to=@var{ISSUE_NUMBER}@@debbugs.gnu.org -2\n"
msgstr ""
"$ guix shell -D guix\n"
"[env]$ git send-email --to=@var{ISSUE_NUMBER}@@debbugs.gnu.org -2\n"

msgid "teams, on Codeberg"
msgstr "team, su Codeberg"

msgid "To generate a @file{CODEOWNERS} file, which Forgejo---the software behind Codeberg---uses to determine which team or person should review changes to a given set of files, run:"
msgstr "Per generare un file @file{CODEOWNERS}, che Forgejo - il software dietro Codeberg - utilizza per determinare quale team o persona dovrebbe revisionare le modifiche a un determinato insieme di file, esegui:"

msgid "./etc/teams.scm codeowners > CODEOWNERS\n"
msgstr "./etc/teams.scm codeowners > CODEOWNERS\n"

msgid "Teams defined in @file{etc/teams.scm} are reflected @uref{https://codeberg.org/guix/guix, on Codeberg}; the ``Owners'' team on Codeberg, whose members have administration privileges over @uref{https://codeberg.org/guix, the entire ``organization''}, is the only one missing from this file.  To synchronize team changes with Codeberg, a member of the ``Owners'' team can run:"
msgstr "I team definiti in @file{etc/teams.scm} sono riflessi su @uref{https://codeberg.org/guix/guix, Codeberg}; il team ``Owners'' su Codeberg, i cui membri hanno privilegi di amministrazione sull'intera ``organizzazione'' (@uref{https://codeberg.org/guix, intera 'organizzazione'}), è l'unico mancante da questo file. Per sincronizzare le modifiche dei team con Codeberg, un membro del team ``Owners'' può eseguire:"

msgid "./etc/teams.scm sync-codeberg-teams @var{token}\n"
msgstr "./etc/teams.scm sync-codeberg-teams @var{token}\n"

msgid "decision making"
msgstr "presa di decisioni"

msgid "consensus seeking"
msgstr "ricerca del consenso"

msgid "It is expected from all contributors, and even more so from committers, to help build consensus and make decisions based on consensus.  By using consensus, we are committed to finding solutions that everyone can live with.  It implies that no decision is made against significant concerns and these concerns are actively resolved with proposals that work for everyone."
msgstr "È previsto da tutti i contributori, e ancor più dai committer, aiutare a costruire il consenso e prendere decisioni basate sul consenso. Usando il consenso, ci impegniamo a trovare soluzioni con cui tutti possano convivere. Ciò implica che nessuna decisione è presa contro preoccupazioni significative e queste preoccupazioni sono attivamente risolte con proposte che funzionano per tutti."

msgid "A contributor (who may or may not have commit access) wishing to block a proposal bears a special responsibility for finding alternatives, proposing ideas/code or explain the rationale for the status quo to resolve the deadlock.  To learn what consensus decision making means and understand its finer details, you are encouraged to read @url{https://www.seedsforchange.org.uk/consensus}."
msgstr "Un contributore (che potrebbe o meno avere accesso in commit) che desidera bloccare una proposta ha una responsabilità speciale nel trovare alternative, proporre idee/codice o spiegare la logica dello status quo per risolvere l'impasse. Per imparare cosa significa la presa di decisioni per consenso e capirne i dettagli più fini, ti incoraggiamo a leggere @url{https://www.seedsforchange.org.uk/consensus}."

msgid "commit access, for developers"
msgstr "accesso in commit, per sviluppatori"

msgid "Everyone can contribute to Guix without having commit access (@pxref{Submitting Patches}).  However, for frequent contributors, having write access to the repository can be convenient.  As a rule of thumb, a contributor should have accumulated fifty (50) reviewed commits to be considered as a committer and have sustained their activity in the project for at least 6 months.  This ensures enough interactions with the contributor, which is essential for mentoring and assessing whether they are ready to become a committer.  Commit access should not be thought of as a ``badge of honor'' but rather as a responsibility a contributor is willing to take to help the project."
msgstr "Chiunque può contribuire a Guix senza avere accesso in commit (@pxref{Submitting Patches}). Tuttavia, per i contributori frequenti, avere accesso in scrittura al repository può essere conveniente. Come regola generale, un contributore dovrebbe aver accumulato cinquanta (50) commit revisionati per essere considerato un committer e aver mantenuto la sua attività nel progetto per almeno 6 mesi. Ciò garantisce abbastanza interazioni con il contributore, che è essenziale per il mentoring e la valutazione se è pronto a diventare un committer. L'accesso in commit non dovrebbe essere pensato come un ``distintivo d'onore'' ma piuttosto come una responsabilità che un contributore è disposto ad assumersi per aiutare il progetto."

msgid "Committers are in a position where they enact technical decisions.  Such decisions must be made by @emph{actively building consensus} among interested parties and stakeholders.  @xref{Making Decisions}, for more on that."
msgstr "I committer sono in una posizione in cui emanano decisioni tecniche. Tali decisioni devono essere prese @emph{costruendo attivamente il consenso} tra le parti interessate e gli stakeholder. @xref{Making Decisions}, per maggiori informazioni su questo."

msgid "The following sections explain how to get commit access, how to be ready to push commits, and the policies and community expectations for commits pushed upstream."
msgstr "Le sezioni seguenti spiegano come ottenere l'accesso in commit, come essere pronti a inviare commit e le politiche e le aspettative della comunità per i commit inviati upstream."

msgid "Applying for Commit Access"
msgstr "Richiesta di Accesso in Commit"

msgid "When you deem it necessary, consider applying for commit access by following these steps:"
msgstr "Quando lo ritieni necessario, considera di richiedere l'accesso in commit seguendo questi passaggi:"

msgid "Find three committers who would vouch for you.  Each of them should email a statement to @email{guix-maintainers@@gnu.org} (a private alias for the collective of maintainers), signed with their OpenPGP key."
msgstr "Trova tre committer che possano garantire per te. Ciascuno di loro dovrebbe inviare una dichiarazione a @email{guix-maintainers@@gnu.org} (un alias privato per il collettivo dei maintainer), firmata con la loro chiave OpenPGP."

msgid "Committers are expected to have had some interactions with you as a contributor and to be able to judge whether you are sufficiently familiar with the project's practices.  It is @emph{not} a judgment on the value of your work, so a refusal should rather be interpreted as ``let's try again later''."
msgstr "Si prevede che i committer abbiano avuto alcune interazioni con te come contributore e siano in grado di giudicare se sei sufficientemente familiare con le pratiche del progetto. Non è un giudizio sul valore del tuo lavoro, quindi un rifiuto dovrebbe piuttosto essere interpretato come ``riproviamo più tardi''."

msgid "Send @email{guix-maintainers@@gnu.org} a message stating your intent, listing the three committers who support your application, signed with the OpenPGP key you will use to sign commits, and giving its fingerprint (see below).  See @uref{https://emailselfdefense.fsf.org/en/}, for an introduction to public-key cryptography with GnuPG."
msgstr "Invia a @email{guix-maintainers@@gnu.org} un messaggio che dichiara la tua intenzione, elencando i tre committer che supportano la tua candidatura, firmato con la chiave OpenPGP che userai per firmare i commit e fornendo la sua impronta digitale (vedi sotto). Vedi @uref{https://emailselfdefense.fsf.org/en/}, per un'introduzione alla crittografia a chiave pubblica con GnuPG."

msgid "Set up GnuPG such that it never uses the SHA1 hash algorithm for digital signatures, which is known to be unsafe since 2019, for instance by adding the following line to @file{~/.gnupg/gpg.conf} (@pxref{GPG Esoteric Options,,, gnupg, The GNU Privacy Guard Manual}):"
msgstr "Configura GnuPG in modo che non usi mai l'algoritmo di hash SHA1 per le firme digitali, che è noto per essere insicuro dal 2019, ad esempio aggiungendo la seguente riga a @file{~/.gnupg/gpg.conf} (@pxref{GPG Esoteric Options,,, gnupg, The GNU Privacy Guard Manual}):"

msgid "digest-algo sha512\n"
msgstr "digest-algo sha512\n"

msgid "Maintainers ultimately decide whether to grant you commit access, usually following your referrals' recommendation."
msgstr "I maintainer decidono in ultima istanza se concederti l'accesso in commit, di solito seguendo la raccomandazione dei tuoi referenti."

msgid "OpenPGP, signed commits"
msgstr "OpenPGP, commit firmati"

msgid "If and once you've been given access, please send a message to @email{guix-devel@@gnu.org} to say so, again signed with the OpenPGP key you will use to sign commits (do that before pushing your first commit).  That way, everyone can notice and ensure you control that OpenPGP key."
msgstr "Se e una volta che ti è stato concesso l'accesso, invia un messaggio a @email{guix-devel@@gnu.org} per dirlo, di nuovo firmato con la chiave OpenPGP che userai per firmare i commit (fallo prima di inviare il tuo primo commit). In questo modo, tutti possono notare e assicurarsi che tu controlli quella chiave OpenPGP."

msgid "Important"
msgstr "Importante"

msgid "Before you can push for the first time, maintainers must:"
msgstr "Prima che tu possa inviare per la prima volta, i maintainer devono:"

msgid "add your OpenPGP key to the @code{keyring} branch;"
msgstr "aggiungere la tua chiave OpenPGP al ramo @code{keyring};"

msgid "add your OpenPGP fingerprint to the @file{.guix-authorizations} file of the branch(es) you will commit to."
msgstr "aggiungere la tua impronta digitale OpenPGP al file @file{.guix-authorizations} del/dei ramo/i in cui effettuerai commit."

msgid "Make sure to read the rest of this section and... profit!"
msgstr "Assicurati di leggere il resto di questa sezione e... buon profitto!"

msgid "Maintainers are happy to give commit access to people who have been contributing for some time and have a track record---don't be shy and don't underestimate your work!"
msgstr "I maintainer sono felici di dare accesso in commit a persone che hanno contribuito per un po' di tempo e hanno un track record---non essere timido e non sottovalutare il tuo lavoro!"

msgid "However, note that the project is working towards a more automated patch review and merging system, which, as a consequence, may lead us to have fewer people with commit access to the main repository.  Stay tuned!"
msgstr "Tuttavia, nota che il progetto sta lavorando verso un sistema più automatizzato di revisione e unione delle patch, che, di conseguenza, potrebbe portarci ad avere meno persone con accesso in commit al repository principale. Rimani sintonizzato!"

msgid "All commits that are pushed to the central repository on Codeberg must be signed with an OpenPGP key, and the public key should be uploaded to your user account on Codeberg and to public key servers, such as @code{keys.openpgp.org}.  To configure Git to automatically sign commits, run:"
msgstr "Tutti i commit inviati al repository centrale su Codeberg devono essere firmati con una chiave OpenPGP e la chiave pubblica dovrebbe essere caricata sul tuo account utente su Codeberg e su server di chiavi pubblici, come @code{keys.openpgp.org}. Per configurare Git per firmare automaticamente i commit, esegui:"

msgid ""
"git config commit.gpgsign true\n"
"\n"
msgstr ""
"git config commit.gpgsign true\n"
"\n"

msgid ""
"# Substitute the fingerprint of your public PGP key.\n"
"git config user.signingkey CABBA6EA1DC0FF33\n"
msgstr ""
"# Sostituisci l'impronta digitale della tua chiave PGP pubblica.\n"
"git config user.signingkey CABBA6EA1DC0FF33\n"

msgid "To check that commits are signed with correct key, use:"
msgstr "Per verificare che i commit siano firmati con la chiave corretta, usa:"

msgid "@xref{Building from Git} for running the first authentication of a Guix checkout."
msgstr "@xref{Building from Git} per eseguire la prima autenticazione di un checkout di Guix."

msgid "To avoid accidentally pushing unsigned or signed with the wrong key commits to Codeberg, make sure to configure Git according to @xref{Configuring Git}."
msgstr "Per evitare di inviare accidentalmente commit non firmati o firmati con la chiave sbagliata a Codeberg, assicurati di configurare Git secondo @xref{Configuring Git}."

msgid "Commit Policy"
msgstr "Politica dei Commit"

msgid "If you get commit access, please make sure to follow the policy below (discussions of the policy can take place on @email{guix-devel@@gnu.org})."
msgstr "Se ottieni l'accesso in commit, assicurati di seguire la politica seguente (le discussioni sulla politica possono aver luogo su @email{guix-devel@@gnu.org})."

msgid "Ensure you're aware of how the changes should be handled (@pxref{Managing Patches and Branches}) prior to being pushed to the repository, especially for the @code{master} branch."
msgstr "Assicurati di essere consapevole di come le modifiche dovrebbero essere gestite (@pxref{Managing Patches and Branches}) prima di essere inviate al repository, specialmente per il ramo @code{master}."

msgid "If you're committing and pushing your own changes, try and wait at least one week (two weeks for more significant changes, up to one month for changes such as removing a package---@pxref{package-removal-policy, Package Removal}) after you send them for review.  After this, if no one else is available to review them and if you're confident about the changes, it's OK to commit."
msgstr "Se stai effettuando commit e inviando le tue modifiche, cerca di attendere almeno una settimana (due settimane per modifiche più significative, fino a un mese per modifiche come la rimozione di un pacchetto---@pxref{package-removal-policy, Rimozione de pacchetti}) dopo averle inviate per la revisione. Dopo ciò, se nessun altro è disponibile per revisionarle e sei sicuro delle modifiche, va bene effettuare il commit."

msgid "When pushing a commit on behalf of somebody else, please add a @code{Signed-off-by} line at the end of the commit log message---e.g., with @command{git am --signoff}.  This improves tracking of who did what."
msgstr "Quando invii un commit per conto di qualcun altro, aggiungi una linea @code{Signed-off-by} alla fine del messaggio di log del commit---ad esempio, con @command{git am --signoff}. Ciò migliora il tracciamento di chi ha fatto cosa."

msgid "When adding channel news entries (@pxref{Channels, Writing Channel News}), make sure they are well-formed by running the following command right before pushing:"
msgstr "Quando aggiungi voci di notizie dei canali (@pxref{Channels, Writing Channel News}), assicurati che siano ben formate eseguendo il seguente comando appena prima di inviare:"

msgid "make check-channel-news\n"
msgstr "make check-channel-news\n"

msgid "Addressing Issues"
msgstr "Affrontare i Problemi"

msgid "Peer review (@pxref{Submitting Patches}) and tools such as @command{guix lint} (@pxref{Invoking guix lint}) and the test suite (@pxref{Running the Test Suite}) should catch issues before they are pushed.  Yet, commits that ``break'' functionality might occasionally go through.  When that happens, there are two priorities: mitigating the impact, and understanding what happened to reduce the chance of similar incidents in the future.  The responsibility for both these things primarily lies with those involved, but like everything this is a group effort."
msgstr "La revisione tra pari (@pxref{Submitting Patches}) e strumenti come @command{guix lint} (@pxref{Invoking guix lint}) e la suite di test (@pxref{Running the Test Suite}) dovrebbero rilevare i problemi prima che siano inviati. Tuttavia, commit che ``rompono'' funzionalità potrebbero occasionalmente passare. Quando ciò accade, ci sono due priorità: mitigare l'impatto e capire cosa è successo per ridurre la possibilità di incidenti simili in futuro. La responsabilità per entrambe queste cose ricade principalmente su quelli coinvolti, ma come tutto questo è uno sforzo di gruppo."

msgid "Some issues can directly affect all users---for instance because they make @command{guix pull} fail or break core functionality, because they break major packages (at build time or run time), or because they introduce known security vulnerabilities."
msgstr "Alcuni problemi possono influenzare direttamente tutti gli utenti---ad esempio perché fanno fallire @command{guix pull} o rompono funzionalità fondamentali, perché rompono pacchetti principali (al momento della build o dell'esecuzione), o perché introducono vulnerabilità di sicurezza note."

msgid "reverting commits"
msgstr "revert dei commit"

msgid "The people involved in authoring, reviewing, and pushing such commit(s) should be at the forefront to mitigate their impact in a timely fashion: by pushing a followup commit to fix it (if possible), or by reverting it to leave time to come up with a proper fix, and by communicating with other developers about the problem."
msgstr "Le persone coinvolte nella creazione, revisione e invio di tali commit dovrebbero essere in prima linea per mitigare il loro impatto in modo tempestivo: inviando un commit di followup per risolverlo (se possibile), o revertendolo per lasciare tempo per trovare una soluzione corretta, e comunicando con altri sviluppatori sul problema."

msgid "If these persons are unavailable to address the issue in time, other committers are entitled to revert the commit(s), explaining in the commit log and on the mailing list what the problem was, with the goal of leaving time to the original committer, reviewer(s), and author(s)  to propose a way forward."
msgstr "Se queste persone non sono disponibili per affrontare il problema in tempo, altri committer hanno il diritto di revertare i commit, spiegando nel log del commit e nella mailing list qual era il problema, con l'obiettivo di lasciare tempo al committer originale, ai revisori e agli autori di proporre una via da seguire."

msgid "Once the problem has been dealt with, it is the responsibility of those involved to make sure the situation is understood.  If you are working to understand what happened, focus on gathering information and avoid assigning any blame.  Do ask those involved to describe what happened, do not ask them to explain the situation---this would implicitly blame them, which is unhelpful.  Accountability comes from a consensus about the problem, learning from it and improving processes so that it's less likely to reoccur."
msgstr "Una volta affrontato il problema, è responsabilità di quelli coinvolti assicurarsi che la situazione sia compresa. Se stai lavorando per capire cosa è successo, concentrati sulla raccolta di informazioni ed evita di assegnare colpe. Chiedi a quelli coinvolti di descrivere cosa è successo, non chiedere loro di spiegare la situazione---questo implicherebbe implicitamente incolparli, il che non è utile. La responsabilità deriva da un consenso sul problema, imparare da esso e migliorare i processi in modo che sia meno probabile che si ripeta."

msgid "Reverting commits"
msgstr "Revert dei commit"

msgid "Like normal commits, the commit message should state why the changes are being made, which in this case would be why the commits are being reverted."
msgstr "Come i commit normali, il messaggio di commit dovrebbe dichiarare perché le modifiche vengono apportate, che in questo caso sarebbe perché i commit vengono revertati."

msgid "If the changes are being reverted because they led to excessive number of packages being affected, then a decision should be made whether to allow the build farms to build the changes, or whether to avoid this. For the bordeaux build farm, commits can be ignored by adding them to the @code{ignore-commits} list in the @code{build-from-guix-data-service} record, found in the bayfront machine configuration."
msgstr "Se le modifiche vengono revertate perché hanno portato a un numero eccessivo di pacchetti interessati, allora dovrebbe essere presa una decisione se permettere alle build farm di costruire le modifiche o se evitarlo. Per la build farm di bordeaux, i commit possono essere ignorati aggiungendoli alla lista @code{ignore-commits} nel record @code{build-from-guix-data-service}, trovato nella configurazione della macchina bayfront."

msgid "Commit Revocation"
msgstr "Revoca dei Commit"

msgid "In order to reduce the possibility of mistakes, committers will have their Codeberg account removed from the Guix Codeberg project and their key removed from @file{.guix-authorizations} after 12 months of inactivity; they can ask to regain commit access by emailing the maintainers, without going through the vouching process."
msgstr "Per ridurre la possibilità di errori, i committer avranno il loro account Codeberg rimosso dal progetto Guix Codeberg e la loro chiave rimossa da @file{.guix-authorizations} dopo 12 mesi di inattività; possono richiedere di riottenere l'accesso in commit inviando un'email ai maintainer, senza passare attraverso il processo di garanzia."

msgid "Maintainers@footnote{See @uref{https://guix.gnu.org/en/about} for the current list of maintainers.  You can email them privately at @email{guix-maintainers@@gnu.org}.} may also revoke an individual's commit rights, as a last resort, if cooperation with the rest of the community has caused too much friction---even within the bounds of the project's code of conduct (@pxref{Contributing}).  They would only do so after public or private discussion with the individual and a clear notice.  Examples of behavior that hinders cooperation and could lead to such a decision include:"
msgstr "I maintainer@footnote{Vedi @uref{https://guix.gnu.org/en/about} per l'elenco attuale dei maintainer. Puoi inviare loro email privatamente a @email{guix-maintainers@@gnu.org}.} possono anche revocare i diritti di commit di un individuo, come ultima risorsa, se la cooperazione con il resto della comunità ha causato troppa attrito---anche entro i limiti del codice di condotta del progetto (@pxref{Contributing}). Lo farebbero solo dopo una discussione pubblica o privata con l'individuo e un chiaro preavviso. Esempi di comportamento che ostacola la cooperazione e potrebbe portare a una tale decisione includono:"

msgid "repeated violation of the commit policy stated above;"
msgstr "violazione ripetuta della politica dei commit sopra indicata;"

msgid "repeated failure to take peer criticism into account;"
msgstr "mancato ripetuto di tenere conto delle critiche dei pari;"

msgid "breaching trust through a series of grave incidents."
msgstr "violazione della fiducia attraverso una serie di incidenti gravi."

msgid "When maintainers resort to such a decision, they notify developers on @email{guix-devel@@gnu.org}; inquiries may be sent to @email{guix-maintainers@@gnu.org}.  Depending on the situation, the individual may still be welcome to contribute."
msgstr "Quando i maintainer ricorrono a una tale decisione, notificano gli sviluppatori su @email{guix-devel@@gnu.org}; le richieste possono essere inviate a @email{guix-maintainers@@gnu.org}. A seconda della situazione, l'individuo potrebbe ancora essere il benvenuto a contribuire."

msgid "Helping Out"
msgstr "Dare una Mano"

msgid "One last thing: the project keeps moving forward because committers not only push their own awesome changes, but also offer some of their time @emph{reviewing} and pushing other people's changes.  As a committer, you're welcome to use your expertise and commit rights to help other contributors, too!"
msgstr "Un'ultima cosa: il progetto continua ad avanzare perché i committer non solo inviare le loro fantastiche modifiche, ma offrono anche parte del loro tempo a @emph{revisionare} e inviare le modifiche di altre persone. Come committer, sei il benvenuto a usare la tua esperienza e i tuoi diritti di commit per aiutare anche altri contributori!"

msgid "Perhaps the biggest action you can do to help GNU Guix grow as a project is to review the work contributed by others.  You do not need to be a committer to do so; applying, reading the source, building, linting and running other people's series and sharing your comments about your experience will give some confidence to committers.  You must ensure the check list found in the @ref{Submitting Patches} section has been correctly followed.  A reviewed patch series should give the best chances for the proposed change to be merged faster, so if a change you would like to see merged hasn't yet been reviewed, this is the most appropriate thing to do! If you would like to review changes in a specific area and to receive notifications for incoming patches relevant to that domain, consider joining the relevant team(s) (@pxref{Teams})."
msgstr "Forse l'azione più grande che puoi fare per aiutare GNU Guix a crescere come progetto è revisionare il lavoro contribuito da altri. Non devi essere un committer per farlo; applicare, leggere il sorgente, costruire, lintare ed eseguire le serie di altre persone e condividere i tuoi commenti sulla tua esperienza darà una certa fiducia ai committer. Devi assicurarti che la lista di controllo trovata nella sezione @ref{Submitting Patches} sia stata seguita correttamente. Una serie di patch revisionata dovrebbe dare le migliori possibilità affinché la modifica proposta sia unita più velocemente, quindi se una modifica che vorresti vedere unita non è ancora stata revisionata, questa è la cosa più appropriata da fare! Se desideri revisionare modifiche in un'area specifica e ricevere notifiche per patch in arrivo rilevanti per quel dominio, considera di unirti ai team pertinenti (@pxref{Teams})."

msgid "reviewing, guidelines"
msgstr "revisione, linee guida"

msgid "Review comments should be unambiguous; be as clear and explicit as you can about what you think should be changed, ensuring the author can take action on it.  Please try to keep the following guidelines in mind during review:"
msgstr "I commenti di revisione dovrebbero essere inequivocabili; sii il più chiaro ed esplicito possibile su cosa pensi debba essere cambiato, assicurandoti che l'autore possa agire su di esso. Per favore cerca di tenere a mente le seguenti linee guida durante la revisione:"

msgid "@emph{Be clear and explicit about changes you are suggesting}, ensuring the author can take action on it.  In particular, it is a good idea to explicitly ask for new revisions when you want it."
msgstr "@emph{Sii chiaro ed esplicito riguardo alle modifiche che stai suggerendo}, assicurandoti che l'autore possa agire su di esse. In particolare, è una buona idea chiedere esplicitamente nuove revisioni quando le vuoi."

msgid "@emph{Remain focused: do not change the scope of the work being reviewed.} For example, if the contribution touches code that follows a pattern deemed unwieldy, it would be unfair to ask the submitter to fix all occurrences of that pattern in the code; to put it simply, if a problem unrelated to the patch at hand was already there, do not ask the submitter to fix it."
msgstr "@emph{Rimani concentrato: non cambiare l'ambito del lavoro in revisione.} Ad esempio, se il contributo tocca codice che segue uno schema ritenuto ingombrante, sarebbe ingiusto chiedere al mittente di correggere tutte le occorrenze di quello schema nel codice; per dirla semplicemente, se un problema non correlato alla patch in questione era già presente, non chiedere al mittente di risolverlo."

msgid "@emph{Ensure progress.} As they respond to review, submitters may submit new revisions of their changes; avoid requesting changes that you did not request in the previous round of comments.  Overall, the submitter should get a clear sense of progress; the number of items open for discussion should clearly decrease over time."
msgstr "@emph{Assicura il progresso.} Mentre rispondono alla revisione, i mittenti potrebbero inviare nuove revisioni delle loro modifiche; evita di richiedere modifiche che non hai richiesto nel round precedente di commenti. In generale, il mittente dovrebbe avere una chiara sensazione di progresso; il numero di elementi aperti per la discussione dovrebbe chiaramente diminuire nel tempo."

msgid "@emph{Aim for finalization.} Reviewing code is time-consuming.  Your goal as a reviewer is to put the process on a clear path towards integration, possibly with agreed-upon changes, or rejection, with a clear and mutually-understood reasoning.  Avoid leaving the review process in a lingering state with no clear way out."
msgstr "@emph{Mira alla finalizzazione.} Revisionare il codice richiede tempo. Il tuo obiettivo come revisore è mettere il processo su un percorso chiaro verso l'integrazione, possibilmente con modifiche concordate, o il rifiuto, con una motivazione chiara e compresa reciprocamente. Evita di lasciare il processo di revisione in uno stato prolungato senza una via d'uscita chiara."

msgid "@emph{Review is a discussion.} The submitter's and reviewer's views on how to achieve a particular change may not always be aligned.  To lead the discussion, remain focused, ensure progress and aim for finalization, spending time proportional to the stakes@footnote{The tendency to discuss minute details at length is often referred to as ``bikeshedding'', where much time is spent discussing each one's preference for the color of the shed at the expense of progress made on the project to keep bikes dry.}.  As a reviewer, try hard to explain the rationale for suggestions you make, and to understand and take into account the submitter's motivation for doing things in a certain way.  In other words, build consensus with everyone involved (@pxref{Making Decisions})."
msgstr "@emph{La revisione è una discussione.} Le opinioni del mittente e del revisore su come ottenere un particolare cambiamento potrebbero non essere sempre allineate. Per guidare la discussione, rimani concentrato, assicura il progresso e mira alla finalizzazione, spendendo tempo proporzionale alla post@footnote{La tendenza a discutere a lungo di dettagli minuti è spesso chiamata ``bikeshedding'', dove si passa molto tempo a discutere la preferenza di ognuno per il colore del capanno a scapito del progresso fatto sul progetto per tenere le bici asciutte.}. Come revisore, sforzati di spiegare la logica dei suggerimenti che fai e di capire e tenere conto della motivazione del mittente nel fare le cose in un certo modo. In altre parole, costruisci consenso con tutti i coinvolti (@pxref{Making Decisions})."

msgid "When you deem the proposed change adequate and ready for inclusion in Guix, you can explicitly say so for pull requests on Codeberg, for example by selecting ``Approve changes'' in the ``Finish review'' dialog of the web interface."
msgstr "Quando ritieni che la modifica proposta sia adeguata e pronta per l'inclusione in Guix, puoi dirlo esplicitamente per le pull request su Codeberg, ad esempio selezionando ``Approva modifiche'' nella finestra di dialogo ``Termina revisione'' dell'interfaccia web."

msgid "LGTM, Looks Good To Me"
msgstr "LGTM, Looks Good To Me"

msgid "review tags"
msgstr "tag di revisione"

msgid "Reviewed-by, git trailer"
msgstr "Reviewed-by, trailer git"

msgid "The following well understood/codified @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} @footnote{The @samp{Reviewed-by} Git trailer is used by other projects such as Linux, and is understood by third-party tools such as the @samp{b4 am} sub-command, which is able to retrieve the complete submission email thread from a public-inbox instance and add the Git trailers found in replies to the commit patches.} line should be used to sign off as a reviewer, meaning you have reviewed the change and that it looks good to you:"
msgstr "La seguente riga @samp{Reviewed-by:@tie{}Tuo@tie{}Nome@tie{}<tua-email@@example.com>} ben compresa/codificata@footnote{Il trailer Git @samp{Reviewed-by} è usato da altri progetti come Linux, ed è compreso da strumenti di terze parti come il sottocomando @samp{b4 am}, che è in grado di recuperare l'intero thread di email di sottomissione da un'istanza public-inbox e aggiungere i trailer Git trovati nelle risposte alle patch dei commit.} dovrebbe essere usata per firmare come revisore, il che significa che hai revisionato la modifica e che per te va bene:"

msgid "If the @emph{whole} series (containing multiple commits) looks good to you, reply with @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} to the cover page if it has one, or to the last patch of the series otherwise, adding another @samp{(for the whole series)} comment on the line below to explicit this fact."
msgstr "Se l'@emph{intera} serie (contenente più commit) ti sembra buona, rispondi con @samp{Reviewed-by:@tie{}Tuo@tie{}Nome@tie{}<tua-email@@example.com>} alla pagina di copertina se ce n'è una, o all'ultima patch della serie altrimenti, aggiungendo un altro commento @samp{(for the whole series)} sulla riga sotto per esplicitare questo fatto."

msgid "If you instead want to mark a @emph{single commit} as reviewed (but not the whole series), simply reply with @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} to that commit message."
msgstr "Se invece vuoi contrassegnare un @emph{single commit} come revisionato (ma non l'intera serie), rispondi semplicemente con @samp{Reviewed-by:@tie{}Tuo@tie{}Nome@tie{}<tua-email@@example.com>} a quel messaggio di commit."

msgid "update-guix-package, updating the guix package"
msgstr "update-guix-package, aggiornamento del pacchetto guix"

msgid "It is sometimes desirable to update the @code{guix} package itself (the package defined in @code{(gnu packages package-management)}), for example to make new daemon features available for use by the @code{guix-service-type} service type.  In order to simplify this task, the following command can be used:"
msgstr "A volte è desiderabile aggiornare il pacchetto @code{guix} stesso (il pacchetto definito in @code{(gnu packages package-management)}), ad esempio per rendere disponibili nuove funzionalità del demone per l'uso da parte del tipo di servizio @code{guix-service-type}. Per semplificare questo compito, può essere usato il seguente comando:"

msgid "make update-guix-package\n"
msgstr "make update-guix-package\n"

msgid "The @code{update-guix-package} make target will use the last known @emph{commit} corresponding to @code{HEAD} in your Guix checkout, compute the hash of the Guix sources corresponding to that commit and update the @code{commit}, @code{revision} and hash of the @code{guix} package definition."
msgstr "L'obiettivo make @code{update-guix-package} userà l'ultimo @emph{commit} noto corrispondente a @code{HEAD} nel tuo checkout di Guix, calcolerà l'hash delle sorgenti di Guix corrispondenti a quel commit e aggiornerà il @code{commit}, @code{revision} e l'hash della definizione del pacchetto @code{guix}."

msgid "To validate that the updated @code{guix} package hashes are correct and that it can be built successfully, the following command can be run from the directory of your Guix checkout:"
msgstr "Per convalidare che gli hash aggiornati del pacchetto @code{guix} siano corretti e che possa essere costruito con successo, il seguente comando può essere eseguito dalla directory del tuo checkout di Guix:"

msgid "./pre-inst-env guix build guix\n"
msgstr "./pre-inst-env guix build guix\n"

msgid "To guard against accidentally updating the @code{guix} package to a commit that others can't refer to, a check is made that the commit used has already been pushed to the Codeberg-hosted Guix Git repository."
msgstr "Per evitare di aggiornare accidentalmente il pacchetto @code{guix} a un commit a cui altri non possono fare riferimento, viene effettuato un controllo che il commit utilizzato sia già stato inviato al repository Git di Guix ospitato su Codeberg."

msgid "This check can be disabled, @emph{at your own peril}, by setting the @code{GUIX_ALLOW_ME_TO_USE_PRIVATE_COMMIT} environment variable.  When this variable is set, the updated package source is also added to the store.  This is used as part of the release process of Guix."
msgstr "Questo controllo può essere disabilitato, @emph{a tuo rischio e pericolo}, impostando la variabile d'ambiente @code{GUIX_ALLOW_ME_TO_USE_PRIVATE_COMMIT}. Quando questa variabile è impostata, la sorgente del pacchetto aggiornato viene anche aggiunta allo store. Questo è usato come parte del processo di rilascio di Guix."

msgid "deprecation policy"
msgstr "politica di deprecazione"

msgid "As any lively project with a broad scope, Guix changes all the time and at all levels.  Because it's user-extensible and programmable, incompatible changes can directly impact users and make their life harder.  It is thus important to reduce user-visible incompatible changes to a minimum and, when such changes are deemed necessary, to clearly communicate them through a @dfn{deprecation period} so everyone can adapt with minimum hassle.  This section defines the project's commitments for smooth deprecation and describes procedures and mechanisms to honor them."
msgstr "Come qualsiasi progetto vivace con un ampio ambito, Guix cambia continuamente e a tutti i livelli. Poiché è estendibile dall'utente e programmabile, cambiamenti incompatibili possono influenzare direttamente gli utenti e rendere loro la vita più difficile. È quindi importante ridurre al minimo i cambiamenti incompatibili visibili all'utente e, quando tali cambiamenti sono ritenuti necessari, comunicarli chiaramente attraverso un @dfn{periodo di deprecazione} in modo che tutti possano adattarsi con il minimo disagio. Questa sezione definisce gli impegni del progetto per una deprecazione fluida e descrive procedure e meccanismi per rispettarli."

msgid "There are several ways to use Guix; how to handle deprecation will depend on each use case.  Those can be roughly categorized like this:"
msgstr "Ci sono diversi modi per usare Guix; come gestire la deprecazione dipenderà:"

msgid "package management exclusively through the command line;"
msgstr "gestione dei pacchetti esclusivamente tramite riga di comando;"

msgid "advanced package management using the manifest and package interfaces;"
msgstr "gestione avanzata dei pacchetti utilizzando le interfacce manifest e pacchetto;"

msgid "Home and System management, using the @code{operating-system} and/or @code{home-environment} interfaces together with the service interfaces;"
msgstr "gestione di Home e System, utilizzando le interfacce @code{operating-system} e/o @code{home-environment} insieme alle interfacce dei servizi;"

msgid "development or use of external tools that use programming interfaces such as the @code{(guix ...)} modules."
msgstr "sviluppo o utilizzo di strumenti esterni che utilizzano interfacce di programmazione come i moduli @code{(guix ...)}."

msgid "These use cases form a spectrum with varying degrees of coupling---from ``distant'' to tightly coupled.  Based on this insight, we define the following @dfn{deprecation policies} that we consider suitable for each of these levels."
msgstr "Questi casi d'uso formano uno spettro con vari gradi di accoppiamento—da ``distante'' a strettamente accoppiato. Basandoci su questa osservazione, definiamo le seguenti @dfn{politiche di deprecazione} che riteniamo adatte per ciascuno di questi livelli."

msgid "Guix sub-commands should be thought of as remaining available ``forever''.  Once a Guix sub-command is to be removed, it should be deprecated first, and then remain available for @b{at least one year} after the first release that deprecated it."
msgstr "I sottocomandi di Guix dovrebbero essere considerati disponibili ``per sempre''. Una volta che un sottocomando di Guix deve essere rimosso, dovrebbe prima essere deprecato, quindi rimanere disponibile per @b{almeno un anno} dopo la prima versione che lo ha deprecato."

msgid "Deprecation should first be announced in the manual and as an entry in @file{etc/news.scm}; additional communication such as a blog post explaining the rationale is welcome.  Months before the scheduled removal date, the command should print a warning explaining how to migrate.  An example of this is the replacement of @command{guix environment} by @command{guix shell}, started in October 2021@footnote{For more details on the @command{guix shell} transition, see @uref{https://guix.gnu.org/en/blog/2021/from-guix-environment-to-guix-shell/}.}."
msgstr "La deprecazione dovrebbe essere prima annunciata nel manuale e come voce in @file{etc/news.scm}; sono benvenute comunicazioni aggiuntive come un post su blog che spieghi la motivazione. Mesi prima della data di rimozione pianificata, il comando dovrebbe stampare un avviso che spiega come migrare. Un esempio di ciò è la sostituzione di @command{guix environment} con @command{guix shell}, iniziata nell'ottobre 2021@footnote{Per maggiori dettagli sulla transizione di @command{guix shell}, vedere @uref{https://guix.gnu.org/en/blog/2021/from-guix-environment-to-guix-shell/}.}."

msgid "Because of the broad impact of such a change, we recommend conducting a user survey before enacting a plan."
msgstr "A causa del vasto impatto di tale cambiamento, raccomandiamo di condurre un sondaggio utente prima di attuare un piano."

msgid "package deprecation"
msgstr "deprecazione dei pacchetti"

msgid "Package name changes"
msgstr "Cambiamenti di nome dei pacchetti"

msgid "When a package name changes, it must remain available under its old name for @b{at least one year}.  For example, @code{go-ipfs} was renamed to @code{kubo} following a decision made upstream; to communicate the name change to users, the package module provided this definition:"
msgstr "Quando il nome di un pacchetto cambia, deve rimanere disponibile con il suo vecchio nome per @b{almeno un anno}. Ad esempio, @code{go-ipfs} è stato rinominato in @code{kubo} a seguito di una decisione upstream; per comunicare il cambio di nome agli utenti, il modulo del pacchetto ha fornito questa definizione:"

msgid "deprecated-package"
msgstr "deprecated-package"

msgid "package removal policy"
msgstr "politica di rimozione dei pacchetti"

msgid "package-removal-policy"
msgstr "package-removal-policy"

msgid "Packages whose upstream developers have declared as having reached ``end of life'' or being unmaintained may be removed; likewise, packages that have been @b{failing to build for two months or more} may be removed."
msgstr "I pacchetti i cui sviluppatori upstream hanno dichiarato di aver raggiunto ``fine vita'' o non essere più mantenuti possono essere rimossi; allo stesso modo, i pacchetti che @b{non sono stati compilati con successo per due mesi o più} possono essere rimossi."

msgid "If the package being removed is a ``leaf'' (no other packages depend on it), it may be removed after a @b{one-month review period} of the patch removing it (this applies even when the removal has additional motivations such as security problems affecting the package)."
msgstr "Se il pacchetto da rimuovere è una ``foglia'' (nessun altro pacchetto dipende da esso), può essere rimosso dopo un @b{periodo di revisione di un mese} della patch che lo rimuove (questo si applica anche quando la rimozione ha motivazioni aggiuntive come problemi di sicurezza che interessano il pacchetto)."

msgid "When the package being removed is considered popular, whether or not it is a leaf, its deprecation must be announced as an entry in @code{etc/news.scm}."
msgstr "Quando il pacchetto da rimuovere è considerato popolare, che sia o meno una foglia, la sua deprecazione deve essere annunciata come voce in @code{etc/news.scm}."

msgid "In the case of packages with many dependents and/or many users, an upgrade may be treated like the @emph{removal} of the previous version."
msgstr "Nel caso di pacchetti con molti dipendenti e/o molti utenti, un aggiornamento può essere trattato come la @emph{removal} della versione precedente."

msgid "Examples include major version upgrades of programming language implementations, as we've seen above with Python, and major upgrades of ``big'' libraries such as Qt or GTK."
msgstr "Esempi includono aggiornamenti di versione maggiore delle implementazioni di linguaggi di programmazione, come abbiamo visto sopra con Python, e aggiornamenti maggiori di librerie ``grandi'' come Qt o GTK."

msgid "service deprecation"
msgstr "deprecazione dei servizi"

msgid "Services"
msgstr "Servizi"

msgid "Changes to services for Guix Home and Guix System have a direct impact on user configuration.  For a user, adjusting to interface changes is rarely rewarding, which is why any such change must be clearly communicated in advance through deprecation warnings and documentation."
msgstr "Le modifiche ai servizi per Guix Home e Guix System hanno un impatto diretto sulla configurazione dell'utente. Per un utente, adattarsi ai cambiamenti dell'interfaccia è raramente gratificante, motivo per cui ogni modifica del genere deve essere chiaramente comunicata in anticipo tramite avvisi di deprecazione e documentazione."

msgid "Renaming of variables related to service, home, or system configuration must be communicated for at least six months before removal using the @code{(guix deprecation)} mechanisms.  For example, renaming of @code{murmur-configuration} to @code{mumble-server-configuration} was communicated through a series of definitions like this one:"
msgstr "La ridenominazione di variabili relative a servizi, home o configurazione di sistema deve essere comunicata per almeno sei mesi prima della rimozione utilizzando i meccanismi @code{(guix deprecation)}. Ad esempio, la ridenominazione di @code{murmur-configuration} in @code{mumble-server-configuration} è stata comunicata tramite una serie di definizioni come questa:"

msgid "define-deprecated/public-alias"
msgstr "define-deprecated/public-alias"

msgid ""
"(define-deprecated/public-alias\n"
"  murmur-configuration\n"
"  mumble-server-configuration)\n"
msgstr ""
"(define-deprecated/public-alias\n"
"  murmur-configuration\n"
"  mumble-server-configuration)\n"

msgid "Procedures slated for removal may be defined like this:"
msgstr "Le procedure destinate alla rimozione possono essere definite così:"

msgid "define-deprecated"
msgstr "define-deprecated"

msgid ""
"(define-deprecated (elogind-service #:key (config (elogind-configuration)))\n"
"  elogind-service-type\n"
"  (service elogind-service-type config))\n"
msgstr ""
"(define-deprecated (elogind-service #:key (config (elogind-configuration)))\n"
"  elogind-service-type\n"
"  (service elogind-service-type config))\n"

msgid "Record fields, notably fields of service configuration records, must follow a similar deprecation period.  This is usually achieved through @i{ad hoc} means though.  For example, the @code{hosts-file} field of @code{operating-system} was deprecated by adding a @code{sanitized} property that would emit a warning:"
msgstr "I campi dei record, in particolare i campi dei record di configurazione dei servizi, devono seguire un periodo di deprecazione simile. Tuttavia, questo di solito è ottenuto tramite mezzi @i{ad hoc}. Ad esempio, il campo @code{hosts-file} di @code{operating-system} è stato deprecato aggiungendo una proprietà @code{sanitized} che emetteva un avviso:"

msgid ""
"(define-record-type* <operating-system>\n"
"  ;; @dots{}\n"
"  (hosts-file %operating-system-hosts-file         ;deprecated\n"
"              (default #f)\n"
"              (sanitize warn-hosts-file-field-deprecation)))\n"
"\n"
msgstr ""
"(define-record-type* <operating-system>\n"
"  ;; @dots{}\n"
"  (hosts-file %operating-system-hosts-file         ;obsoleto\n"
"              (default #f)\n"
"              (sanitize warn-hosts-file-field-deprecation)))\n"
"\n"

msgid ""
"(define-deprecated (operating-system-hosts-file os)\n"
"  hosts-service-type\n"
"  (%operating-system-hosts-file os))\n"
msgstr ""
"(define-deprecated (operating-system-hosts-file os)\n"
"  hosts-service-type\n"
"  (%operating-system-hosts-file os))\n"

msgid "When deprecating interfaces in @code{operating-system}, @code{home-environment}, @code{(gnu services)}, or any popular service, the deprecation must come with an entry in @code{etc/news.scm}."
msgstr "Quando si deprecano interfacce in @code{operating-system}, @code{home-environment}, @code{(gnu services)} o qualsiasi servizio popolare, la deprecazione deve includere una voce in @code{etc/news.scm}."

msgid "deprecation of programming interfaces"
msgstr "deprecazione delle interfacce di programmazione"

msgid "Core programming interfaces, in particular the @code{(guix ...)} modules, may be relied on by a variety of external tools and channels.  Any incompatible change must be formally deprecated with @code{define-deprecated}, as shown above, for @b{at least one year} before removal.  The manual must clearly document the new interface and, except in obvious cases, explain how to migrate from the old one."
msgstr "Le interfacce di programmazione principali, in particolare i moduli @code{(guix ...)}, possono essere utilizzate da vari strumenti e canali esterni. Qualsiasi modifica incompatibile deve essere formalmente deprecata con @code{define-deprecated}, come mostrato sopra, per @b{almeno un anno} prima della rimozione. Il manuale deve documentare chiaramente la nuova interfaccia e, tranne nei casi ovvi, spiegare come migrare dalla vecchia."

msgid "As an example, the @code{build-expression->derivation} procedure was superseded by @code{gexp->derivation} and remained available as a deprecated symbol:"
msgstr "Ad esempio, la procedura @code{build-expression->derivation} è stata sostituita da @code{gexp->derivation} ed è rimasta disponibile come simbolo deprecato:"

msgid ""
"(define-deprecated (build-expression->derivation store name exp\n"
"                                                 #:key @dots{})\n"
"  gexp->derivation\n"
"  @dots{})\n"
msgstr ""
"(define-deprecated (build-expression->derivation store name exp\n"
"                                                 #:key @dots{})\n"
"  gexp->derivation\n"
"  @dots{})\n"

msgid "Sometimes bindings are moved from one module to another.  In those cases, bindings must be reexported from the original module for at least one year."
msgstr "A volte i binding vengono spostati da un modulo a un altro. In questi casi, i binding devono essere riesportati dal modulo originale per almeno un anno."

msgid "This section does not cover all possible situations but hopefully allows users to know what to expect and developers to stick to its spirit.  Please email @email{guix-devel@@gnu.org} for any questions."
msgstr "Questa sezione non copre tutte le possibili situazioni ma si spera permetta agli utenti di sapere cosa aspettarsi e agli sviluppatori di attenersi al suo spirito. Per qualsiasi domanda, inviare un'email a @email{guix-devel@@gnu.org}."

msgid "documentation"
msgstr "documentation"

msgid "Guix is documented using the Texinfo system.  If you are not yet familiar with it, we accept contributions for documentation in most formats.  That includes plain text, Markdown, Org, etc."
msgstr "Guix è documentato utilizzando il sistema Texinfo. Se non lo conosci ancora, accettiamo contributi per la documentazione nella maggior parte dei formati. Ciò include testo semplice, Markdown, Org, ecc."

msgid "Documentation contributions can be sent to @email{guix-patches@@gnu.org}.  Prepend @samp{[DOCUMENTATION]} to the subject."
msgstr "I contributi alla documentazione possono essere inviati a @email{guix-patches@@gnu.org}. Anteporre @samp{[DOCUMENTATION]} all'oggetto."

msgid "When you need to make more than a simple addition to the documentation, we prefer that you send a proper patch as opposed to sending an email as described above.  @xref{Submitting Patches} for more information on how to send your patches."
msgstr "Quando devi apportare più di una semplice aggiunta alla documentazione, preferiamo che invii una patch corretta invece di inviare un'email come descritto sopra. @xref{Submitting Patches} per maggiori informazioni su come inviare le tue patch."

msgid "To modify the documentation, you need to edit @file{doc/guix.texi} and @file{doc/contributing.texi} (which contains this documentation section), or @file{doc/guix-cookbook.texi} for the cookbook.  If you compiled the Guix repository before, you will have many more @file{.texi} files that are translations of these documents.  Do not modify them, the translation is managed through @uref{https://translate.codeberg.org/projects/guix, Weblate}.  @xref{Translating Guix} for more information."
msgstr "Per modificare la documentazione, devi modificare @file{doc/guix.texi} e @file{doc/contributing.texi} (che contiene questa sezione di documentazione) o @file{doc/guix-cookbook.texi} per il cookbook. Se hai compilato il repository Guix in precedenza, avrai molti altri file @file{.texi} che sono traduzioni di questi documenti. Non modificarli, la traduzione è gestita tramite @uref{https://translate.codeberg.org/projects/guix, Weblate}. @xref{Translating Guix} per maggiori informazioni."

msgid "To render documentation, you must first make sure that you ran @command{./configure} in your source tree (@pxref{Running Guix Before It Is Installed}).  After that you can run one of the following commands:"
msgstr "Per generare la documentazione, devi prima assicurarti di aver eseguito @command{./configure} nel tuo albero sorgente (@pxref{Running Guix Before It Is Installed}). Dopodiché puoi eseguire uno dei seguenti comandi:"

msgid "@samp{make doc/guix.info} to compile the Info manual."
msgstr "@samp{make doc/guix.info} per compilare il manuale Info."

msgid "You can check it with @command{info doc/guix.info}."
msgstr "Puoi controllarlo con @command{info doc/guix.info}."

msgid "@samp{make doc/guix.html} to compile the HTML version."
msgstr "@samp{make doc/guix.html} per compilare la versione HTML."

msgid "You can point your browser to the relevant file in the @file{doc/guix.html} directory."
msgstr "Puoi puntare il tuo browser al file pertinente nella directory @file{doc/guix.html}."

msgid "@samp{make doc/guix-cookbook.info} for the cookbook Info manual."
msgstr "@samp{make doc/guix-cookbook.info} per il manuale Info del cookbook."

msgid "@samp{make doc/guix-cookbook.html} for the cookbook HTML version."
msgstr "@samp{make doc/guix-cookbook.html} per la versione HTML del cookbook."

msgid "l10n"
msgstr "l10n"

msgid "i18n"
msgstr "i18n"

msgid "native language support"
msgstr "supporto per la lingua nativa"

msgid "Writing code and packages is not the only way to provide a meaningful contribution to Guix.  Translating to a language you speak is another example of a valuable contribution you can make.  This section is designed to describe the translation process.  It gives you advice on how you can get involved, what can be translated, what mistakes you should avoid and what we can do to help you!"
msgstr "Scrivere codice e pacchetti non è l'unico modo per fornire un contributo significativo a Guix. Tradurre in una lingua che conosci è un altro esempio di contributo prezioso che puoi dare. Questa sezione è progettata per descrivere il processo di traduzione. Ti dà consigli su come puoi coinvolgerti, cosa puoi tradurre, quali errori dovresti evitare e cosa possiamo fare per aiutarti!"

msgid "Guix is a big project that has multiple components that can be translated.  We coordinate the translation effort on a @uref{https://translate.codeberg.org/projects/guix/,Weblate instance} hosted by Codeberg.  You will need an account to submit translations."
msgstr "Guix è un grande progetto con più componenti che possono essere tradotti. Coordiniamo lo sforzo di traduzione su un @uref{https://translate.codeberg.org/projects/guix/,istanza Weblate} ospitata da Codeberg. Avrai bisogno di un account per inviare traduzioni."

msgid "Some of the software packaged in Guix also contain translations.  We do not host a translation platform for them.  If you want to translate a package provided by Guix, you should contact their developers or find the information on their website.  As an example, you can find the homepage of the @code{hello} package by typing @command{guix show hello}.  On the ``homepage'' line, you will see @url{https://www.gnu.org/software/hello/} as the homepage."
msgstr "Alcuni dei software impacchettati in Guix contengono anche traduzioni. Non ospitiamo una piattaforma di traduzione per loro. Se vuoi tradurre un pacchetto fornito da Guix, dovresti contattare i suoi sviluppatori o trovare le informazioni sul loro sito web. Ad esempio, puoi trovare la homepage del pacchetto @code{hello} digitando @command{guix show hello}. Sulla riga ``homepage'', vedrai @url{https://www.gnu.org/software/hello/} come homepage."

msgid "Many GNU and non-GNU packages can be translated on the @uref{https://translationproject.org,Translation Project}.  Some projects with multiple components have their own platform.  For instance, GNOME has its own platform, @uref{https://l10n.gnome.org/,Damned Lies}."
msgstr "Molti pacchetti GNU e non GNU possono essere tradotti su @uref{https://translationproject.org,Translation Project}. Alcuni progetti con più componenti hanno la loro piattaforma. Ad esempio, GNOME ha la sua piattaforma, @uref{https://l10n.gnome.org/,Damned Lies}."

msgid "Guix has five components hosted on Weblate."
msgstr "Guix ha cinque componenti ospitati su Weblate."

msgid "@code{guix} contains all the strings from the Guix software (the"
msgstr "@code{guix} contiene tutte le stringhe del software Guix (il"

msgid "guided system installer, the package manager, etc), excluding packages."
msgstr "installer guidato del sistema, il gestore di pacchetti, ecc.), escludendo i pacchetti."

msgid "@code{packages} contains the synopsis (single-sentence description"
msgstr "@code{packages} contiene la sinossi (descrizione di una frase)"

msgid "of a package) and description (longer description) of packages in Guix."
msgstr "di un pacchetto) e la descrizione (descrizione più lunga) dei pacchetti in Guix."

msgid "@code{website} contains the official Guix website, except for"
msgstr "@code{website} contiene il sito web ufficiale di Guix, eccetto per"

msgid "blog posts and multimedia content."
msgstr "post del blog e contenuti multimediali."

msgid "@code{documentation-manual} corresponds to this manual."
msgstr "@code{documentation-manual} corrisponde a questo manuale."

msgid "@code{documentation-cookbook} is the component for the cookbook."
msgstr "@code{documentation-cookbook} è il componente per il cookbook."

msgid "General Directions"
msgstr "Indicazioni Generali"

msgid "Once you get an account, you should be able to select a component from @uref{https://translate.codeberg.org/projects/guix/,the guix project}, and select a language.  If your language does not appear in the list, go to the bottom and click on the ``Start new translation'' button.  Select the language you want to translate to from the list, to start your new translation."
msgstr "Una volta ottenuto un account, dovresti essere in grado di selezionare un componente da @uref{https://translate.codeberg.org/projects/guix/,il progetto guix} e selezionare una lingua. Se la tua lingua non appare nell'elenco, vai in fondo e clicca sul pulsante ``Start new translation''. Seleziona la lingua in cui vuoi tradurre dall'elenco per iniziare la tua nuova traduzione."

msgid "Like lots of other free software packages, Guix uses @uref{https://www.gnu.org/software/gettext,GNU Gettext} for its translations, with which translatable strings are extracted from the source code to so-called PO files."
msgstr "Come molti altri pacchetti software libero, Guix utilizza @uref{https://www.gnu.org/software/gettext,GNU Gettext} per le sue traduzioni, con cui le stringhe traducibili vengono estratte dal codice sorgente in file cosiddetti PO."

msgid "Even though PO files are text files, changes should not be made with a text editor but with PO editing software.  Weblate integrates PO editing functionality.  Alternatively, translators can use any of various free-software tools for filling in translations, of which @uref{https://poedit.net/,Poedit} is one example, and (after logging in)  @uref{https://docs.weblate.org/en/latest/user/files.html,upload} the changed file.  There is also a special @uref{https://www.emacswiki.org/emacs/PoMode,PO editing mode} for users of GNU Emacs.  Over time translators find out what software they are happy with and what features they need."
msgstr "Anche se i file PO sono file di testo, le modifiche non dovrebbero essere fatte con un editor di testo ma con software di editing PO. Weblate integra la funzionalità di editing PO. In alternativa, i traduttori possono utilizzare uno dei vari strumenti software libero per compilare le traduzioni, tra cui @uref{https://poedit.net/,Poedit} è un esempio, e (dopo aver effettuato l'accesso) @uref{https://docs.weblate.org/en/latest/user/files.html,caricare} il file modificato. C'è anche un @uref{https://www.emacswiki.org/emacs/PoMode,modalità di editing PO} speciale per gli utenti di GNU Emacs. Nel tempo i traduttori scoprono con quale software sono soddisfatti e di quali funzionalità hanno bisogno."

msgid "On Weblate, you will find various links to the editor, that will show various subsets (or all) of the strings.  Have a look around and at the @uref{https://docs.weblate.org/en/latest/,documentation} to familiarize yourself with the platform."
msgstr "Su Weblate, troverai vari collegamenti all'editor, che mostreranno vari sottoinsiemi (o tutte) le stringhe. Dai un'occhiata in giro e alla @uref{https://docs.weblate.org/en/latest/,documentazione} per familiarizzare con la piattaforma."

msgid "Translation Components"
msgstr "Componenti della Traduzione"

msgid "In this section, we provide more detailed guidance on the translation process, as well as details on what you should or should not do.  When in doubt, please contact us, we will be happy to help!"
msgstr "In questa sezione, forniamo indicazioni più dettagliate sul processo di traduzione, nonché dettagli su cosa dovresti o non dovresti fare. In caso di dubbio, contattaci, saremo felici di aiutare!"

msgid "Guix is written in the Guile programming language, and some strings contain special formatting that is interpreted by Guile.  These special formatting should be highlighted by Weblate.  They start with @code{~} followed by one or more characters."
msgstr "Guix è scritto nel linguaggio di programmazione Guile e alcune stringhe contengono formattazioni speciali interpretate da Guile. Queste formattazioni speciali dovrebbero essere evidenziate da Weblate. Iniziano con @code{~} seguito da uno o più caratteri."

msgid "When printing the string, Guile replaces the special formatting symbols with actual values.  For instance, the string @samp{ambiguous package specification `~a'} would be substituted to contain said package specification instead of @code{~a}.  To properly translate this string, you must keep the formatting code in your translation, although you can place it where it makes sense in your language.  For instance, the French translation says @samp{spécification du paquet « ~a » ambiguë} because the adjective needs to be placed in the end of the sentence."
msgstr "Quando stampa la stringa, Guile sostituisce i simboli di formattazione speciali con valori effettivi. Ad esempio, la stringa @samp{ambiguous package specification `~a'} verrebbe sostituita per contenere la specifica del pacchetto anziché @code{~a}. Per tradurre correttamente questa stringa, devi mantenere il codice di formattazione nella tua traduzione, sebbene tu possa posizionarlo dove ha senso nella tua lingua. Ad esempio, la traduzione francese dice @samp{spécification du paquet « ~a » ambiguë} perché l'aggettivo deve essere posto alla fine della frase."

msgid "If there are multiple formatting symbols, make sure to respect the order.  Guile does not know in which order you intended the string to be read, so it will substitute the symbols in the same order as the English sentence."
msgstr "Se ci sono più simboli di formattazione, assicurati di rispettare l'ordine. Guile non sa in quale ordine intendevi che la stringa fosse letta, quindi sostituirà i simboli nello stesso ordine della frase inglese."

msgid "As an example, you cannot translate @samp{package '~a' has been superseded by '~a'} by @samp{'~a' supersedes package '~a'}, because the meaning would be reversed.  If @var{foo} is superseded by @var{bar}, the translation would read @samp{'foo' supersedes package 'bar'}.  To work around this problem, it is possible to use more advanced formatting to select a given piece of data, instead of following the default English order.  @xref{Formatted Output,,, guile, GNU Guile Reference Manual}, for more information on formatting in Guile."
msgstr "Ad esempio, non puoi tradurre @samp{package '~a' has been superseded by '~a'} con @samp{'~a' supersedes package '~a'}, perché il significato sarebbe invertito. Se @var{foo} è sostituito da @var{bar}, la traduzione dice @samp{'foo' supersedes package 'bar'}. Per aggirare questo problema, è possibile utilizzare una formattazione più avanzata per selezionare un dato pezzo di dati, invece di seguire l'ordine predefinito inglese. @xref{Formatted Output,,, guile, GNU Guile Reference Manual}, per maggiori informazioni sulla formattazione in Guile."

msgid "packages"
msgstr "pacchetti"

msgid "Package descriptions occasionally contain Texinfo markup (@pxref{Synopses and Descriptions}).  Texinfo markup looks like @samp{@@code@{rm -rf@}}, @samp{@@emph@{important@}}, etc.  When translating, please leave markup as is."
msgstr "Le descrizioni dei pacchetti occasionalmente contengono markup Texinfo (@pxref{Synopses and Descriptions}). Il markup Texinfo appare come @samp{@@code@{rm -rf@}}, @samp{@@emph@{important@}}, ecc. Durante la traduzione, per favore lascia il markup così com'è."

msgid "The characters after ``@@'' form the name of the markup, and the text between ``@{'' and ``@}'' is its content.  In general, you should not translate the content of markup like @code{@@code}, as it contains literal code that do not change with language.  You can translate the content of formatting markup such as @code{@@emph}, @code{@@i}, @code{@@itemize}, @code{@@item}.  However, do not translate the name of the markup, or it will not be recognized.  Do not translate the word after @code{@@end}, it is the name of the markup that is closed at this position (e.g.@: @code{@@itemize ... @@end itemize})."
msgstr "I caratteri dopo ``@@'' formano il nome del markup, e il testo tra ``@{'' e ``@}'' è il suo contenuto. In generale, non dovresti tradurre il contenuto di markup come @code{@@code}, poiché contiene codice letterale che non cambia con la lingua. Puoi tradurre il contenuto del markup di formattazione come @code{@@emph}, @code{@@i}, @code{@@itemize}, @code{@@item}. Tuttavia, non tradurre il nome del markup, altrimenti non sarà riconosciuto. Non tradurre la parola dopo @code{@@end}, è il nome del markup che viene chiuso in questa posizione (es.@: @code{@@itemize ... @@end itemize})."

msgid "documentation-manual and documentation-cookbook"
msgstr "documentation-manual e documentation-cookbook"

msgid "The first step to ensure a successful translation of the manual is to find and translate the following strings @emph{first}:"
msgstr "Il primo passo per garantire una traduzione riuscita del manuale è trovare e tradurre @emph{first} le seguenti stringhe:"

msgid "@code{version.texi}: Translate this string as @code{version-xx.texi},"
msgstr "@code{version.texi}: Traduci questa stringa come @code{version-xx.texi},"

msgid "where @code{xx} is your language code (the one shown in the URL on weblate)."
msgstr "dove @code{xx} è il tuo codice lingua (quello mostrato nell'URL su weblate)."

msgid "@code{contributing.texi}: Translate this string as"
msgstr "@code{contributing.texi}: Traduci questa stringa come"

msgid "@code{contributing.xx.texi}, where @code{xx} is the same language code."
msgstr "@code{contributing.xx.texi}, dove @code{xx} è lo stesso codice lingua."

msgid "@code{Top}: Do not translate this string, it is important for Texinfo."
msgstr "@code{Top}: Non tradurre questa stringa, è importante per Texinfo."

msgid "If you translate it, the document will be empty (missing a Top node).  Please look for it, and register @code{Top} as its translation."
msgstr "Se la traduci, il documento sarà vuoto (manca un nodo Top). Per favore cercala e registra @code{Top} come sua traduzione."

msgid "Translating these strings first ensure we can include your translation in the guix repository without breaking the make process or the @command{guix pull} machinery."
msgstr "Tradurre queste stringhe per prime garantisce che possiamo includere la tua traduzione nel repository guix senza interrompere il processo make o il meccanismo @command{guix pull}."

msgid "The manual and the cookbook both use Texinfo.  As for @code{packages}, please keep Texinfo markup as is.  There are more possible markup types in the manual than in the package descriptions.  In general, do not translate the content of @code{@@code}, @code{@@file}, @code{@@var}, @code{@@value}, etc.  You should translate the content of formatting markup such as @code{@@emph}, @code{@@i}, etc."
msgstr "Il manuale e il cookbook utilizzano entrambi Texinfo. Come per @code{packages}, per favore mantieni il markup Texinfo così com'è. Ci sono più tipi di markup possibili nel manuale che nelle descrizioni dei pacchetti. In generale, non tradurre il contenuto di @code{@@code}, @code{@@file}, @code{@@var}, @code{@@value}, ecc. Dovresti tradurre il contenuto del markup di formattazione come @code{@@emph}, @code{@@i}, ecc."

msgid "The manual contains sections that can be referred to by name by @code{@@ref}, @code{@@xref} and @code{@@pxref}.  We have a mechanism in place so you do not have to translate their content.  If you keep the English title, we will automatically replace it with your translation of that title.  This ensures that Texinfo will always be able to find the node. If you decide to change the translation of the title, the references will automatically be updated and you will not have to update them all yourself."
msgstr "Il manuale contiene sezioni a cui si può fare riferimento per nome con @code{@@ref}, @code{@@xref} e @code{@@pxref}. Abbiamo un meccanismo in atto in modo che tu non debba tradurne il contenuto. Se mantieni il titolo inglese, lo sostituiremo automaticamente con la tua traduzione di quel titolo. Ciò garantisce che Texinfo sarà sempre in grado di trovare il nodo. Se decidi di cambiare la traduzione del titolo, i riferimenti verranno aggiornati automaticamente e non dovrai aggiornarli tutti tu stesso."

msgid "When translating references from the cookbook to the manual, you need to replace the name of the manual and the name of the section.  For instance, to translate @code{@@pxref@{Defining Packages,,, guix, GNU Guix Reference Manual@}}, you would replace @code{Defining Packages} with the title of that section in the translated manual @emph{only} if that title is translated.  If the title is not translated in your language yet, do not translate it here, or the link will be broken.  Replace @code{guix} with @code{guix.xx} where @code{xx} is your language code.  @code{GNU Guix Reference Manual} is the text of the link.  You can translate it however you wish."
msgstr "Quando traduci riferimenti dal cookbook al manuale, devi sostituire il nome del manuale e il nome della sezione. Ad esempio, per tradurre @code{@@pxref@{Defining Packages,,, guix, GNU Guix Reference Manual@}}, sostituiresti @code{Defining Packages} con il titolo di quella sezione nel manuale tradotto @emph{solo} se quel titolo è tradotto. Se il titolo non è ancora tradotto nella tua lingua, non tradurlo qui, altrimenti il collegamento si interromperà. Sostituisci @code{guix} con @code{guix.xx} dove @code{xx} è il tuo codice lingua. @code{GNU Guix Reference Manual} è il testo del collegamento. Puoi tradurlo come preferisci."

msgid "website"
msgstr "sito web"

msgid "The website pages are written using SXML, an s-expression version of HTML, the basic language of the web.  We have a process to extract translatable strings from the source, and replace complex s-expressions with a more familiar XML markup, where each markup is numbered.  Translators can arbitrarily change the ordering, as in the following example."
msgstr "Le pagine del sito web sono scritte in SXML, una versione s-expression di HTML, il linguaggio di base del web. Abbiamo un processo per estrarre le stringhe traducibili dal sorgente e sostituire espressioni s complesse con un markup XML più familiare, dove ogni markup è numerato. I traduttori possono cambiare arbitrariamente l'ordine, come nell'esempio seguente."

msgid ""
"#. TRANSLATORS: Defining Packages is a section name\n"
"#. in the English (en) manual.\n"
"#: apps/base/templates/about.scm:64\n"
"msgid \"Packages are <1>defined<1.1>en</1.1><1.2>Defining-Packages.html</1.2></1> as native <2>Guile</2> modules.\"\n"
"msgstr \"Pakete werden als reine <2>Guile</2>-Module <1>definiert<1.1>de</1.1><1.2>Pakete-definieren.html</1.2></1>.\"\n"
msgstr ""
"#. TRADUTTORI: Defining Packages è un nome di sezione\n"
"#. nel manuale inglese (en).\n"
"#: apps/base/templates/about.scm:64\n"
"msgid \"Packages are <1>defined<1.1>en</1.1><1.2>Defining-Packages.html</1.2></1> as native <2>Guile</2> modules.\"\n"
"msgstr \"I pacchetti sono <1>definiti<1.1>it</1.1><1.2>Definizione-dei-pacchetti.html</1.2></1> come moduli nativi <2>Guile</2>.\"\n"

msgid "Note that you need to include the same markups.  You cannot skip any."
msgstr "Nota che devi includere gli stessi markup. Non puoi saltarne nessuno."

msgid "In case you make a mistake, the component might fail to build properly with your language, or even make guix pull fail.  To prevent that, we have a process in place to check the content of the files before pushing to our repository.  We will not be able to update the translation for your language in Guix, so we will notify you (through weblate and/or by email) so you get a chance to fix the issue."
msgstr "In caso di errore, il componente potrebbe non essere compilato correttamente con la tua lingua, o addirittura far fallire guix pull. Per prevenire ciò, abbiamo un processo per controllare il contenuto dei file prima di inviarli al nostro repository. Non saremo in grado di aggiornare la traduzione per la tua lingua in Guix, quindi ti notificheremo (tramite weblate e/o email) in modo che tu abbia la possibilità di risolvere il problema."

msgid "Outside of Weblate"
msgstr "Al di fuori di Weblate"

msgid "Currently, some parts of Guix cannot be translated on Weblate, help wanted!"
msgstr "Attualmente, alcune parti di Guix non possono essere tradotte su Weblate, cercasi aiuto!"

msgid "@command{guix pull} news can be translated in @file{news.scm}, but is not"
msgstr "Le notizie di @command{guix pull} possono essere tradotte in @file{news.scm}, ma non sono"

msgid "available from Weblate.  If you want to provide a translation, you can prepare a patch as described above, or simply send us your translation with the name of the news entry you translated and your language. @xref{Writing Channel News}, for more information about channel news."
msgstr "disponibili su Weblate. Se vuoi fornire una traduzione, puoi preparare una patch come descritto sopra, o semplicemente inviarci la tua traduzione con il nome della voce di notizie che hai tradotto e la tua lingua. @xref{Writing Channel News}, per maggiori informazioni sulle notizie del canale."

msgid "Guix blog posts cannot currently be translated."
msgstr "I post del blog di Guix attualmente non possono essere tradotti."

msgid "The installer script (for foreign distributions) is entirely in English."
msgstr "Lo script di installazione (per distribuzioni esterne) è interamente in inglese."

msgid "Some of the libraries Guix uses cannot be translated or are translated"
msgstr "Alcune delle librerie utilizzate da Guix non possono essere tradotte o sono tradotte"

msgid "outside of the Guix project.  Guile itself is not internationalized."
msgstr "al di fuori del progetto Guix. Guile stesso non è internazionalizzato."

msgid "Other manuals linked from this manual or the cookbook might not be"
msgstr "Altri manuali collegati da questo manuale o dal cookbook potrebbero non essere"

msgid "translated."
msgstr "tradotti."

msgid "Conditions for Inclusion"
msgstr "Condizioni per l'Inclusione"

msgid "There are no conditions for adding new translations of the @code{guix} and @code{guix-packages} components, other than they need at least one translated string.  New languages will be added to Guix as soon as possible.  The files may be removed if they fall out of sync and have no more translated strings."
msgstr "Non ci sono condizioni per aggiungere nuove traduzioni dei componenti @code{guix} e @code{guix-packages}, se non che devono avere almeno una stringa tradotta. Le nuove lingue verranno aggiunte a Guix il prima possibile. I file potrebbero essere rimossi se cadono fuori sincronizzazione e non hanno più stringhe tradotte."

msgid "Given that the web site is dedicated to new users, we want its translation to be as complete as possible before we include it in the language menu.  For a new language to be included, it needs to reach at least 80% completion.  When a language is included, it may be removed in the future if it stays out of sync and falls below 60% completion."
msgstr "Dato che il sito web è dedicato ai nuovi utenti, vogliamo che la sua traduzione sia il più completa possibile prima di includerla nel menu lingua. Affinché una nuova lingua venga inclusa, deve raggiungere almeno l'80% di completamento. Quando una lingua è inclusa, potrebbe essere rimossa in futuro se rimane fuori sincronizzazione e scende sotto il 60% di completamento."

msgid "The manual and cookbook are automatically added in the default compilation target.  Every time we synchronize translations, developers need to recompile all the translated manuals and cookbooks.  This is useless for what is essentially the English manual or cookbook.  Therefore, we will only include a new language when it reaches 10% completion in the component.  When a language is included, it may be removed in the future if it stays out of sync and falls below 5% completion."
msgstr "Il manuale e il cookbook vengono aggiunti automaticamente nel target di compilazione predefinito. Ogni volta che sincronizziamo le traduzioni, gli sviluppatori devono ricompilare tutti i manuali e i cookbook tradotti. Ciò è inutile per ciò che è essenzialmente il manuale o il cookbook inglese. Pertanto, includeremo una nuova lingua solo quando raggiunge il 10% di completamento nel componente. Quando una lingua è inclusa, potrebbe essere rimossa in futuro se rimane fuori sincronizzazione e scende sotto il 5% di completamento."

msgid "Translation Infrastructure"
msgstr "Infrastruttura di Traduzione"

msgid "Weblate is backed by a git repository from which it discovers new strings to translate and pushes new and updated translations.  Normally, it would be enough to give it commit access to our repositories.  However, we decided to use a separate repository for two reasons.  First, we would have to give Weblate commit access and authorize its signing key, but we do not trust it in the same way we trust guix developers, especially since we do not manage the instance ourselves.  Second, if translators mess something up, it can break the generation of the website and/or guix pull for all our users, independently of their language."
msgstr "Weblate è supportato da un repository git da cui scopre nuove stringhe da tradurre e invia nuove traduzioni e aggiornamenti. Normalmente, sarebbe sufficiente dargli accesso in commit ai nostri repository. Tuttavia, abbiamo deciso di utilizzare un repository separato per due motivi. Primo, dovremmo dare a Weblate l'accesso in commit e autorizzare la sua chiave di firma, ma non ci fidiamo di esso nello stesso modo in cui ci fidiamo degli sviluppatori di guix, specialmente poiché non gestiamo l'istanza noi stessi. Secondo, se i traduttori combinano pasticci, potrebbe interrompere la generazione del sito web e/o di guix pull per tutti i nostri utenti, indipendentemente dalla loro lingua."

msgid "For these reasons, we use a dedicated repository to host translations, and we synchronize it with our guix and artworks repositories after checking no issue was introduced in the translation."
msgstr "Per questi motivi, utilizziamo un repository dedicato per ospitare le traduzioni e lo sincronizziamo con i nostri repository guix e artworks dopo aver verificato che nessun problema sia stato introdotto nella traduzione."

msgid "Developers can download the latest PO files from weblate in the Guix repository by running the @command{make download-po} command.  It will automatically download the latest files from weblate, reformat them to a canonical form, and check they do not contain issues.  The manual needs to be built again to check for additional issues that might crash Texinfo."
msgstr "Gli sviluppatori possono scaricare i file PO più recenti da weblate nel repository Guix eseguendo il comando @command{make download-po}. Scaricherà automaticamente i file più recenti da weblate, li riformatterà in una forma canonica e controllerà che non contengano problemi. Il manuale deve essere ricostruito per verificare ulteriori problemi che potrebbero far crashare Texinfo."

msgid "Before pushing new translation files, developers should add them to the make machinery so the translations are actually available.  The process differs for the various components."
msgstr "Prima di inviare nuovi file di traduzione, gli sviluppatori dovrebbero aggiungerli alla meccanica make in modo che le traduzioni siano effettivamente disponibili. Il processo differisce per i vari componenti."

msgid "New po files for the @code{guix} and @code{packages} components must"
msgstr "I nuovi file po per i componenti @code{guix} e @code{packages} devono"

msgid "be registered by adding the new language to @file{po/guix/LINGUAS} or @file{po/packages/LINGUAS}."
msgstr "essere registrati aggiungendo la nuova lingua a @file{po/guix/LINGUAS} o @file{po/packages/LINGUAS}."

msgid "New po files for the @code{documentation-manual} component must be"
msgstr "I nuovi file po per il componente @code{documentation-manual} devono essere"

msgid "registered by adding the file name to @code{DOC_PO_FILES} in @file{po/doc/local.mk}, the generated @file{%D%/guix.xx.texi} manual to @code{info_TEXINFOS} in @file{doc/local.mk} and the generated @file{%D%/guix.xx.texi} and @file{%D%/contributing.xx.texi} to @code{TRANSLATED_INFO} also in @file{doc/local.mk}."
msgstr "registrati aggiungendo il nome del file a @code{DOC_PO_FILES} in @file{po/doc/local.mk}, il manuale generato @file{%D%/guix.xx.texi} a @code{info_TEXINFOS} in @file{doc/local.mk} e @file{%D%/guix.xx.texi} e @file{%D%/contributing.xx.texi} a @code{TRANSLATED_INFO} sempre in @file{doc/local.mk}."

msgid "New po files for the @code{documentation-cookbook} component must be"
msgstr "I nuovi file po per il componente @code{documentation-cookbook} devono essere"

msgid "registered by adding the file name to @code{DOC_COOKBOOK_PO_FILES} in @file{po/doc/local.mk}, the generated @file{%D%/guix-cookbook.xx.texi} manual to @code{info_TEXINFOS} in @file{doc/local.mk} and the generated @file{%D%/guix-cookbook.xx.texi} to @code{TRANSLATED_INFO} also in @file{doc/local.mk}."
msgstr "registrati aggiungendo il nome del file a @code{DOC_COOKBOOK_PO_FILES} in @file{po/doc/local.mk}, il manuale generato @file{%D%/guix-cookbook.xx.texi} a @code{info_TEXINFOS} in @file{doc/local.mk} e @file{%D%/guix-cookbook.xx.texi} a @code{TRANSLATED_INFO} sempre in @file{doc/local.mk}."

msgid "New po files for the @code{website} component must be added to the"
msgstr "I nuovi file po per il componente @code{website} devono essere aggiunti al"

msgid "@code{guix-artwork} repository, in @file{website/po/}.  @file{website/po/LINGUAS} and @file{website/po/ietf-tags.scm} must be updated accordingly (see @file{website/i18n-howto.txt} for more information on the process)."
msgstr "repository @code{guix-artwork}, in @file{website/po/}. @file{website/po/LINGUAS} e @file{website/po/ietf-tags.scm} devono essere aggiornati di conseguenza (vedi @file{website/i18n-howto.txt} per maggiori informazioni sul processo)."

msgid "infrastructure"
msgstr "infrastrutture"

msgid "Since its inception, the Guix project has always valued its autonomy, and that reflects in its infrastructure: our servers run Guix System and exclusively free software, and are administered by volunteers."
msgstr "Fin dalla sua creazione, il progetto Guix ha sempre valorizzato la sua autonomia, e questo si riflette nella sua infrastruttura: i nostri server eseguono Guix System e software esclusivamente libero, e sono amministrati da volontari."

msgid "Of course this comes at a cost and this is why we need contributions.  Our hope is to make infrastructure-related activity more legible so that maybe you can picture yourself helping in one of these areas."
msgstr "Naturalmente questo ha un costo ed è per questo che abbiamo bisogno di contributi. La nostra speranza è rendere più leggibili le attività relative all'infrastruttura in modo che forse tu possa immaginarti di aiutare in una di queste aree."

msgid "Day-to-Day System Administration"
msgstr "Amministrazione del Sistema Giornaliera"

msgid "On-Site Intervention"
msgstr "Intervento in Sito"

msgid "Administrative Tasks"
msgstr "Compiti Amministrativi"

msgid "The project runs many Guix-specific services; this is all lovely Scheme code but it tends to receive less attention than Guix itself:"
msgstr "Il progetto esegue molti servizi specifici di Guix; questo è tutto codice Scheme adorabile ma tende a ricevere meno attenzione di Guix stesso:"

msgid "@url{https://git.cbaines.net/guix/bffe, Build Farm Front End}"
msgstr "@url{https://git.cbaines.net/guix/bffe, Build Farm Front End}"

msgid "@url{https://codeberg.org/guix/cuirass/, Cuirass}"
msgstr "@url{https://codeberg.org/guix/cuirass/, Cuirass}"

msgid "@url{https://codeberg.org/guix/maintenance/src/branch/master/hydra/goggles.scm, Goggles} (IRC logger)"
msgstr "@url{https://codeberg.org/guix/maintenance/src/branch/master/hydra/goggles.scm, Goggles} (logger IRC)"

msgid "@url{https://codeberg.org/guix/build-coordinator, Guix Build Coordinator}"
msgstr "@url{https://codeberg.org/guix/build-coordinator, Guix Build Coordinator}"

msgid "@url{https://codeberg.org/luis-felipe/guix-packages-website, Guix Packages Website}"
msgstr "@url{https://codeberg.org/luis-felipe/guix-packages-website, Sito Web dei Pacchetti Guix}"

msgid "There is no time constraint on this coding activity: any improvement is welcome, whenever it comes.  Most of these code bases are relatively small, which should make it easier to get started."
msgstr "Non ci sono vincoli di tempo per questa attività di codifica: qualsiasi miglioramento è benvenuto, ogni volta che arriva. La maggior parte di queste basi di codice sono relativamente piccole, il che dovrebbe rendere più facile iniziare."

msgid "Prerequisites: Familiarity with Guile, HTTP, and databases."
msgstr "Prerequisiti: Familiarità con Guile, HTTP e database."

msgid "If you wish to get started, check out the README of the project of your choice and get in touch with guix-devel and the primary developer(s) of the tool as per @code{git shortlog -s | sort -k1 -n}."
msgstr "Se desideri iniziare, controlla il README del progetto di tua scelta e mettiti in contatto con guix-devel e lo/i sviluppatore/i principale/i dello strumento come da @code{git shortlog -s | sort -k1 -n}."

msgid "Guix System configuration for all our systems is held in this repository:"
msgstr "La configurazione di Guix System per tutti i nostri sistemi è contenuta in questo repository:"

msgid "The two front-ends are @file{berlin.scm} (the machine behind ci.guix.gnu.org)  and @file{bayfront.scm} (the machine behind bordeaux.guix.gnu.org, guix.gnu.org, hpc.guix.info, qa.guix.gnu.org, and more).  Both connect to a number of build machines and helpers."
msgstr "I due front-end sono @file{berlin.scm} (la macchina dietro ci.guix.gnu.org) e @file{bayfront.scm} (la macchina dietro bordeaux.guix.gnu.org, guix.gnu.org, hpc.guix.info, qa.guix.gnu.org e altro). Entrambi si connettono a una serie di macchine di compilazione e helper."

msgid "Without even having SSH access to the machine, you can help by posting patches to improve the configuration (you can test it with @code{guix system vm}).  Here are ways you can help:"
msgstr "Anche senza accesso SSH alla macchina, puoi aiutare inviando patch per migliorare la configurazione (puoi testarla con @code{guix system vm}). Ecco come puoi aiutare:"

msgid "Improve infra monitoring: set up a dashboard to monitor all the infrastructure, and an out-of-band channel to communicate about downtime."
msgstr "Migliorare il monitoraggio dell'infrastruttura: impostare una dashboard per monitorare tutta l'infrastruttura e un canale fuori banda per comunicare i tempi di inattività."

msgid "Implement web site redundancy: guix.gnu.org should be backed by several machines on different sites.  Get in touch with us and/or send a patch!"
msgstr "Implementare la ridondanza del sito web: guix.gnu.org dovrebbe essere supportato da diverse macchine su siti diversi. Mettiti in contatto con noi e/o invia una patch!"

msgid "Implement substitute redundancy: likewise, bordeaux.guix.gnu.org and ci.guix.gnu.org should be backed by several head nodes."
msgstr "Implementare la ridondanza dei sostituti: allo stesso modo, bordeaux.guix.gnu.org e ci.guix.gnu.org dovrebbero essere supportati da diversi nodi head."

msgid "Improve backup: there's currently ad-hoc backup of selected pieces over rsync between the two head nodes; we can improve on that, for example with a dedicated backup site and proper testing of recoverability."
msgstr "Migliorare il backup: attualmente c'è un backup ad-hoc di parti selezionate tramite rsync tra i due nodi head; possiamo migliorarlo, ad esempio con un sito di backup dedicato e un adeguato test di recuperabilità."

msgid "Support mirroring: We'd like to make it easy for others to mirror substitutes from ci.guix and bordeaux.guix, perhaps by offering public rsync access."
msgstr "Supportare il mirroring: vorremmo rendere facile per altri fare mirror dei sostituti da ci.guix e bordeaux.guix, magari offrendo accesso rsync pubblico."

msgid "Optimize our web services: Monitor the performance of our services and tweak nginx config or whatever it takes to improve it."
msgstr "Ottimizzare i nostri servizi web: monitorare le prestazioni dei nostri servizi e modificare la configurazione di nginx o qualsiasi cosa sia necessaria per migliorarla."

msgid "There is no time constraint on this activity: any improvement is welcome, whenever you can work on it."
msgstr "Non ci sono vincoli di tempo per questa attività: qualsiasi miglioramento è benvenuto, ogni volta che puoi lavorarci."

msgid "Prerequisite: Familiarity with Guix System administration and ideally with the infrastructure handbook:"
msgstr "Prerequisito: Familiarità con l'amministrazione di Guix System e idealmente con il manuale dell'infrastruttura:"

msgid "@url{https://codeberg.org/guix/maintenance.git/src/branch/master/doc/infra-handbook.org, Infra-Handbook}"
msgstr "@url{https://codeberg.org/guix/maintenance.git/src/branch/master/doc/infra-handbook.org, Infra-Handbook}"

msgid "We're also looking for people who'd be willing to have SSH access to some of the infrastructure to help with day-to-day maintenance: restarting a build, restarting the occasional service that has gone wild (that can happen), reconfiguring/upgrading a machine, rebooting, etc."
msgstr "Cerchiamo anche persone disposte ad avere accesso SSH ad alcune parti dell'infrastruttura per aiutare con la manutenzione giornaliera: riavviare una compilazione, riavviare il servizio occasionale che è impazzito (può succedere), riconfigurare/aggiornare una macchina, riavviare, ecc."

msgid "This day-to-day activity requires you to be available some of the time (during office hours or not, during the week-end or not), whenever is convenient for you, so you can react to issues reported on IRC, on the mailing list, or elsewhere, and synchronize with other sysadmins."
msgstr "Questa attività giornaliera richiede che tu sia disponibile in alcuni momenti (durante l'orario d'ufficio o meno, durante il fine settimana o meno), ogni volta che è conveniente per te, in modo da poter reagire ai problemi segnalati su IRC, sulla mailing list o altrove, e sincronizzarti con altri amministratori di sistema."

msgid "Prerequisite: Being a ``known'' member of the community, familiarity with Guix System administration, with some of the services/web sites being run, and with the infrastructure handbook:"
msgstr "Prerequisito: Essere un membro ``noto'' della comunità, familiarità con l'amministrazione di Guix System, con alcuni dei servizi/siti web in esecuzione e con il manuale dell'infrastruttura:"

msgid "The first front-end is currently generously hosted by the Max Delbrück Center (MDC), a research institute in Berlin, Germany. Only authorized personnel can physically access it."
msgstr "Il primo front-end è attualmente generosamente ospitato dal Max Delbrück Center (MDC), un istituto di ricerca a Berlino, Germania. Solo il personale autorizzato può accedervi fisicamente."

msgid "The second one, bordeaux.guix.gnu.org, is hosted in Bordeaux, France, in a professional data center shared with non-profit ISP Aquilenet.  If you live in the region of Bordeaux and would like to help out when we need to go on-site, please make yourself known by emailing @email{guix-sysadmin@@gnu.org}."
msgstr "Il secondo, bordeaux.guix.gnu.org, è ospitato a Bordeaux, Francia, in un data center professionale condiviso con l'ISP no-profit Aquilenet. Se vivi nella regione di Bordeaux e vorresti aiutare quando dobbiamo intervenire in sito, fatti conoscere inviando un'email a @email{guix-sysadmin@@gnu.org}."

msgid "On-site interventions are rare, but they're usually in response to an emergency."
msgstr "Gli interventi in sito sono rari, ma di solito sono in risposta a un'emergenza."

msgid "We're looking for people who can host machines and help out whenever physical access is needed.  More specifically:"
msgstr "Cerchiamo persone che possano ospitare macchine e aiutare ogni volta che è necessario l'accesso fisico. Più specificamente:"

msgid "We need hosting of ``small'' machines such as single-board computers (AArch64, RISC-V) for use as build machines."
msgstr "Abbiamo bisogno di ospitare macchine ``piccole'' come computer single-board (AArch64, RISC-V) per usarle come macchine di compilazione."

msgid "We need hosting for front-ends and x86_64 build machines in a data center where they can be racked and where, ideally, several local Guix sysadmins can physically access them."
msgstr "Abbiamo bisogno di ospitare front-end e macchine di compilazione x86_64 in un data center dove possono essere rackate e dove, idealmente, diversi amministratori di sistema Guix locali possono accedervi fisicamente."

msgid "The machines should be accessible over Wireguard VPN most of the time, so longer power or network interruptions should be the exception."
msgstr "Le macchine dovrebbero essere accessibili tramite VPN Wireguard la maggior parte del tempo, quindi interruzioni più lunghe di alimentazione o rete dovrebbero essere l'eccezione."

msgid "Prerequisites: Familiarity with installing and remotely administering Guix System."
msgstr "Prerequisiti: Familiarità con l'installazione e l'amministrazione remota di Guix System."

msgid "The infra remains up and running thanks to crucial administrative tasks, which includes:"
msgstr "L'infrastruttura rimane attiva e funzionante grazie a compiti amministrativi cruciali, che includono:"

msgid "Selecting and purchasing hardware, for example build machines."
msgstr "Selezionare e acquistare hardware, ad esempio macchine di compilazione."

msgid "Renewing domain names."
msgstr "Rinnovare i nomi di dominio."

msgid "Securing funding, in particular via the Guix Foundation: @url{https://foundation.guix.info, Guix Foundation}"
msgstr "Assicurare i finanziamenti, in particolare tramite la Guix Foundation: @url{https://foundation.guix.info, Guix Foundation}"

msgid "Prerequisites: Familiarity with hardware, and/or DNS registrars, and/or sponsorship, and/or crowdfunding."
msgstr "Prerequisiti: Familiarità con l'hardware e/o registrar DNS e/o sponsorizzazioni e/o crowdfunding."

msgid "@documentencoding UTF-8"
msgstr ""
"@documentencoding UTF-8\n"
"@documentlanguage it\n"
"@frenchspacing on"

msgid "GNU Guix Reference Manual"
msgstr "Manuale di riferimento di GNU Guix"

msgid "version.texi"
msgstr "version-it.texi"

msgid "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''."
msgstr "È concesso il permesso di copiare, distribuire e/o modificare questo documento secondo i termini della GNU Free Documentation License, Versione 1.3 o qualsiasi versione successiva pubblicata dalla Free Software Foundation; senza Sezioni Invarianti, senza Testi di Copertina e senza Testi di Retro copertina. Una copia della licenza è inclusa nella sezione intitolata \"Licenza di Documentazione Libera GNU\"."

msgid "System administration"
msgstr "Amministrazione di sistema"

msgid "Guix: (guix)"
msgstr "Guix.it: (guix.it)"

msgid "Manage installed software and system configuration."
msgstr "Gestisci il software installato e la configurazione del sistema."

msgid "guix package: (guix)Invoking guix package"
msgstr "guix package: (guix.it)Invocare guix package"

msgid "Installing, removing, and upgrading packages."
msgstr "Installazione, rimozione e aggiornamento dei pacchetti."

msgid "guix gc: (guix)Invoking guix gc"
msgstr "guix gc: (guix.it)Invocare guix gc"

msgid "Reclaiming unused disk space."
msgstr "Recupero dello spazio su disco non utilizzato."

msgid "guix pull: (guix)Invoking guix pull"
msgstr "guix pull: (guix.it)Invocare guix pull"

msgid "Update the list of available packages."
msgstr "Aggiorna l'elenco dei pacchetti disponibili."

msgid "guix system: (guix)Invoking guix system"
msgstr "guix system: (guix.it)Invocare guix system"

msgid "Manage the operating system configuration."
msgstr "Gestisci la configurazione del sistema operativo."

msgid "guix deploy: (guix)Invoking guix deploy"
msgstr "guix deploy: (guix.it)Invocare guix deploy"

msgid "Manage operating system configurations for remote hosts."
msgstr "Gestisci le configurazioni del sistema operativo per host remoti."

msgid "Software development"
msgstr "Sviluppo software"

msgid "guix shell: (guix)Invoking guix shell"
msgstr "guix shell: (guix.it)Invocare guix shell"

msgid "Creating software environments."
msgstr "Creazione di ambienti software."

msgid "guix environment: (guix)Invoking guix environment"
msgstr "guix environment: (guix.it)Invocare guix environment"

msgid "Building development environments with Guix."
msgstr "Costruire ambienti di sviluppo con Guix."

msgid "guix build: (guix)Invoking guix build"
msgstr "guix build: (guix.it)Invocare guix build"

msgid "Building packages."
msgstr "Compilazione di pacchetti."

msgid "guix pack: (guix)Invoking guix pack"
msgstr "guix pack: (guix.it)Invocare guix pack"

msgid "Creating binary bundles."
msgstr "Creazione di bundle binari."

msgid "Using the GNU Guix Functional Package Manager"
msgstr "Utilizzo del Gestore di Pacchetti Funzionale GNU Guix"

msgid "The GNU Guix Developers"
msgstr "Gli Sviluppatori di GNU Guix"

msgid "Edition @value{EDITION} @* @value{UPDATED} @*"
msgstr "Edizione @value{EDITION} @* @value{UPDATED} @*"

msgid "Top"
msgstr "Top"

msgid "GNU Guix"
msgstr "GNU Guix"

msgid "This document describes GNU Guix version @value{VERSION}, a functional package management tool written for the GNU system."
msgstr "Questo documento descrive GNU Guix versione @value{VERSION}, uno strumento funzionale di gestione dei pacchetti scritto per il sistema GNU."

msgid "This manual is also available in Simplified Chinese (@pxref{Top,,, guix.zh_CN, GNU Guix参考手册}), French (@pxref{Top,,, guix.fr, Manuel de référence de GNU Guix}), German (@pxref{Top,,, guix.de, Referenzhandbuch zu GNU Guix}), Spanish (@pxref{Top,,, guix.es, Manual de referencia de GNU Guix}), Italian (@pxref{Top,,, guix.it, Manuale di riferimento di GNU Guix}), Brazilian Portuguese (@pxref{Top,,, guix.pt_BR, Manual de referência do GNU Guix}), and Russian (@pxref{Top,,, guix.ru, Руководство GNU Guix}).  If you would like to translate it in your native language, consider joining @uref{https://translate.codeberg.org/projects/guix/documentation-manual, Weblate} (@pxref{Translating Guix})."
msgstr "Questo manuale è disponibile anche in inglese (@pxref{Top,,, guix, GNU Guix Reference Manual}), cinese semplificato (@pxref{Top,,, guix.zh_CN, GNU Guix参考手册}), francese (@pxref{Top,,, guix.fr, Manuel de référence de GNU Guix}), tedesco (@pxref{Top,,, guix.de, Referenzhandbuch zu GNU Guix}), spagnolo (@pxref{Top,,, guix.es, Manual de referencia de GNU Guix}), portoghese brasiliano (@pxref{Top,,, guix.pt_BR, Manual de referência do GNU Guix}) e russo (@pxref{Top,,, guix.ru, Руководство GNU Guix}). Se desideri tradurlo nella tua lingua madre, considera di unirti a @uref{https://translate.codeberg.org/projects/guix/documentation-manual, Weblate} (@pxref{Translating Guix})."

msgid "Introduction"
msgstr "Introduzione"

msgid "What is Guix about?"
msgstr "Di cosa tratta Guix?"

msgid "Installation"
msgstr "Installazione"

msgid "Installing Guix."
msgstr "Installazione di Guix."

msgid "System Installation"
msgstr "Installazione del Sistema"

msgid "Installing the whole operating system."
msgstr "Installazione dell'intero sistema operativo."

msgid "Getting Started"
msgstr "Per iniziare"

msgid "Your first steps."
msgstr "I tuoi primi passi."

msgid "Package Management"
msgstr "Gestione dei pacchetti"

msgid "Package installation, upgrade, etc."
msgstr "Installazione, aggiornamento, ecc. dei pacchetti."

msgid "Channels"
msgstr "Canali"

msgid "Customizing the package collection."
msgstr "Personalizzazione della collezione di pacchetti."

msgid "Development"
msgstr "Sviluppo"

msgid "Guix-aided software development."
msgstr "Sviluppo software assistito da Guix."

msgid "Programming Interface"
msgstr "Interfaccia di Programmazione"

msgid "Using Guix in Scheme."
msgstr "Utilizzo di Guix in Scheme."

msgid "Utilities"
msgstr "Utilità"

msgid "Package management commands."
msgstr "Comandi di gestione dei pacchetti."

msgid "Foreign Architectures"
msgstr "Architetture Estere"

msgid "Build for foreign architectures."
msgstr "Compilazione per architetture estere."

msgid "System Configuration"
msgstr "Configurazione di sistema"

msgid "Configuring the operating system."
msgstr "Configurazione del sistema operativo."

msgid "System Troubleshooting Tips"
msgstr "Suggerimenti per la Risoluzione dei Problemi del Sistema"

msgid "When things don't go as planned."
msgstr "Quando le cose non vanno come previsto."

msgid "Home Configuration"
msgstr "Configurazione della Home"

msgid "Configuring the home environment."
msgstr "Configurazione dell'ambiente home."

msgid "Documentation"
msgstr "Documentazione"

msgid "Browsing software user manuals."
msgstr "Navigazione nei manuali utente del software."

msgid "Platforms"
msgstr "Piattaforme"

msgid "Defining platforms."
msgstr "Definizione delle piattaforme."

msgid "System Images"
msgstr "Immagini di Sistema"

msgid "Creating system images."
msgstr "Creazione di immagini di sistema."

msgid "Installing Debugging Files"
msgstr "Installazione dei File di Debug"

msgid "Feeding the debugger."
msgstr "Alimentazione del debugger."

msgid "Using TeX and LaTeX"
msgstr "Utilizzo di TeX e LaTeX"

msgid "Typesetting."
msgstr "Composizione tipografica."

msgid "Security Updates"
msgstr "Aggiornamenti di sicurezza"

msgid "Deploying security fixes quickly."
msgstr "Distribuzione rapida delle correzioni di sicurezza."

msgid "Bootstrapping"
msgstr "Bootstrapping"

msgid "GNU/Linux built from scratch."
msgstr "GNU/Linux costruito da zero."

msgid "Porting"
msgstr "Porting"

msgid "Targeting another platform or kernel."
msgstr "Mirare a un'altra piattaforma o kernel."

msgid "Your help needed!"
msgstr "Il tuo aiuto è necessario!"

msgid "Acknowledgments"
msgstr "Ringraziamenti"

msgid "Thanks!"
msgstr "Grazie!"

msgid "GNU Free Documentation License"
msgstr "Licenza di Documentazione Libera GNU"

msgid "The license of this manual."
msgstr "La licenza di questo manuale."

msgid "Concept Index"
msgstr "Indice dei concetti"

msgid "Concepts."
msgstr "Concetti."

msgid "Programming Index"
msgstr "Indice di Programmazione"

msgid "Data types, functions, and variables."
msgstr "Tipi di dati, funzioni e variabili."

msgid "--- The Detailed Node Listing ---"
msgstr "--- L'Elenco Dettagliato dei Nodi ---"

msgid "Managing Software the Guix Way"
msgstr "Gestione del Software alla Maniera di Guix"

msgid "What's special."
msgstr "Cosa c'è di speciale."

msgid "GNU Distribution"
msgstr "Distribuzione GNU"

msgid "The packages and tools."
msgstr "I pacchetti e gli strumenti."

msgid "Binary Installation"
msgstr "Installazione binaria"

msgid "Getting Guix running in no time!"
msgstr "Fare funzionare Guix in pochissimo tempo!"

msgid "Setting Up the Daemon"
msgstr "Configurazione del demone"

msgid "Preparing the build daemon's environment."
msgstr "Preparazione dell'ambiente del demone di compilazione."

msgid "Invoking guix-daemon"
msgstr "Invocare guix-daemon"

msgid "Running the build daemon."
msgstr "Esecuzione del demone di compilazione."

msgid "Application Setup"
msgstr "Configurazione dell'applicazione"

msgid "Application-specific setup."
msgstr "Configurazione specifica dell'applicazione."

msgid "Upgrading Guix"
msgstr "Aggiornamento di Guix"

msgid "Upgrading Guix and its build daemon."
msgstr "Aggiornamento di Guix e del suo demone di compilazione."

msgid "Build Environment Setup"
msgstr "Configurazione dell'ambiente di build"

msgid "Preparing the isolated build environment."
msgstr "Preparazione dell'ambiente di compilazione isolato."

msgid "Daemon Offload Setup"
msgstr "Configurazione dello scarico del demone"

msgid "Offloading builds to remote machines."
msgstr "Scaricare le compilazioni su macchine remote."

msgid "SELinux Support"
msgstr "Supporto SELinux"

msgid "Using an SELinux policy for the daemon."
msgstr "Utilizzo di una politica SELinux per il demone."

msgid "Limitations"
msgstr "Limitazioni"

msgid "What you can expect."
msgstr "Cosa puoi aspettarti."

msgid "Hardware Considerations"
msgstr "Considerazioni sull'hardware"

msgid "Supported hardware."
msgstr "Hardware supportato."

msgid "USB Stick and DVD Installation"
msgstr "Installazione da chiavetta USB e DVD"

msgid "Preparing the installation medium."
msgstr "Preparazione del supporto di installazione."

msgid "Preparing for Installation"
msgstr "Preparazione all'installazione"

msgid "Networking, partitioning, etc."
msgstr "Rete, partizionamento, ecc."

msgid "Guided Graphical Installation"
msgstr "Installazione grafica guidata"

msgid "Easy graphical installation."
msgstr "Installazione grafica semplice."

msgid "Manual Installation"
msgstr "Installazione manuale"

msgid "Manual installation for wizards."
msgstr "Installazione manuale per maghi."

msgid "After System Installation"
msgstr "Dopo l'installazione del sistema"

msgid "When installation succeeded."
msgstr "Quando l'installazione è riuscita."

msgid "Installing Guix in a VM"
msgstr "Installare Guix in una VM"

msgid "Guix System playground."
msgstr "Area di prova per Guix System."

msgid "Building the Installation Image"
msgstr "Creare l'immagine di installazione"

msgid "How this comes to be."
msgstr "Come questo viene creato."

msgid "Keyboard Layout and Networking and Partitioning"
msgstr "Layout della tastiera e rete e partizionamento"

msgid "Initial setup."
msgstr "Configurazione iniziale."

msgid "Proceeding with the Installation"
msgstr "Procedere con l'installazione"

msgid "Installing."
msgstr "Installazione."

msgid "Features"
msgstr "Funzionalità"

msgid "How Guix will make your life brighter."
msgstr "Come Guix renderà la tua vita più luminosa."

msgid "Invoking guix package"
msgstr "Invocare guix package"

msgid "Package installation, removal, etc."
msgstr "Installazione, rimozione, ecc. dei pacchetti."

msgid "Substitutes"
msgstr "Sostituti"

msgid "Downloading pre-built binaries."
msgstr "Scaricare binari pre-compilati."

msgid "Packages with Multiple Outputs"
msgstr "Pacchetti con output multipli"

msgid "Single source package, multiple outputs."
msgstr "Singolo pacchetto sorgente, output multipli."

msgid "Invoking guix locate"
msgstr "Invocare guix locate"

msgid "Locating packages that provide a file."
msgstr "Trovare pacchetti che forniscono un file."

msgid "Invoking guix gc"
msgstr "Invocare guix gc"

msgid "Running the garbage collector."
msgstr "Eseguire il garbage collector."

msgid "Invoking guix pull"
msgstr "Invocare guix pull"

msgid "Fetching the latest Guix and distribution."
msgstr "Ottenere l'ultima versione di Guix e della distribuzione."

msgid "Invoking guix time-machine"
msgstr "Invocare guix time-machine"

msgid "Running an older revision of Guix."
msgstr "Eseguire una revisione precedente di Guix."

msgid "Inferiors"
msgstr "Inferiori"

msgid "Interacting with another revision of Guix."
msgstr "Interagire con un'altra revisione di Guix."

msgid "Invoking guix describe"
msgstr "Invocare guix describe"

msgid "Display information about your Guix revision."
msgstr "Mostrare informazioni sulla tua revisione di Guix."

msgid "Invoking guix archive"
msgstr "Invocare guix archive"

msgid "Exporting and importing store files."
msgstr "Esportare e importare file dallo store."

msgid "Official Substitute Servers"
msgstr "Server di sostituti ufficiali"

msgid "One particular source of substitutes."
msgstr "Una fonte particolare di sostituti."

msgid "Substitute Server Authorization"
msgstr "Autorizzazione del server di sostituti"

msgid "How to enable or disable substitutes."
msgstr "Come abilitare o disabilitare i sostituti."

msgid "Getting Substitutes from Other Servers"
msgstr "Ottenere sostituti da altri server"

msgid "Substitute diversity."
msgstr "Diversità dei sostituti."

msgid "Substitute Authentication"
msgstr "Autenticazione dei sostituti"

msgid "How Guix verifies substitutes."
msgstr "Come Guix verifica i sostituti."

msgid "Proxy Settings"
msgstr "Impostazioni proxy"

msgid "How to get substitutes via proxy."
msgstr "Come ottenere sostituti tramite proxy."

msgid "Substitution Failure"
msgstr "Fallimento della sostituzione"

msgid "What happens when substitution fails."
msgstr "Cosa succede quando la sostituzione fallisce."

msgid "On Trusting Binaries"
msgstr "Sulla fiducia nei binari"

msgid "How can you trust that binary blob?"
msgstr "Come puoi fidarti di quel blob binario?"

msgid "Specifying Additional Channels"
msgstr "Specificare canali aggiuntivi"

msgid "Extending the package collection."
msgstr "Estendere la collezione di pacchetti."

msgid "Using a Custom Guix Channel"
msgstr "Usare un canale Guix personalizzato"

msgid "Using a customized Guix."
msgstr "Usare un Guix personalizzato."

msgid "Replicating Guix"
msgstr "Replicare Guix"

msgid "Running the @emph{exact same} Guix."
msgstr "Eseguire l'@emph{esatto stesso} Guix."

msgid "Customizing the System-Wide Guix"
msgstr "Personalizzare il Guix di sistema"

msgid "Default channels on Guix System."
msgstr "Canali predefiniti su Guix System."

msgid "Channel Authentication"
msgstr "Autenticazione dei canali"

msgid "How Guix verifies what it fetches."
msgstr "Come Guix verifica ciò che scarica."

msgid "Channels with Substitutes"
msgstr "Canali con sostituti"

msgid "Using channels with available substitutes."
msgstr "Usare canali con sostituti disponibili."

msgid "Creating a Channel"
msgstr "Creare un canale"

msgid "How to write your custom channel."
msgstr "Come scrivere il tuo canale personalizzato."

msgid "Package Modules in a Sub-directory"
msgstr "Moduli di pacchetti in una sottocartella"

msgid "Specifying the channel's package modules location."
msgstr "Specificare la posizione dei moduli dei pacchetti del canale."

msgid "Declaring Channel Dependencies"
msgstr "Dichiarare le dipendenze dei canali"

msgid "How to depend on other channels."
msgstr "Come dipendere da altri canali."

msgid "Specifying Channel Authorizations"
msgstr "Specificare le autorizzazioni dei canali"

msgid "Defining channel authors authorizations."
msgstr "Definire le autorizzazioni degli autori dei canali."

msgid "Primary URL"
msgstr "URL primario"

msgid "Distinguishing mirror to original."
msgstr "Distinguere il mirror dall'originale."

msgid "Writing Channel News"
msgstr "Scrivere le novità del canale"

msgid "Communicating information to channel's users."
msgstr "Comunicare informazioni agli utenti del canale."

msgid "Invoking guix shell"
msgstr "Invocare guix shell"

msgid "Spawning one-off software environments."
msgstr "Generare ambienti software temporanei."

msgid "Invoking guix environment"
msgstr "Invocare guix environment"

msgid "Setting up development environments."
msgstr "Impostare ambienti di sviluppo."

msgid "Invoking guix pack"
msgstr "Invocare guix pack"

msgid "Creating software bundles."
msgstr "Creare pacchetti software."

msgid "The GCC toolchain"
msgstr "La toolchain GCC"

msgid "Working with languages supported by GCC."
msgstr "Lavorare con i linguaggi supportati da GCC."

msgid "Invoking guix git authenticate"
msgstr "Invocare guix git authenticate"

msgid "Authenticating Git repositories."
msgstr "Autenticare i repository Git."

msgid "Package Modules"
msgstr "Moduli di pacchetti"

msgid "Packages from the programmer's viewpoint."
msgstr "Pacchetti dal punto di vista del programmatore."

msgid "Defining Packages"
msgstr "Definire i pacchetti"

msgid "Defining new packages."
msgstr "Definire nuovi pacchetti."

msgid "Defining Package Variants"
msgstr "Definire varianti di pacchetto"

msgid "Customizing packages."
msgstr "Personalizzare i pacchetti."

msgid "Writing Manifests"
msgstr "Scrivere manifesti"

msgid "The bill of materials of your environment."
msgstr "L'elenco dei materiali del tuo ambiente."

msgid "Build Systems"
msgstr "Sistemi di build"

msgid "Specifying how packages are built."
msgstr "Specificare come vengono compilati i pacchetti."

msgid "Build Phases"
msgstr "Fasi di build"

msgid "Phases of the build process of a package."
msgstr "Fasi del processo di build di un pacchetto."

msgid "Build Utilities"
msgstr "Utilità di build"

msgid "Helpers for your package definitions and more."
msgstr "Aiuti per le definizioni dei tuoi pacchetti e altro."

msgid "Search Paths"
msgstr "Percorsi di ricerca"

msgid "Declaring search path environment variables."
msgstr "Dichiarare le variabili d'ambiente dei percorsi di ricerca."

msgid "The Store"
msgstr "Lo store"

msgid "Manipulating the package store."
msgstr "Manipolare lo store dei pacchetti."

msgid "Derivations"
msgstr "Derivazioni"

msgid "Low-level interface to package derivations."
msgstr "Interfaccia a basso livello per le derivazioni dei pacchetti."

msgid "The Store Monad"
msgstr "La monade dello store"

msgid "Purely functional interface to the store."
msgstr "Interfaccia puramente funzionale allo store."

msgid "G-Expressions"
msgstr "G-expression"

msgid "Manipulating build expressions."
msgstr "Manipolare le espressioni di build."

msgid "Invoking guix repl"
msgstr "Invocare guix repl"

msgid "Programming Guix in Guile"
msgstr "Programmare Guix in Guile"

msgid "Using Guix Interactively"
msgstr "Usare Guix interattivamente"

msgid "Fine-grain interaction at the REPL."
msgstr "Interazione a grana fine nella REPL."

msgid "package Reference"
msgstr "Riferimenti per 'package'"

msgid "The package data type."
msgstr "Il tipo di dato 'package'."

msgid "origin Reference"
msgstr "Riferimenti per 'origin'"

msgid "The origin data type."
msgstr "Il tipo di dato 'origin'."

msgid "Invoking guix build"
msgstr "Invocare guix build"

msgid "Building packages from the command line."
msgstr "Compilare pacchetti da riga di comando."

msgid "Invoking guix edit"
msgstr "Invocare guix edit"

msgid "Editing package definitions."
msgstr "Modificare le definizioni dei pacchetti."

msgid "Invoking guix download"
msgstr "Invocare guix download"

msgid "Downloading a file and printing its hash."
msgstr "Scaricare un file e stamparne l'hash."

msgid "Invoking guix hash"
msgstr "Invocare guix hash"

msgid "Computing the cryptographic hash of a file."
msgstr "Calcolare l'hash crittografico di un file."

msgid "Invoking guix import"
msgstr "Invocare guix import"

msgid "Importing package definitions."
msgstr "Importare le definizioni dei pacchetti."

msgid "Invoking guix refresh"
msgstr "Invocare guix refresh"

msgid "Updating package definitions."
msgstr "Aggiornare le definizioni dei pacchetti."

msgid "Invoking guix style"
msgstr "Invocare guix style"

msgid "Invoking guix lint"
msgstr "Invocare guix lint"

msgid "Finding errors in package definitions."
msgstr "Trovare errori nelle definizioni dei pacchetti."

msgid "Invoking guix size"
msgstr "Invocare guix size"

msgid "Profiling disk usage."
msgstr "Profilare l'uso del disco."

msgid "Invoking guix graph"
msgstr "Invocare guix graph"

msgid "Visualizing the graph of packages."
msgstr "Visualizzare il grafico dei pacchetti."

msgid "Invoking guix publish"
msgstr "Invocare guix publish"

msgid "Sharing substitutes."
msgstr "Condividere sostituti."

msgid "Invoking guix challenge"
msgstr "Invocare guix challenge"

msgid "Challenging substitute servers."
msgstr "Sfidare i server di sostituti."

msgid "Invoking guix copy"
msgstr "Invocare guix copy"

msgid "Copying to and from a remote store."
msgstr "Copiare da e verso uno store remoto."

msgid "Invoking guix container"
msgstr "Invocare guix container"

msgid "Process isolation."
msgstr "Isolamento dei processi."

msgid "Invoking guix weather"
msgstr "Invocare guix weather"

msgid "Assessing substitute availability."
msgstr "Valutare la disponibilità dei sostituti."

msgid "Invoking guix processes"
msgstr "Invocare guix processes"

msgid "Listing client processes."
msgstr "Elencare i processi client."

msgid "Invoking @command{guix build}"
msgstr "Invocare @command{guix build}"

msgid "Common Build Options"
msgstr "Opzioni di build comuni"

msgid "Build options for most commands."
msgstr "Opzioni di build per la maggior parte dei comandi."

msgid "Package Transformation Options"
msgstr "Opzioni di trasformazione dei pacchetti"

msgid "Creating variants of packages."
msgstr "Creare varianti di pacchetti."

msgid "Additional Build Options"
msgstr "Opzioni di build aggiuntive"

msgid "Options specific to 'guix build'."
msgstr "Opzioni specifiche per 'guix build'."

msgid "Debugging Build Failures"
msgstr "Debug dei fallimenti di build"

msgid "Real life packaging experience."
msgstr "Esperienza di pacchettizzazione nella vita reale."

msgid "Cross-Compilation"
msgstr "Compilazione incrociata"

msgid "Cross-compiling for another architecture."
msgstr "Compilazione incrociata per un'altra architettura."

msgid "Native Builds"
msgstr "Build nativi"

msgid "Targeting another architecture through native builds."
msgstr "Mirare a un'altra architettura tramite build nativi."

msgid "Getting Started with the System"
msgstr "Primi passi con il sistema"

msgid "Using the Configuration System"
msgstr "Usare il sistema di configurazione"

msgid "Customizing your GNU system."
msgstr "Personalizzare il tuo sistema GNU."

msgid "operating-system Reference"
msgstr "Riferimenti per 'operating-system'"

msgid "Detail of operating-system declarations."
msgstr "Dettagli sulle dichiarazioni di operating-system."

msgid "File Systems"
msgstr "Filesystem"

msgid "Configuring file system mounts."
msgstr "Configurare i mount del file system."

msgid "Mapped Devices"
msgstr "Dispositivi mappati"

msgid "Block device extra processing."
msgstr "Elaborazione extra dei dispositivi a blocchi."

msgid "Swap Space"
msgstr "Spazio di swap"

msgid "Backing RAM with disk space."
msgstr "Supportare la RAM con spazio su disco."

msgid "User Accounts"
msgstr "Account utente"

msgid "Specifying user accounts."
msgstr "Specificare gli account utente."

msgid "Keyboard Layout"
msgstr "Layout della tastiera"

msgid "How the system interprets key strokes."
msgstr "Come il sistema interpreta la pressione dei tasti."

msgid "Locales"
msgstr "Lingue"

msgid "Language and cultural convention settings."
msgstr "Impostazioni di lingua e convenzioni culturali."

msgid "Specifying system services."
msgstr "Specificare i servizi di sistema."

msgid "Privileged Programs"
msgstr "Programmi privilegiati"

msgid "Programs running with elevated privileges."
msgstr "Programmi eseguiti con privilegi elevati."

msgid "X.509 Certificates"
msgstr "Certificati X.509"

msgid "Authenticating HTTPS servers."
msgstr "Autenticazione dei server HTTPS."

msgid "Name Service Switch"
msgstr "Name Service Switch"

msgid "Configuring libc's name service switch."
msgstr "Configurare il name service switch della libc."

msgid "Initial RAM Disk"
msgstr "Disco RAM iniziale"

msgid "Linux-Libre bootstrapping."
msgstr "Bootstrap di Linux-Libre."

msgid "Bootloader Configuration"
msgstr "Configurazione del bootloader"

msgid "Configuring the boot loader."
msgstr "Configurare il boot loader."

msgid "Invoking guix system"
msgstr "Invocare guix system"

msgid "Instantiating a system configuration."
msgstr "Instanziare una configurazione di sistema."

msgid "Invoking guix deploy"
msgstr "Invocare guix deploy"

msgid "Deploying a system configuration to a remote host."
msgstr "Distribuire una configurazione di sistema su un host remoto."

msgid "Running Guix in a VM"
msgstr "Eseguire Guix in una VM"

msgid "How to run Guix System in a virtual machine."
msgstr "Come eseguire Guix System in una macchina virtuale."

msgid "Defining Services"
msgstr "Definire i servizi"

msgid "Adding new service definitions."
msgstr "Aggiungere nuove definizioni di servizi."

msgid "Btrfs file system"
msgstr "File system Btrfs"

msgid "Base Services"
msgstr "Servizi di base"

msgid "Essential system services."
msgstr "Servizi di sistema essenziali."

msgid "Scheduled Job Execution"
msgstr "Esecuzione di lavori pianificati"

msgid "The mcron service."
msgstr "Il servizio mcron."

msgid "Log Rotation"
msgstr "Rotazione dei log"

msgid "Archiving and deleting old logs."
msgstr "Archiviazione ed eliminazione dei vecchi log."

msgid "Setting up network interfaces."
msgstr "Impostazione delle interfacce di rete."

msgid "Networking Services"
msgstr "Servizi di rete"

msgid "Firewall, SSH daemon, etc."
msgstr "Firewall, demone SSH, ecc."

msgid "Unattended Upgrades"
msgstr "Aggiornamenti non presidiati"

msgid "Automated system upgrades."
msgstr "Aggiornamenti di sistema automatici."

msgid "X Window"
msgstr "X Window"

msgid "Graphical display."
msgstr "Schermo grafico."

msgid "Printing Services"
msgstr "Servizi di stampa"

msgid "Local and remote printer support."
msgstr "Supporto per stampanti locali e remote."

msgid "Desktop Services"
msgstr "Servizi desktop"

msgid "D-Bus and desktop services."
msgstr "D-Bus e servizi desktop."

msgid "Sound Services"
msgstr "Servizi suono"

msgid "ALSA and Pulseaudio services."
msgstr "Servizi ALSA e Pulseaudio."

msgid "Tools to search for files."
msgstr "Strumenti per cercare file."

msgid "Database Services"
msgstr "Servizi di database"

msgid "SQL databases, key-value stores, etc."
msgstr "Database SQL, archivi chiave-valore, ecc."

msgid "Mail Services"
msgstr "Servizi di posta"

msgid "IMAP, POP3, SMTP, and all that."
msgstr "IMAP, POP3, SMTP e tutto il resto."

msgid "Messaging Services"
msgstr "Servizi di messaggistica"

msgid "Messaging services."
msgstr "Servizi di messaggistica."

msgid "Telephony Services"
msgstr "Servizi di telefonia"

msgid "Telephony services."
msgstr "Servizi di telefonia."

msgid "File-Sharing Services"
msgstr "Servizi di condivisione file"

msgid "File-sharing services."
msgstr "Servizi di condivisione file."

msgid "Monitoring Services"
msgstr "Servizi di monitoraggio"

msgid "Monitoring services."
msgstr "Servizi di monitoraggio."

msgid "Kerberos Services"
msgstr "Servizi Kerberos"

msgid "Kerberos services."
msgstr "Servizi Kerberos."

msgid "LDAP Services"
msgstr "Servizi LDAP"

msgid "LDAP services."
msgstr "Servizi LDAP."

msgid "Web Services"
msgstr "Servizi web"

msgid "Web servers."
msgstr "Server web."

msgid "Certificate Services"
msgstr "Servizi di certificati"

msgid "TLS certificates via Let's Encrypt."
msgstr "Certificati TLS tramite Let's Encrypt."

msgid "DNS Services"
msgstr "Servizi DNS"

msgid "DNS daemons."
msgstr "Demoni DNS."

msgid "VNC daemons."
msgstr "Demoni VNC."

msgid "VPN Services"
msgstr "Servizi VPN"

msgid "VPN daemons."
msgstr "Demoni VPN."

msgid "Network File System"
msgstr "Filesystem di rete"

msgid "NFS related services."
msgstr "Servizi correlati a NFS."

msgid "Samba services."
msgstr "Servizi Samba."

msgid "Continuous Integration"
msgstr "Integrazione continua"

msgid "Cuirass and Laminar services."
msgstr "Servizi Cuirass e Laminar."

msgid "Power Management Services"
msgstr "Servizi di gestione energetica"

msgid "Extending battery life, etc."
msgstr "Estendere la durata della batteria, ecc."

msgid "Audio Services"
msgstr "Servizi audio"

msgid "The MPD."
msgstr "L'MPD."

msgid "Virtualization Services"
msgstr "Servizi di virtualizzazione"

msgid "Virtualization services."
msgstr "Servizi di virtualizzazione."

msgid "Version Control Services"
msgstr "Servizi di controllo versione"

msgid "Game Services"
msgstr "Servizi di gioco"

msgid "Game servers."
msgstr "Server di gioco."

msgid "PAM Mount Service"
msgstr "Servizio PAM Mount"

msgid "Service to mount volumes when logging in."
msgstr "Servizio per montare volumi al momento del login."

msgid "Guix Services"
msgstr "Servizi Guix"

msgid "Services relating specifically to Guix."
msgstr "Servizi relativi specificamente a Guix."

msgid "Linux Services"
msgstr "Servizi Linux"

msgid "Services tied to the Linux kernel."
msgstr "Servizi legati al kernel Linux."

msgid "Hurd Services"
msgstr "Servizi Hurd"

msgid "Services specific for a Hurd System."
msgstr "Servizi specifici per un sistema Hurd."

msgid "Miscellaneous Services"
msgstr "Servizi vari"

msgid "Other services."
msgstr "Altri servizi."

msgid "Service Composition"
msgstr "Composizione dei servizi"

msgid "The model for composing services."
msgstr "Il modello per la composizione dei servizi."

msgid "Service Types and Services"
msgstr "Tipi di servizio e servizi"

msgid "Types and services."
msgstr "Tipi e servizi."

msgid "Service Reference"
msgstr "Riferimenti per i servizi"

msgid "API reference."
msgstr "Riferimenti API."

msgid "Shepherd Services"
msgstr "Servizi Shepherd"

msgid "A particular type of service."
msgstr "Un tipo particolare di servizio."

msgid "Defining bindings for complex configurations."
msgstr "Definire collegamenti per configurazioni complesse."

msgid "Chrooting into an existing system"
msgstr "Fare chroot in un sistema esistente"

msgid "Declaring the Home Environment"
msgstr "Dichiarare l'ambiente home"

msgid "Customizing your Home."
msgstr "Personalizzare la tua home."

msgid "Configuring the Shell"
msgstr "Configurare la shell"

msgid "Enabling home environment."
msgstr "Abilitare l'ambiente home."

msgid "Specifying home services."
msgstr "Specificare i servizi home."

msgid "Invoking guix home"
msgstr "Invocare guix home"

msgid "Instantiating a home configuration."
msgstr "Instanziare una configurazione home."

msgid "Environment variables, packages, on-* scripts."
msgstr "Variabili d'ambiente, pacchetti, script on-*."

msgid "Shells: Shells Home Services"
msgstr "Shell: Servizi Home per le Shell"

msgid "POSIX shells, Bash, Zsh."
msgstr "Shell POSIX, Bash, Zsh."

msgid "Mcron: Mcron Home Service"
msgstr "Mcron: Servizio Home Mcron"

msgid "Scheduled User's Job Execution."
msgstr "Esecuzione pianificata di lavori dell'utente."

msgid "Power Management: Power Management Home Services"
msgstr "Gestione energetica: Servizi Home di gestione energetica"

msgid "Services for battery power."
msgstr "Servizi per l'alimentazione a batteria."

msgid "Shepherd: Shepherd Home Service"
msgstr "Shepherd: Servizio Home Shepherd"

msgid "Managing User's Daemons."
msgstr "Gestione dei demoni dell'utente."

msgid "SSH: Secure Shell"
msgstr "SSH: Secure Shell"

msgid "Setting up the secure shell client."
msgstr "Impostazione del client secure shell."

msgid "GPG: GNU Privacy Guard"
msgstr "GPG: GNU Privacy Guard"

msgid "Setting up GPG and related tools."
msgstr "Impostazione di GPG e strumenti correlati."

msgid "Services for graphical environments."
msgstr "Servizi per ambienti grafici."

msgid "Services for Guix."
msgstr "Servizi per Guix."

msgid "Services for managing User's fonts."
msgstr "Servizi per gestire i font dell'utente."

msgid "Dealing with audio."
msgstr "Gestione dell'audio."

msgid "Services for managing mail."
msgstr "Servizi per gestire la posta."

msgid "Services for managing messaging."
msgstr "Servizi per gestire la messaggistica."

msgid "Services for managing media."
msgstr "Servizi per gestire supporti e media."

msgid "Sway: Sway window manager"
msgstr "Sway: Window manager Sway"

msgid "Networking services."
msgstr "Servizi di rete."

msgid "More services."
msgstr "Altri servizi."

msgid "platform Reference"
msgstr "Riferimenti per 'platform'"

msgid "Detail of platform declarations."
msgstr "Dettagli sulle dichiarazioni di piattaforma."

msgid "Supported Platforms"
msgstr "Piattaforme supportate"

msgid "Description of the supported platforms."
msgstr "Descrizione delle piattaforme supportate."

msgid "Creating System Images"
msgstr "Creare immagini di sistema"

msgid "image Reference"
msgstr "Riferimenti per 'image'"

msgid "Detail of image declarations."
msgstr "Dettagli sulle dichiarazioni di immagine."

msgid "Instantiate an Image"
msgstr "Instanziare un'immagine"

msgid "How to instantiate an image record."
msgstr "Come instanziare un record di immagine."

msgid "image-type Reference"
msgstr "Riferimenti per 'image-type'"

msgid "Detail of image types declaration."
msgstr "Dettagli sulla dichiarazione dei tipi di immagine."

msgid "Definition of image modules."
msgstr "Definizione dei moduli di immagine."

msgid "@code{image} Reference"
msgstr "Riferimenti per @code{image}"

msgid "partition Reference"
msgstr "Riferimenti per 'partition'"

msgid "Separate Debug Info"
msgstr "Informazioni di debug separate"

msgid "Installing 'debug' outputs."
msgstr "Installare output di 'debug'."

msgid "Rebuilding Debug Info"
msgstr "Ricompilare le informazioni di debug"

msgid "Building missing debug info."
msgstr "Compilare le informazioni di debug mancanti."

msgid "Full-Source Bootstrap"
msgstr "Bootstrap completo da sorgente"

msgid "A Bootstrap worthy of GNU."
msgstr "Un bootstrap degno di GNU."

msgid "Preparing to Use the Bootstrap Binaries"
msgstr "Preparazione all'uso dei binari di bootstrap"

msgid "Building that what matters most."
msgstr "Compilare ciò che conta di più."

msgid "purpose"
msgstr "scopo"

msgid "GNU Guix@footnote{``Guix'' is pronounced like ``geeks'', or ``ɡiːks'' using the international phonetic alphabet (IPA).} is a package management tool for and distribution of the GNU system.  Guix makes it easy for unprivileged users to install, upgrade, or remove software packages, to roll back to a previous package set, to build packages from source, and generally assists with the creation and maintenance of software environments."
msgstr "GNU Guix@footnote{``Guix'' si pronuncia come «ghiks», o «ɡiːks» usando l'alfabeto fonetico internazionale (IPA).} è uno strumento di gestione dei pacchetti e una distribuzione del sistema GNU. Guix rende facile per gli utenti non privilegiati installare, aggiornare o rimuovere pacchetti software, tornare a un insieme di pacchetti precedente, compilare pacchetti dai sorgenti, e in generale assiste con la creazione e la manutenzione di ambienti software."

msgid "Guix System"
msgstr "Guix System"

msgid "GuixSD, now Guix System"
msgstr "GuixSD, ora Guix System"

msgid "Guix System Distribution, now Guix System"
msgstr "Guix System Distribution, ora Guix System"

msgid "You can install GNU@tie{}Guix on top of an existing GNU/Linux system where it complements the available tools without interference (@pxref{Installation}), or you can use it as a standalone operating system distribution, @dfn{Guix@tie{}System}@footnote{We used to refer to Guix System as ``Guix System Distribution'' or ``GuixSD''.  We now consider it makes more sense to group everything under the ``Guix'' banner since, after all, Guix System is readily available through the @command{guix system} command, even if you're using a different distro underneath!}.  @xref{GNU Distribution}."
msgstr "È possibile installare GNU@tie{}Guix su un sistema GNU/Linux esistente, dove completa gli strumenti disponibili senza interferenze (@pxref{Installation}), oppure si può usare come una distribuzione di sistema operativo autonoma, @dfn{Guix@tie{}System}@footnote{In passato ci riferivamo a Guix System come ``Guix System Distribution'' o ``GuixSD''. Ora riteniamo che abbia più senso raggruppare tutto sotto l'insegna di ``Guix'' poiché, dopotutto, Guix System è prontamente disponibile tramite il comando @command{guix system}, anche se si sta usando una distro diversa sotto!}. @xref{GNU Distribution}."

msgid "user interfaces"
msgstr "interfacce utente"

msgid "Guix provides a command-line package management interface (@pxref{Package Management}), tools to help with software development (@pxref{Development}), command-line utilities for more advanced usage (@pxref{Utilities}), as well as Scheme programming interfaces (@pxref{Programming Interface})."
msgstr "Guix fornisce un'interfaccia di gestione dei pacchetti da riga di comando (@pxref{Package Management}), strumenti per aiutare nello sviluppo software (@pxref{Development}), utilità da riga di comando per un uso più avanzato (@pxref{Utilities}), così come interfacce di programmazione Scheme (@pxref{Programming Interface})."

msgid "build daemon"
msgstr "demone di build"

msgid "Its @dfn{build daemon} is responsible for building packages on behalf of users (@pxref{Setting Up the Daemon}) and for downloading pre-built binaries from authorized sources (@pxref{Substitutes})."
msgstr "Il suo @dfn{demone di build} è responsabile della compilazione dei pacchetti per conto degli utenti (@pxref{Setting Up the Daemon}) e dello scaricamento di binari precompilati da fonti autorizzate (@pxref{Substitutes})."

msgid "extensibility of the distribution"
msgstr "estensibilità della distribuzione"

msgid "customization, of packages"
msgstr "personalizzazione, dei pacchetti"

msgid "Guix includes package definitions for many GNU and non-GNU packages, all of which @uref{https://www.gnu.org/philosophy/free-sw.html, respect the user's computing freedom}.  It is @emph{extensible}: users can write their own package definitions (@pxref{Defining Packages}) and make them available as independent package modules (@pxref{Package Modules}).  It is also @emph{customizable}: users can @emph{derive} specialized package definitions from existing ones, including from the command line (@pxref{Package Transformation Options})."
msgstr "Guix include definizioni di pacchetti per molti pacchetti GNU e non-GNU, tutti i quali @uref{https://www.gnu.org/philosophy/free-sw.html, rispettano la libertà informatica dell'utente}. È @emph{estensibile}: gli utenti possono scrivere le proprie definizioni di pacchetto (@pxref{Defining Packages}) e renderle disponibili come moduli di pacchetti indipendenti (@pxref{Package Modules}). È anche @emph{customizable}: gli utenti possono @emph{derivare} definizioni di pacchetti specializzate da quelle esistenti, anche da riga di comando (@pxref{Package Transformation Options})."

msgid "functional package management"
msgstr "gestione funzionale dei pacchetti"

msgid "isolation"
msgstr "isolamento"

msgid "Under the hood, Guix implements the @dfn{functional package management} discipline pioneered by Nix (@pxref{Acknowledgments}).  In Guix, the package build and installation process is seen as a @emph{function}, in the mathematical sense.  That function takes inputs, such as build scripts, a compiler, and libraries, and returns an installed package.  As a pure function, its result depends solely on its inputs---for instance, it cannot refer to software or scripts that were not explicitly passed as inputs.  A build function always produces the same result when passed a given set of inputs.  It cannot alter the environment of the running system in any way; for instance, it cannot create, modify, or delete files outside of its build and installation directories.  This is achieved by running build processes in isolated environments (or @dfn{containers}), where only their explicit inputs are visible."
msgstr "Sotto il cofano, Guix implementa la disciplina di @dfn{gestione funzionale dei pacchetti} introdotta da Nix (@pxref{Acknowledgments}). In Guix, il processo di build e installazione di un pacchetto è visto come una @emph{funzione}, nel senso matematico. Tale funzione prende degli input, come script di build, un compilatore e delle librerie, e restituisce un pacchetto installato. Come funzione pura, il suo risultato dipende unicamente dai suoi input - ad esempio, non può fare riferimento a software o script che non sono stati passati esplicitamente come input. Una funzione di build produce sempre lo stesso risultato quando le viene fornito un dato insieme di input. Non può alterare in alcun modo l'ambiente del sistema in esecuzione; ad esempio, non può creare, modificare o eliminare file al di fuori delle sue directory di build e installazione. Questo si ottiene eseguendo i processi di build in ambienti isolati (o @dfn{containers}), dove sono visibili solo i loro input espliciti."

msgid "store"
msgstr "store"

msgid "The result of package build functions is @dfn{cached} in the file system, in a special directory called @dfn{the store} (@pxref{The Store}).  Each package is installed in a directory of its own in the store---by default under @file{/gnu/store}.  The directory name contains a hash of all the inputs used to build that package; thus, changing an input yields a different directory name."
msgstr "Il risultato delle funzioni di build dei pacchetti viene @dfn{cached} nel file system, in una directory speciale chiamata @dfn{lo store} (@pxref{The Store}). Ogni pacchetto è installato in una propria directory nello store - per impostazione predefinita sotto @file{/gnu/store}. Il nome della directory contiene un hash di tutti gli input usati per compilare quel pacchetto; quindi, cambiare un input produce un nome di directory diverso."

msgid "This approach is the foundation for the salient features of Guix: support for transactional package upgrade and rollback, per-user installation, and garbage collection of packages (@pxref{Features})."
msgstr "Questo approccio è la base per le caratteristiche salienti di Guix: supporto per aggiornamenti e rollback transazionali dei pacchetti, installazione per utente e garbage collection dei pacchetti (@pxref{Features})."

msgid "Guix comes with a distribution of the GNU system consisting entirely of free software@footnote{The term ``free'' here refers to the @url{https://www.gnu.org/philosophy/free-sw.html,freedom provided to users of that software}.}.  The distribution can be installed on its own (@pxref{System Installation}), but it is also possible to install Guix as a package manager on top of an installed GNU/Linux system (@pxref{Installation}).  When we need to distinguish between the two, we refer to the standalone distribution as Guix@tie{}System."
msgstr "Guix viene fornito con una distribuzione del sistema GNU composta interamente da software libero@footnote{Il termine ``libero'' qui si riferisce alla @url{https://www.gnu.org/philosophy/free-sw.html,libertà fornita agli utenti di quel software}.}. La distribuzione può essere installata da sola (@pxref{System Installation}), ma è anche possibile installare Guix come gestore di pacchetti su un sistema GNU/Linux già installato (@pxref{Installation}). Quando abbiamo bisogno di distinguere tra i due, ci riferiamo alla distribuzione autonoma come Guix@tie{}System."

msgid "The distribution provides core GNU packages such as GNU libc, GCC, and Binutils, as well as many GNU and non-GNU applications.  The complete list of available packages can be browsed @url{https://www.gnu.org/software/guix/packages,on-line} or by running @command{guix package} (@pxref{Invoking guix package}):"
msgstr "La distribuzione fornisce pacchetti GNU di base come GNU libc, GCC e Binutils, così come molte applicazioni GNU e non-GNU. L'elenco completo dei pacchetti disponibili può essere consultato @url{https://www.gnu.org/software/guix/packages,on-line} o eseguendo @command{guix package} (@pxref{Invoking guix package}):"

msgid "guix package --list-available\n"
msgstr "guix package --list-available\n"

msgid "Our goal is to provide a practical 100% free software distribution of Linux-based and other variants of GNU, with a focus on the promotion and tight integration of GNU components, and an emphasis on programs and tools that help users exert that freedom."
msgstr "Il nostro obiettivo è fornire una distribuzione pratica di software libero al 100% di varianti basate su Linux e altre di GNU, con un focus sulla promozione e l'integrazione stretta dei componenti GNU, e un'enfasi su programmi e strumenti che aiutano gli utenti a esercitare tale libertà."

msgid "Packages are currently available on the following platforms:"
msgstr "I pacchetti sono attualmente disponibili sulle seguenti piattaforme:"

msgid "x86_64-linux"
msgstr "x86_64-linux"

msgid "Intel/AMD @code{x86_64} architecture, Linux-Libre kernel."
msgstr "Architettura Intel/AMD @code{x86_64}, kernel Linux-Libre."

msgid "i686-linux"
msgstr "i686-linux"

msgid "Intel 32-bit architecture (IA32), Linux-Libre kernel."
msgstr "Architettura Intel a 32 bit (IA32), kernel Linux-Libre."

msgid "armhf-linux"
msgstr "armhf-linux"

msgid "ARMv7-A architecture with hard float, Thumb-2 and NEON, using the EABI hard-float application binary interface (ABI), and Linux-Libre kernel."
msgstr "Architettura ARMv7-A con hard float, Thumb-2 e NEON, usando l'interfaccia binaria applicativa (ABI) EABI hard-float, e kernel Linux-Libre."

msgid "aarch64-linux"
msgstr "aarch64-linux"

msgid "little-endian 64-bit ARMv8-A processors, Linux-Libre kernel."
msgstr "Processori ARMv8-A a 64 bit little-endian, kernel Linux-Libre."

msgid "i586-gnu"
msgstr "i586-gnu"

msgid "@uref{https://hurd.gnu.org, GNU/Hurd} on the Intel 32-bit architecture (IA32)."
msgstr "@uref{https://hurd.gnu.org, GNU/Hurd} sull'architettura Intel a 32 bit (IA32)."

msgid "This configuration is experimental and under development.  The easiest way for you to give it a try is by setting up an instance of @code{hurd-vm-service-type} on your GNU/Linux machine (@pxref{transparent-emulation-qemu, @code{hurd-vm-service-type}}).  @xref{Contributing}, on how to help!"
msgstr "Questa configurazione è sperimentale e in fase di sviluppo. Il modo più semplice per provarla è impostare un'istanza di @code{hurd-vm-service-type} sulla tua macchina GNU/Linux (@pxref{transparent-emulation-qemu, @code{hurd-vm-service-type}}). @xref{Contributing}, su come aiutare!"

msgid "x86_64-gnu"
msgstr "x86_64-gnu"

msgid "@uref{https://hurd.gnu.org, GNU/Hurd} on the @code{x86_64} Intel/AMD 64-bit architecture."
msgstr "@uref{https://hurd.gnu.org, GNU/Hurd} sull'architettura Intel/AMD a 64 bit @code{x86_64}."

msgid "This configuration is even more experimental and under heavy upstream development."
msgstr "Questa configurazione è ancora più sperimentale e in forte sviluppo upstream."

msgid "mips64el-linux (unsupported)"
msgstr "mips64el-linux (non supportato)"

msgid "little-endian 64-bit MIPS processors, specifically the Loongson series, n32 ABI, and Linux-Libre kernel.  This configuration is no longer fully supported; in particular, there is no ongoing work to ensure that this architecture still works.  Should someone decide they wish to revive this architecture then the code is still available."
msgstr "Processori MIPS a 64 bit little-endian, in particolare la serie Loongson, ABI n32 e kernel Linux-Libre. Questa configurazione non è più completamente supportata; in particolare, non c'è un lavoro in corso per garantire che questa architettura funzioni ancora. Se qualcuno decidesse di voler ripristinare questa architettura, il codice è ancora disponibile."

msgid "powerpc-linux (unsupported)"
msgstr "powerpc-linux (non supportato)"

msgid "big-endian 32-bit PowerPC processors, specifically the PowerPC G4 with AltiVec support, and Linux-Libre kernel.  This configuration is not fully supported and there is no ongoing work to ensure this architecture works."
msgstr "Processori PowerPC a 32 bit big-endian, in particolare il PowerPC G4 con supporto AltiVec, e kernel Linux-Libre. Questa configurazione non è completamente supportata e non c'è un lavoro in corso per garantire che questa architettura funzioni."

msgid "powerpc64le-linux"
msgstr "powerpc64le-linux"

msgid "little-endian 64-bit Power ISA processors, Linux-Libre kernel.  This includes POWER9 systems such as the @uref{https://www.fsf.org/news/talos-ii-mainboard-and-talos-ii-lite-mainboard-now-fsf-certified-to-respect-your-freedom, RYF Talos II mainboard}. This platform is available as a \"technology preview\": although it is supported, substitutes are not yet available from the build farm (@pxref{Substitutes}), and some packages may fail to build (@pxref{Tracking Bugs and Changes}).  That said, the Guix community is actively working on improving this support, and now is a great time to try it and get involved!"
msgstr "Processori Power ISA a 64 bit little-endian, kernel Linux-Libre. Questo include sistemi POWER9 come la @uref{https://www.fsf.org/news/talos-ii-mainboard-and-talos-ii-lite-mainboard-now-fsf-certified-to-respect-your-freedom, scheda madre RYF Talos II}. Questa piattaforma è disponibile come \"anteprima tecnologica\": sebbene sia supportata, i sostituti non sono ancora disponibili dalla build farm (@pxref{Substitutes}), e alcuni pacchetti potrebbero non compilare (@pxref{Tracking Bugs and Changes}). Detto questo, la comunità di Guix sta lavorando attivamente per migliorare questo supporto, e ora è un ottimo momento per provarlo e farsi coinvolgere!"

msgid "riscv64-linux"
msgstr "riscv64-linux"

msgid "little-endian 64-bit RISC-V processors, specifically RV64GC, and Linux-Libre kernel. This platform is available as a \"technology preview\": although it is supported, substitutes are not yet available from the build farm (@pxref{Substitutes}), and some packages may fail to build (@pxref{Tracking Bugs and Changes}).  That said, the Guix community is actively working on improving this support, and now is a great time to try it and get involved!"
msgstr "Processori RISC-V a 64 bit little-endian, in particolare RV64GC, e kernel Linux-Libre. Questa piattaforma è disponibile come \"anteprima tecnologica\": sebbene sia supportata, i sostituti non sono ancora disponibili dalla build farm (@pxref{Substitutes}), e alcuni pacchetti potrebbero non compilare (@pxref{Tracking Bugs and Changes}). Detto questo, la comunità di Guix sta lavorando attivamente per migliorare questo supporto, e ora è un ottimo momento per provarlo e farsi coinvolgere!"

msgid "With Guix@tie{}System, you @emph{declare} all aspects of the operating system configuration and Guix takes care of instantiating the configuration in a transactional, reproducible, and stateless fashion (@pxref{System Configuration}).  Guix System uses the Linux-libre kernel, the Shepherd initialization system (@pxref{Introduction,,, shepherd, The GNU Shepherd Manual}), the well-known GNU utilities and tool chain, as well as the graphical environment or system services of your choice."
msgstr "Con Guix@tie{}System, tu @emph{declare} tutti gli aspetti della configurazione del sistema operativo e Guix si occupa di instanziare la configurazione in modo transazionale, riproducibile e senza stato (@pxref{System Configuration}). Guix System utilizza il kernel Linux-libre, il sistema di inizializzazione Shepherd (@pxref{Introduction,,, shepherd, The GNU Shepherd Manual}), le ben note utilità e catena di compilazione GNU, così come l'ambiente grafico o i servizi di sistema di tua scelta."

msgid "Guix System is available on all the above platforms except @code{mips64el-linux}, @code{powerpc-linux}, @code{powerpc64le-linux} and @code{riscv64-linux}."
msgstr "Guix System è disponibile su tutte le piattaforme sopra elencate eccetto @code{mips64el-linux}, @code{powerpc-linux}, @code{powerpc64le-linux} e @code{riscv64-linux}."

msgid "For information on porting to other architectures or kernels, @pxref{Porting}."
msgstr "Per informazioni sul porting ad altre architetture o kernel, @pxref{Porting}."

msgid "Building this distribution is a cooperative effort, and you are invited to join! @xref{Contributing}, for information about how you can help."
msgstr "La creazione di questa distribuzione è uno sforzo cooperativo, e sei invitato a unirti! @xref{Contributing}, per informazioni su come puoi aiutare."

msgid "installing Guix"
msgstr "installare Guix"

msgid "foreign distro"
msgstr "distro esterna"

msgid "You can install the package management tool Guix on top of an existing GNU/Linux or GNU/Hurd system@footnote{Hurd support is currently limited.}, referred to as a @dfn{foreign distro}.  If, instead, you want to install the complete, standalone GNU system distribution, @dfn{Guix@tie{}System}, @pxref{System Installation}.  This section is concerned only with the installation of Guix on a foreign distro."
msgstr "Puoi installare lo strumento di gestione dei pacchetti Guix su un sistema GNU/Linux o GNU/Hurd esistente@footnote{Il supporto a Hurd è attualmente limitato.}, chiamato @dfn{distro esterna}. Se, invece, vuoi installare la distribuzione di sistema GNU completa e autonoma, @dfn{Guix@tie{}System}, @pxref{System Installation}. Questa sezione riguarda solo l'installazione di Guix su una distro esterna."

msgid "This section only applies to systems without Guix.  Following it for existing Guix installations will overwrite important system files."
msgstr "Questa sezione si applica solo ai sistemi senza Guix. Seguirla per installazioni esistenti di Guix sovrascriverà file di sistema importanti."

msgid "directories related to foreign distro"
msgstr "directory relative a distro esterna"

msgid "When installed on a foreign distro, GNU@tie{}Guix complements the available tools without interference.  Its data lives exclusively in two directories, usually @file{/gnu/store} and @file{/var/guix}; other files on your system, such as @file{/etc}, are left untouched."
msgstr "Quando installato su una distro esterna, GNU@tie{}Guix completa gli strumenti disponibili senza interferenze. I suoi dati risiedono esclusivamente in due directory, solitamente @file{/gnu/store} e @file{/var/guix}; altri file sul tuo sistema, come @file{/etc}, non vengono toccati."

msgid "Once installed, Guix can be updated by running @command{guix pull} (@pxref{Invoking guix pull})."
msgstr "Una volta installato, Guix può essere aggiornato eseguendo @command{guix pull} (@pxref{Invoking guix pull})."

msgid "installing Guix from binaries"
msgstr "installare Guix da binari"

msgid "installer script"
msgstr "script di installazione"

msgid "This section describes how to install Guix from a self-contained tarball providing binaries for Guix and for all its dependencies.  This is often quicker than installing from source, described later (@pxref{Building from Git})."
msgstr "Questa sezione descrive come installare Guix da un tarball auto-contenuto che fornisce i binari per Guix e per tutte le sue dipendenze. Questo è spesso più veloce dell'installazione dai sorgenti, descritta più avanti (@pxref{Building from Git})."

msgid "When you're done installing Guix, @pxref{Application Setup} for extra configuration you might need, and @ref{Getting Started} for your first steps!"
msgstr "Quando hai finito di installare Guix, @pxref{Application Setup} per una configurazione extra di cui potresti aver bisogno, e @ref{Getting Started} per i tuoi primi passi!"

msgid "Making the @command{guix} command available to non-root users."
msgstr "Rendere il comando @command{guix} disponibile agli utenti non root."

msgid "Configuring substitute servers (@pxref{Official Substitute Servers})."
msgstr "Configurare i server di sostituti (@pxref{Official Substitute Servers})."

msgid "By default, @file{guix-install.sh} will configure Guix to download pre-built package binaries, called @dfn{substitutes} (@pxref{Substitutes}), from the project's build farms.  If you choose not to permit this, Guix will build @emph{everything} from source, making each installation and upgrade very expensive.  @xref{On Trusting Binaries} for a discussion of why you may want to build packages from source."
msgstr "Per impostazione predefinita, @file{guix-install.sh} configurerà Guix per scaricare binari di pacchetti precompilati, chiamati @dfn{sostituti} (@pxref{Substitutes}), dalle build farm del progetto. Se scegli di non permetterlo, Guix compilerà @emph{everything} dai sorgenti, rendendo ogni installazione e aggiornamento molto costoso. @xref{On Trusting Binaries} per una discussione sul perché potresti voler compilare i pacchetti dai sorgenti."

msgid "substitutes, authorization thereof"
msgstr "sostituti, autorizzazione degli stessi"

msgid "To use substitutes from @code{@value{SUBSTITUTE-SERVER-1}}, @code{@value{SUBSTITUTE-SERVER-2}} or a mirror, you must authorize them.  For example,"
msgstr "Per usare i sostituti da @code{@value{SUBSTITUTE-SERVER-1}}, @code{@value{SUBSTITUTE-SERVER-2}} o un mirror, devi autorizzarli. Ad esempio,"

msgid "The binary installation tarball can be (re)produced and verified simply by running the following command in the Guix source tree:"
msgstr "Il tarball di installazione binaria può essere (ri)prodotto e verificato semplicemente eseguendo il seguente comando nell'albero dei sorgenti di Guix:"

msgid "make guix-binary.@var{system}.tar.xz\n"
msgstr "make guix-binary.@var{system}.tar.xz\n"

msgid "...@: which, in turn, runs:"
msgstr "... che, a sua volta, esegue:"

msgid ""
"guix pack -s @var{system} --localstatedir \\\n"
"  --profile-name=current-guix guix\n"
msgstr ""
"guix pack -s @var{system} --localstatedir \\\n"
"  --profile-name=current-guix guix\n"

msgid "@xref{Invoking guix pack}, for more info on this handy tool."
msgstr "@xref{Invoking guix pack}, per maggiori informazioni su questo utile strumento."

msgid "Should you eventually want to uninstall Guix, run the same script with the @option{--uninstall} flag:"
msgstr "Se alla fine volessi disinstallare Guix, esegui lo stesso script con l'opzione @option{--uninstall}:"

msgid "./guix-install.sh --uninstall\n"
msgstr "./guix-install.sh --uninstall\n"

msgid "With @option{--uninstall}, the script irreversibly deletes all the Guix files, configuration, and services."
msgstr "Con @option{--uninstall}, lo script elimina irreversibilmente tutti i file, la configurazione e i servizi di Guix."

msgid "Some GNU/Linux distributions, such as openSUSE, Alpine and NixOS provide Guix through their own package managers.  The version of Guix may be older than @value{VERSION} but you can update it afterwards by running @command{guix pull}."
msgstr "Alcune distribuzioni GNU/Linux, come openSUSE, Alpine e NixOS, forniscono Guix tramite i loro gestori di pacchetti. La versione di Guix potrebbe essere più vecchia di @value{VERSION} ma puoi aggiornarla in seguito eseguendo @command{guix pull}."

msgid "We advise system administrators who install Guix, both from the installation script or @i{via} the native package manager of their foreign distribution, to also regularly read and follow security notices, as shown by @command{guix pull}."
msgstr "Consigliamo agli amministratori di sistema che installano Guix, sia dallo script di installazione che @i{via} il gestore di pacchetti nativo della loro distribuzione esterna, di leggere e seguire regolarmente gli avvisi di sicurezza, come mostrato da @command{guix pull}."

msgid "daemon"
msgstr "demone"

msgid "During installation, the @dfn{build daemon} that must be running to use Guix has already been set up and you can run @command{guix} commands in your terminal program, @pxref{Getting Started}:"
msgstr "Durante l'installazione, il @dfn{demone di build} che deve essere in esecuzione per usare Guix è già stato configurato e puoi eseguire i comandi @command{guix} nel tuo programma terminale, @pxref{Getting Started}:"

msgid "If this runs through without error, feel free to skip this section.  You should continue with the following section, @ref{Application Setup}."
msgstr "Se questo viene eseguito senza errori, sentiti libero di saltare questa sezione. Dovresti continuare con la sezione successiva, @ref{Application Setup}."

msgid "However, now would be a good time to replace outdated daemon versions, tweak it, perform builds on other machines (@pxref{Daemon Offload Setup}), or start it manually in special environments like ``chroots'' (@pxref{Chrooting into an existing system}) or WSL (not needed for WSL images created with Guix, @pxref{System Images, @code{wsl2-image-type}}).  If you want to know more or optimize your system, this section is worth reading."
msgstr "Tuttavia, ora sarebbe un buon momento per sostituire versioni obsolete del demone, modificarlo, eseguire build su altre macchine (@pxref{Daemon Offload Setup}), o avviarlo manualmente in ambienti speciali come i ``chroot'' (@pxref{Chrooting into an existing system}) o WSL (non necessario per le immagini WSL create con Guix, @pxref{System Images, @code{wsl2-image-type}}). Se vuoi saperne di più o ottimizzare il tuo sistema, questa sezione merita di essere letta."

msgid "Operations such as building a package or running the garbage collector are all performed by a specialized process, the build daemon, on behalf of clients.  Only the daemon may access the store and its associated database.  Thus, any operation that manipulates the store goes through the daemon.  For instance, command-line tools such as @command{guix package} and @command{guix build} communicate with the daemon (@i{via} remote procedure calls) to instruct it what to do."
msgstr "Operazioni come la compilazione di un pacchetto o l'esecuzione del garbage collector sono tutte eseguite da un processo specializzato, il demone di build, per conto dei client. Solo il demone può accedere allo store e al suo database associato. Quindi, qualsiasi operazione che manipola lo store passa attraverso il demone. Per esempio, strumenti da riga di comando come @command{guix package} e @command{guix build} comunicano con il demone (@i{via} chiamate di procedura remota) per istruirlo su cosa fare."

msgid "The following sections explain how to prepare the build daemon's environment.  @xref{Substitutes} for how to allow the daemon to download pre-built binaries."
msgstr "Le sezioni seguenti spiegano come preparare l'ambiente del demone di build. @xref{Substitutes} per come consentire al demone di scaricare binari precompilati."

msgid "build environment"
msgstr "ambiente di build"

msgid "In a standard multi-user setup, Guix and its daemon---the @command{guix-daemon} program---are installed by the system administrator.  Unprivileged users may use Guix tools to build packages or otherwise access the store, and the daemon will do it on their behalf, ensuring that the store is kept in a consistent state, and allowing built packages to be shared among users."
msgstr "In una configurazione multi-utente standard, Guix e il suo demone - il programma @command{guix-daemon} - sono installati dall'amministratore di sistema. Gli utenti non privilegiati possono usare gli strumenti di Guix per compilare pacchetti o accedere allo store in altro modo, e il demone lo farà per loro conto, assicurando che lo store sia mantenuto in uno stato consistente e permettendo che i pacchetti compilati siano condivisi tra gli utenti."

msgid "There are currently two ways to set up and run the build daemon:"
msgstr "Ci sono attualmente due modi per configurare ed eseguire il demone di build:"

msgid "running @command{guix-daemon} as ``root'', letting it run build processes as unprivileged users taken from a pool of build users---this is the historical approach;"
msgstr "eseguire @command{guix-daemon} come ``root'', lasciandogli eseguire i processi di build come utenti non privilegiati presi da un pool di utenti di build - questo è l'approccio storico;"

msgid "running @command{guix-daemon} as a separate unprivileged user, relying on Linux's @dfn{unprivileged user namespace} functionality to set up isolated environments---this is the option chosen when installing Guix on a systemd-based distribution with the installation script (@pxref{Binary Installation})."
msgstr "eseguire @command{guix-daemon} come utente non privilegiato separato, affidandosi alla funzionalità @dfn{namespace utente non privilegiato} di Linux per impostare ambienti isolati - questa è l'opzione scelta quando si installa Guix su una distribuzione basata su systemd con lo script di installazione (@pxref{Binary Installation})."

msgid "The sections below describe each of these two configurations in more detail and summarize the kind of build isolation they provide."
msgstr "Le sezioni seguenti descrivono ciascuna di queste due configurazioni in modo più dettagliato e riassumono il tipo di isolamento di build che forniscono."

msgid "Daemon Running as Root"
msgstr "Demone in esecuzione come Root"

msgid "build users"
msgstr "utenti di build"

msgid "When @command{guix-daemon} runs as @code{root}, you may not want package build processes themselves to run as @code{root} too, for obvious security reasons.  To avoid that, a special pool of @dfn{build users} should be created for use by build processes started by the daemon.  Having several such users allows the daemon to launch distinct build processes under separate UIDs, which guarantees that they do not interfere with each other---an essential feature since builds are regarded as pure functions (@pxref{Introduction})."
msgstr "Quando @command{guix-daemon} viene eseguito come @code{root}, potresti non volere che anche i processi di build dei pacchetti vengano eseguiti come @code{root}, per ovvie ragioni di sicurezza. Per evitarlo, dovrebbe essere creato un pool speciale di @dfn{utenti di build} da utilizzare per i processi di build avviati dal demone. Avere diversi utenti di questo tipo permette al demone di avviare processi di build distinti con UID separati, il che garantisce che non interferiscano tra loro - una caratteristica essenziale poiché le build sono considerate funzioni pure (@pxref{Introduction})."

msgid "On a GNU/Linux system, a build user pool may be created like this (using Bash syntax and the @code{shadow} commands):"
msgstr "Su un sistema GNU/Linux, un pool di utenti di build può essere creato in questo modo (usando la sintassi Bash e i comandi @code{shadow}):"

msgid "The number of build users determines how many build jobs may run in parallel, as specified by the @option{--max-jobs} option (@pxref{Invoking guix-daemon, @option{--max-jobs}}).  To use @command{guix system vm} and related commands, you may need to add the build users to the @code{kvm} group so they can access @file{/dev/kvm}, using @code{-G guixbuild,kvm} instead of @code{-G guixbuild} (@pxref{Invoking guix system})."
msgstr "Il numero di utenti di build determina quanti lavori di build possono essere eseguiti in parallelo, come specificato dall'opzione @option{--max-jobs} (@pxref{Invoking guix-daemon, @option{--max-jobs}}). Per usare @command{guix system vm} e comandi correlati, potrebbe essere necessario aggiungere gli utenti di build al gruppo @code{kvm} in modo che possano accedere a @file{/dev/kvm}, usando @code{-G guixbuild,kvm} invece di @code{-G guixbuild} (@pxref{Invoking guix system})."

msgid "The @code{guix-daemon} program may then be run as @code{root} with the following command@footnote{If your machine uses the systemd init system, copying the @file{@var{prefix}/lib/systemd/system/guix-daemon.service} file to @file{/etc/systemd/system} will ensure that @command{guix-daemon} is automatically started.  Similarly, if your machine uses the Upstart init system, copy the @file{@var{prefix}/lib/upstart/system/guix-daemon.conf} file to @file{/etc/init}.}:"
msgstr "Il programma @code{guix-daemon} può quindi essere eseguito come @code{root} con il seguente comando@footnote{Se la tua macchina usa il sistema di init systemd, copiare il file @file{@var{prefix}/lib/systemd/system/guix-daemon.service} in @file{/etc/systemd/system} garantirà che @command{guix-daemon} venga avviato automaticamente. Allo stesso modo, se la tua macchina usa il sistema di init Upstart, copia il file @file{@var{prefix}/lib/upstart/system/guix-daemon.conf} in @file{/etc/init}.}:"

msgid "# guix-daemon --build-users-group=guixbuild\n"
msgstr "# guix-daemon --build-users-group=guixbuild\n"

msgid "In this setup, @file{/gnu/store} is owned by @code{root}."
msgstr "In questa configurazione, @file{/gnu/store} è di proprietà di @code{root}."

msgid "Daemon Running Without Privileges"
msgstr "Demone in esecuzione senza privilegi"

msgid "rootless build daemon"
msgstr "demone di build rootless"

msgid "unprivileged build daemon"
msgstr "demone di build non privilegiato"

msgid "build daemon, unprivileged"
msgstr "demone di build, non privilegiato"

msgid "The second and preferred option is to run @command{guix-daemon} @emph{as an unprivileged user}.  It has the advantage of reducing the harm that can be done should a build process manage to exploit a vulnerability in the daemon.  This option requires the use of Linux's unprivileged user namespace mechanism; today it is available and enabled by most GNU/Linux distributions but can still be disabled.  The installation script automatically determines whether this option is available on your system (@pxref{Binary Installation})."
msgstr "La seconda e preferita opzione è eseguire @command{guix-daemon} @emph{come utente non privilegiato}. Ha il vantaggio di ridurre il danno che può essere fatto se un processo di build riesce a sfruttare una vulnerabilità nel demone. Questa opzione richiede l'uso del meccanismo di namespace utente non privilegiato di Linux; oggi è disponibile e abilitato sulla maggior parte delle distribuzioni GNU/Linux, ma può ancora essere disabilitato. Lo script di installazione determina automaticamente se questa opzione è disponibile sul tuo sistema (@pxref{Binary Installation})."

msgid "When using this option, you only need to create one user account, and @command{guix-daemon} will run with the authority of that account:"
msgstr "Quando si usa questa opzione, è necessario creare un solo account utente, e @command{guix-daemon} verrà eseguito con l'autorità di quell'account:"

msgid ""
"# groupadd --system guix-daemon\n"
"# useradd -g guix-daemon -G guix-daemon              \\\n"
"          -d /var/empty -s $(which nologin)          \\\n"
"          -c \"Guix daemon privilege separation user\" \\\n"
"          --system guix-daemon\n"
msgstr ""
"# groupadd --system guix-daemon\n"
"# useradd -g guix-daemon -G guix-daemon              \\\n"
"          -d /var/empty -s $(which nologin)          \\\n"
"          -c \"Utente separazione privilegi demone Guix\" \\\n"
"          --system guix-daemon\n"

msgid "In this configuration, @file{/gnu/store} is owned by the @code{guix-daemon} user."
msgstr "In questa configurazione, @file{/gnu/store} è di proprietà dell'utente @code{guix-daemon}."

msgid "unprivileged-daemon-migration"
msgstr "unprivileged-daemon-migration"

msgid "Migrating to the Unprivileged Daemon"
msgstr "Migrazione al demone non privilegiato"

msgid "unprivileged daemon, migration"
msgstr "demone non privilegiato, migrazione"

msgid "rootless daemon, migration"
msgstr "demone rootless, migrazione"

msgid "To switch an existing installation to the unprivileged execution mode, a number of steps must be taken: creating a new dedicated @code{guix-daemon} user account, changing ownership of the relevant files to @code{guix-daemon}, and ensuring that the @command{guix-daemon} program runs as @code{guix-daemon}."
msgstr "Per passare una installazione esistente alla modalità di esecuzione non privilegiata, devono essere eseguiti alcuni passaggi: creare un nuovo account utente dedicato @code{guix-daemon}, cambiare la proprietà dei file pertinenti a @code{guix-daemon}, e assicurarsi che il programma @command{guix-daemon} venga eseguito come @code{guix-daemon}."

msgid "On Guix System, these steps are carried out automatically when you set the @code{privileged?} field of the @code{guix-configuration} record to @code{#f} and reconfigure (@pxref{guix-configuration-type, @code{guix-configuration}})."
msgstr "Su Guix System, questi passaggi vengono eseguiti automaticamente quando si imposta il campo @code{privileged?} del record @code{guix-configuration} su @code{#f} e si riconfigura (@pxref{guix-configuration-type, @code{guix-configuration}})."

msgid "However, on a foreign distribution, the process is manual.  The following paragraphs describe what you need to do."
msgstr "Tuttavia, su una distribuzione esterna, il processo è manuale. I seguenti paragrafi descrivono cosa è necessario fare."

msgid "Follow the instructions below only after making sure you have a recent version of @command{guix-daemon} with support for unprivileged execution."
msgstr "Segui le istruzioni seguenti solo dopo esserti assicurato di avere una versione recente di @command{guix-daemon} con supporto per l'esecuzione non privilegiata."

msgid "File ownership can be changed, after stopping the daemon, by running the following commands as root (the @command{chown} can take a while if there are many files in @file{/gnu/store}):"
msgstr "La proprietà dei file può essere cambiata, dopo aver fermato il demone, eseguendo i seguenti comandi come root (il comando @command{chown} può richiedere del tempo se ci sono molti file in @file{/gnu/store}):"

msgid ""
"groupadd --system guix-daemon\n"
"useradd -g guix-daemon -G guix-daemon,kvm               \\\n"
"        -d /var/empty -s $(which nologin)               \\\n"
"        -c \"Guix daemon privilege separation user\"      \\\n"
"        --system guix-daemon\n"
"\n"
msgstr ""
"groupadd --system guix-daemon\n"
"useradd -g guix-daemon -G guix-daemon,kvm               \\\n"
"        -d /var/empty -s $(which nologin)               \\\n"
"        -c \"Utente separazione privilegi demone Guix\"      \\\n"
"        --system guix-daemon\n"
"\n"

msgid ""
"# Make the store writable, in case the systemd 'gnu-store.mount'\n"
"# unit made it read-only.\n"
"mount -o remount,rw /gnu/store\n"
"\n"
msgstr ""
"# Rendi lo store scrivibile, nel caso l'unità systemd 'gnu-store.mount'\n"
"# l'avesse reso di sola lettura.\n"
"mount -o remount,rw /gnu/store\n"
"\n"

msgid ""
"chown -R guix-daemon:guix-daemon                        \\\n"
"  /gnu                                                  \\\n"
"  /var/guix/@{gc.lock,daemon-socket,db,discover@}         \\\n"
"  /var/guix/@{gcroots,offload,substitute,temproots@}      \\\n"
"  /var/log/guix                                         \\\n"
"  /etc/guix\n"
msgstr ""
"chown -R guix-daemon:guix-daemon                        \\\n"
"  /gnu                                                  \\\n"
"  /var/guix/@{gc.lock,daemon-socket,db,discover@}         \\\n"
"  /var/guix/@{gcroots,offload,substitute,temproots@}      \\\n"
"  /var/log/guix                                         \\\n"
"  /etc/guix\n"

msgid "If your system uses the systemd service manager, running the daemon as @code{guix-daemon} will be a matter of copying the relevant configuration files---make sure to review any changes you might have made in your own @file{.service} files before overwriting them:"
msgstr "Se il tuo sistema usa il gestore di servizi systemd, eseguire il demone come @code{guix-daemon} sarà una questione di copiare i file di configurazione pertinenti - assicurati di rivedere eventuali modifiche che potresti aver fatto nei tuoi file @file{.service} prima di sovrascriverli:"

msgid ""
"cp /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/*.service \\\n"
"   /etc/systemd/system\n"
"systemctl daemon-reload\n"
"systemctl start guix-daemon\n"
msgstr ""
"cp /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/*.service \\\n"
"   /etc/systemd/system\n"
"systemctl daemon-reload\n"
"systemctl start guix-daemon\n"

msgid "The commands above assume that @command{guix pull} was run for the root user.  You can check whether this is the case by running this command:"
msgstr "I comandi sopra assumono che @command{guix pull} sia stato eseguito per l'utente root. Puoi verificare se questo è il caso eseguendo questo comando:"

msgid ""
"grep User=guix-daemon \\\n"
"  /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/guix-daemon.service\n"
msgstr ""
"grep User=guix-daemon \\\n"
"  /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/guix-daemon.service\n"

msgid "If that command does not show the @code{User=guix-daemon} line, then run @command{guix pull} as the root user."
msgstr "Se quel comando non mostra la riga @code{User=guix-daemon}, allora esegui @command{guix pull} come utente root."

msgid "The Isolated Build Environment"
msgstr "L'ambiente di build isolato"

msgid "chroot"
msgstr "chroot"

msgid "build environment isolation"
msgstr "isolamento dell'ambiente di build"

msgid "isolated build environment"
msgstr "ambiente di build isolato"

msgid "hermetic build environment"
msgstr "ambiente di build ermetico"

msgid "In both cases, privileged and unprivileged, the daemon starts build processes without privileges in an @emph{isolated} or @emph{hermetic} build environment---a ``chroot''.  On GNU/Linux, by default, the build environment contains nothing but:"
msgstr "In entrambi i casi, privilegiato e non privilegiato, il demone avvia i processi di build senza privilegi in un ambiente di build @emph{isolated} o @emph{hermetic} - un ``chroot''. Su GNU/Linux, per impostazione predefinita, l'ambiente di build non contiene altro che:"

msgid "a minimal @code{/dev} directory, created mostly independently from the host @code{/dev}@footnote{``Mostly'', because while the set of files that appear in the chroot's @code{/dev} is fixed, most of these files can only be created if the host has them.};"
msgstr "una directory @code{/dev} minimale, creata per lo più indipendentemente dalla @code{/dev} dell'host@footnote{``Per lo più'', perché mentre l'insieme di file che appaiono nella @code{/dev} del chroot è fisso, la maggior parte di questi file può essere creata solo se l'host li ha.};"

msgid "the @code{/proc} directory; it only shows the processes of the container since a separate PID name space is used;"
msgstr "la directory @code{/proc}; mostra solo i processi del container poiché viene usato un namespace PID separato;"

msgid "@file{/etc/passwd} with an entry for the current user and an entry for user @file{nobody};"
msgstr "@file{/etc/passwd} con una voce per l'utente corrente e una voce per l'utente @file{nobody};"

msgid "@file{/etc/group} with an entry for the user's group;"
msgstr "@file{/etc/group} con una voce per il gruppo dell'utente;"

msgid "@file{/etc/hosts} with an entry that maps @code{localhost} to @code{127.0.0.1};"
msgstr "@file{/etc/hosts} con una voce che mappa @code{localhost} a @code{127.0.0.1};"

msgid "a writable @file{/tmp} directory."
msgstr "una directory @file{/tmp} scrivibile."

msgid "The chroot does not contain a @file{/home} directory, and the @env{HOME} environment variable is set to the non-existent @file{/homeless-shelter}.  This helps to highlight inappropriate uses of @env{HOME} in the build scripts of packages."
msgstr "Il chroot non contiene una directory @file{/home}, e la variabile d'ambiente @env{HOME} è impostata sulla directory inesistente @file{/homeless-shelter}. Questo aiuta a evidenziare usi inappropriati di @env{HOME} negli script di build dei pacchetti."

msgid "All this is usually enough to ensure details of the environment do not influence build processes.  In some exceptional cases where more control is needed---typically over the date, kernel, or CPU---you can resort to a virtual build machine (@pxref{build-vm, virtual build machines})."
msgstr "Tutto questo è solitamente sufficiente per garantire che i dettagli dell'ambiente non influenzino i processi di build. In alcuni casi eccezionali in cui è necessario un maggiore controllo - tipicamente sulla data, il kernel o la CPU - si può ricorrere a una macchina virtuale di build (@pxref{build-vm, virtual build machines})."

msgid "You can influence the directory where the daemon stores build trees @i{via} the @env{TMPDIR} environment variable.  However, the build tree within the chroot is always called @file{/tmp/guix-build-@var{name}.drv-0}, where @var{name} is the derivation name---e.g., @code{coreutils-8.24}.  This way, the value of @env{TMPDIR} does not leak inside build environments, which avoids discrepancies in cases where build processes capture the name of their build tree."
msgstr "Puoi influenzare la directory in cui il demone memorizza gli alberi di build @i{via} la variabile d'ambiente @env{TMPDIR}. Tuttavia, l'albero di build all'interno del chroot è sempre chiamato @file{/tmp/guix-build-@var{name}.drv-0}, dove @var{name} è il nome della derivazione - ad esempio, @code{coreutils-8.24}. In questo modo, il valore di @env{TMPDIR} non trapela negli ambienti di build, il che evita discrepanze nei casi in cui i processi di build catturano il nome del loro albero di build."

msgid "http_proxy"
msgstr "http_proxy"

msgid "https_proxy"
msgstr "https_proxy"

msgid "The daemon also honors the @env{http_proxy} and @env{https_proxy} environment variables for HTTP and HTTPS downloads it performs, be it for fixed-output derivations (@pxref{Derivations}) or for substitutes (@pxref{Substitutes})."
msgstr "Il demone onora anche le variabili d'ambiente @env{http_proxy} e @env{https_proxy} per i download HTTP e HTTPS che esegue, sia per le derivazioni a output fisso (@pxref{Derivations}) che per i sostituti (@pxref{Substitutes})."

msgid "Using the Offload Facility"
msgstr "Uso della funzione di offload"

msgid "offloading"
msgstr "offloading"

msgid "build hook"
msgstr "hook di build"

msgid "When desired, the build daemon can @dfn{offload} derivation builds to other machines running Guix, using the @code{offload} @dfn{build hook}@footnote{This feature is available only when @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH} is present.}.  When that feature is enabled, a list of user-specified build machines is read from @file{/etc/guix/machines.scm}; every time a build is requested, for instance via @code{guix build}, the daemon attempts to offload it to one of the machines that satisfy the constraints of the derivation, in particular its system types---e.g., @code{x86_64-linux}.  A single machine can have multiple system types, either because its architecture natively supports it, via emulation (@pxref{transparent-emulation-qemu, Transparent Emulation with QEMU}), or both.  Missing prerequisites for the build are copied over SSH to the target machine, which then proceeds with the build; upon success the output(s) of the build are copied back to the initial machine.  The offload facility comes with a basic scheduler that attempts to select the best machine.  The best machine is chosen among the available machines based on criteria such as:"
msgstr "Se lo si desidera, il demone di build può fare l'@dfn{offload} delle build di derivazione su altre macchine che eseguono Guix, utilizzando l'@dfn{hook di build} @code{offload}@footnote{Questa funzione è disponibile solo quando @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH} è presente.}. Quando questa funzione è abilitata, un elenco di macchine di build specificate dall'utente viene letto da @file{/etc/guix/machines.scm}; ogni volta che viene richiesta una build, ad esempio tramite @code{guix build}, il demone tenta di scaricarla su una delle macchine che soddisfano i vincoli della derivazione, in particolare i suoi tipi di sistema, ad esempio @code{x86_64-linux}. Una singola macchina può avere più tipi di sistema, sia perché la sua architettura lo supporta nativamente, sia tramite emulazione (@pxref{transparent-emulation-qemu, Transparent Emulation with QEMU}), o entrambi. I prerequisiti mancanti per la build vengono copiati tramite SSH sulla macchina di destinazione, che procede quindi con la build; in caso di successo, l'output (o gli output) della build viene copiato nuovamente sulla macchina iniziale. La funzione di offload è dotata di uno scheduler di base che tenta di selezionare la macchina migliore. La macchina migliore viene scelta tra le macchine disponibili in base a criteri quali:"

msgid "The availability of a build slot.  A build machine can have as many build slots (connections) as the value of the @code{parallel-builds} field of its @code{build-machine} object."
msgstr "La disponibilità di uno slot di build. Una macchina di build può avere tanti slot di build (connessioni) quanti il valore del campo @code{parallel-builds} del suo oggetto @code{build-machine}."

msgid "Its relative speed, as defined via the @code{speed} field of its @code{build-machine} object."
msgstr "La sua velocità relativa, come definita tramite il campo @code{speed} del suo oggetto @code{build-machine}."

msgid "Its load.  The normalized machine load must be lower than a threshold value, configurable via the @code{overload-threshold} field of its @code{build-machine} object."
msgstr "Il suo carico. Il carico normalizzato della macchina deve essere inferiore a un valore soglia, configurabile tramite il campo @code{overload-threshold} del suo oggetto @code{build-machine}."

msgid "Disk space availability.  More than 100 MiB must be available."
msgstr "Disponibilità di spazio su disco. Devono essere disponibili più di 100 MiB."

msgid "The @file{/etc/guix/machines.scm} file typically looks like this:"
msgstr "Il file @file{/etc/guix/machines.scm} si presenta tipicamente così:"

msgid ""
"(list (build-machine\n"
"        (name \"eightysix.example.org\")\n"
"        (systems (list \"x86_64-linux\" \"i686-linux\"))\n"
"        (host-key \"ssh-ed25519 AAAAC3Nza@dots{}\")\n"
"        (user \"bob\")\n"
"        (speed 2.))     ;incredibly fast!\n"
"\n"
msgstr ""
"(list (build-machine\n"
"        (name \"eightysix.example.org\")\n"
"        (systems (list \"x86_64-linux\" \"i686-linux\"))\n"
"        (host-key \"ssh-ed25519 AAAAC3Nza@dots{}\")\n"
"        (user \"bob\")\n"
"        (speed 2.))     ;incredibilmente veloce!\n"
"\n"

msgid ""
"      (build-machine\n"
"        (name \"armeight.example.org\")\n"
"        (systems (list \"aarch64-linux\"))\n"
"        (host-key \"ssh-rsa AAAAB3Nza@dots{}\")\n"
"        (user \"alice\")\n"
"\n"
msgstr ""
"      (build-machine\n"
"        (name \"armeight.example.org\")\n"
"        (systems (list \"aarch64-linux\"))\n"
"        (host-key \"ssh-rsa AAAAB3Nza@dots{}\")\n"
"        (user \"alice\")\n"
"\n"

msgid ""
"        ;; Remember 'guix offload' is spawned by\n"
"        ;; 'guix-daemon' as root.\n"
"        (private-key \"/root/.ssh/identity-for-guix\")))\n"
msgstr ""
"        ;; Ricorda che 'guix offload' viene generato da\n"
"        ;; 'guix-daemon' come root.\n"
"        (private-key \"/root/.ssh/identity-for-guix\")))\n"

msgid "In the example above we specify a list of two build machines, one for the @code{x86_64} and @code{i686} architectures and one for the @code{aarch64} architecture."
msgstr "Nell'esempio sopra specifichiamo un elenco di due macchine di build, una per le architetture @code{x86_64} e @code{i686} e una per l'architettura @code{aarch64}."

msgid "In fact, this file is---not surprisingly!---a Scheme file that is evaluated when the @code{offload} hook is started.  Its return value must be a list of @code{build-machine} objects.  While this example shows a fixed list of build machines, one could imagine, say, using DNS-SD to return a list of potential build machines discovered in the local network (@pxref{Introduction, Guile-Avahi,, guile-avahi, Using Avahi in Guile Scheme Programs}).  The @code{build-machine} data type is detailed below."
msgstr "Infatti, questo file è - non sorprendentemente! - un file Scheme che viene valutato quando l'hook @code{offload} viene avviato. Il suo valore di ritorno deve essere un elenco di oggetti @code{build-machine}. Sebbene questo esempio mostri un elenco fisso di macchine di build, si potrebbe immaginare, ad esempio, di usare DNS-SD per restituire un elenco di potenziali macchine di build scoperte nella rete locale (@pxref{Introduction, Guile-Avahi,, guile-avahi, Using Avahi in Guile Scheme Programs}). Il tipo di dato @code{build-machine} è dettagliato di seguito."

msgid "{Data Type} build-machine"
msgstr "{Tipo di dato} build-machine"

msgid "This data type represents build machines to which the daemon may offload builds.  The important fields are:"
msgstr "Questo tipo di dato rappresenta le macchine di build su cui il demone può scaricare le build. I campi importanti sono:"

msgid "name"
msgstr "name"

msgid "The host name of the remote machine."
msgstr "Il nome host della macchina remota."

msgid "systems"
msgstr "sistemi"

msgid "The system types the remote machine supports---e.g., @code{(list \"x86_64-linux\" \"i686-linux\")}."
msgstr "I tipi di sistema che la macchina remota supporta - ad es., @code{(list \"x86_64-linux\" \"i686-linux\")}."

msgid "user"
msgstr "user"

msgid "The user account on the remote machine to use when connecting over SSH.  Note that the SSH key pair must @emph{not} be passphrase-protected, to allow non-interactive logins."
msgstr "L'account utente sulla macchina remota da usare per la connessione via SSH. Nota che la coppia di chiavi SSH @emph{not} deve essere protetta da passphrase, per consentire accessi non interattivi."

msgid "host-key"
msgstr "host-key"

msgid "This must be the machine's SSH @dfn{public host key} in OpenSSH format.  This is used to authenticate the machine when we connect to it.  It is a long string that looks like this:"
msgstr "Questa deve essere la @dfn{chiave host pubblica} SSH della macchina in formato OpenSSH. Viene usata per autenticare la macchina quando ci colleghiamo ad essa. È una stringa lunga che assomiglia a questa:"

msgid "ssh-ed25519 AAAAC3NzaC@dots{}mde+UhL hint@@example.org\n"
msgstr "ssh-ed25519 AAAAC3NzaC@dots{}mde+UhL hint@@example.org\n"

msgid "If the machine is running the OpenSSH daemon, @command{sshd}, the host key can be found in a file such as @file{/etc/ssh/ssh_host_ed25519_key.pub}."
msgstr "Se la macchina sta eseguendo il demone OpenSSH, @command{sshd}, la chiave host può essere trovata in un file come @file{/etc/ssh/ssh_host_ed25519_key.pub}."

msgid "A number of optional fields may be specified:"
msgstr "Possono essere specificati alcuni campi opzionali:"

msgid "@code{port} (default: @code{22})"
msgstr "@code{port} (predefinito: @code{22})"

msgid "Port number of SSH server on the machine."
msgstr "Numero di porta del server SSH sulla macchina."

msgid "@code{private-key} (default: @file{~root/.ssh/id_rsa})"
msgstr "@code{private-key} (predefinito: @file{~root/.ssh/id_rsa})"

msgid "The SSH private key file to use when connecting to the machine, in OpenSSH format.  This key must not be protected with a passphrase."
msgstr "Il file della chiave privata SSH da usare per la connessione alla macchina, in formato OpenSSH. Questa chiave non deve essere protetta da passphrase."

msgid "Note that the default value is the private key @emph{of the root account}.  Make sure it exists if you use the default."
msgstr "Nota che il valore predefinito è la chiave privata @emph{dell'account root}. Assicurati che esista se usi il valore predefinito."

msgid "@code{compression} (default: @code{\"zlib@@openssh.com,zlib\"})"
msgstr "@code{compression} (predefinito: @code{\"zlib@@openssh.com,zlib\"})"

msgid "@code{compression-level} (default: @code{3})"
msgstr "@code{compression-level} (predefinito: @code{3})"

msgid "The SSH-level compression methods and compression level requested."
msgstr "I metodi di compressione a livello SSH e il livello di compressione richiesti."

msgid "Note that offloading relies on SSH compression to reduce bandwidth usage when transferring files to and from build machines."
msgstr "Nota che l'offload si basa sulla compressione SSH per ridurre l'uso della banda durante il trasferimento di file da e verso le macchine di build."

msgid "@code{daemon-socket} (default: @code{\"/var/guix/daemon-socket/socket\"})"
msgstr "@code{daemon-socket} (predefinito: @code{\"/var/guix/daemon-socket/socket\"})"

msgid "File name of the Unix-domain socket @command{guix-daemon} is listening to on that machine."
msgstr "Nome del file della socket di dominio Unix su cui @command{guix-daemon} è in ascolto su quella macchina."

msgid "@code{overload-threshold} (default: @code{0.8})"
msgstr "@code{overload-threshold} (predefinito: @code{0.8})"

msgid "The load threshold above which a potential offload machine is disregarded by the offload scheduler.  The value roughly translates to the total processor usage of the build machine, ranging from 0.0 (0%) to 1.0 (100%).  It can also be disabled by setting @code{overload-threshold} to @code{#f}."
msgstr "La soglia di carico al di sopra della quale una potenziale macchina di offload viene scartata dallo scheduler di offload. Il valore si traduce approssimativamente nell'utilizzo totale del processore della macchina di build, con un intervallo da 0.0 (0%) a 1.0 (100%). Può anche essere disabilitato impostando @code{overload-threshold} a @code{#f}."

msgid "@code{parallel-builds} (default: @code{1})"
msgstr "@code{parallel-builds} (predefinito: @code{1})"

msgid "The number of builds that may run in parallel on the machine."
msgstr "Il numero di build che possono essere eseguite in parallelo sulla macchina."

msgid "@code{speed} (default: @code{1.0})"
msgstr "@code{speed} (predefinito: @code{1.0})"

msgid "A ``relative speed factor''.  The offload scheduler will tend to prefer machines with a higher speed factor."
msgstr "Un ``fattore di velocità relativa''. Lo scheduler di offload tenderà a preferire le macchine con un fattore di velocità più alto."

msgid "@code{features} (default: @code{'()})"
msgstr "@code{features} (predefinito: @code{'()})"

msgid "A list of strings denoting specific features supported by the machine.  An example is @code{\"kvm\"} for machines that have the KVM Linux modules and corresponding hardware support.  Derivations can request features by name, and they will be scheduled on matching build machines."
msgstr "Un elenco di stringhe che denotano caratteristiche specifiche supportate dalla macchina. Un esempio è @code{\"kvm\"} per le macchine che hanno i moduli KVM di Linux e il supporto hardware corrispondente. Le derivazioni possono richiedere caratteristiche per nome, e verranno pianificate su macchine di build corrispondenti."

msgid "On Guix System, instead of managing @file{/etc/guix/machines.scm} independently, you can choose to specify build machines directly in the @code{operating-system} declaration, in the @code{build-machines} field of @code{guix-configuration}.  @xref{guix-configuration-build-machines, @code{build-machines} field of @code{guix-configuration}}."
msgstr "Su Guix System, invece di gestire @file{/etc/guix/machines.scm} indipendentemente, puoi scegliere di specificare le macchine di build direttamente nella dichiarazione @code{operating-system}, nel campo @code{build-machines} di @code{guix-configuration}. @xref{guix-configuration-build-machines, campo @code{build-machines} di @code{guix-configuration}}."

msgid "The @command{guix} command must be in the search path on the build machines.  You can check whether this is the case by running:"
msgstr "Il comando @command{guix} deve trovarsi nel percorso di ricerca delle macchine di build. Puoi verificare se questo è il caso eseguendo:"

msgid "ssh build-machine guix repl --version\n"
msgstr "ssh build-machine guix repl --version\n"

msgid "There is one last thing to do once @file{machines.scm} is in place.  As explained above, when offloading, files are transferred back and forth between the machine stores.  For this to work, you first need to generate a key pair on each machine to allow the daemon to export signed archives of files from the store (@pxref{Invoking guix archive}):"
msgstr "C'è un'ultima cosa da fare una volta che @file{machines.scm} è a posto. Come spiegato sopra, durante l'offloading, i file vengono trasferiti avanti e indietro tra gli store delle macchine. Affinché ciò funzioni, devi prima generare una coppia di chiavi su ogni macchina per consentire al demone di esportare archivi firmati di file dallo store (@pxref{Invoking guix archive}):"

msgid "# guix archive --generate-key\n"
msgstr "# guix archive --generate-key\n"

msgid "This key pair is not related to the SSH key pair that was previously mentioned in the description of the @code{build-machine} data type."
msgstr "Questa coppia di chiavi non è correlata alla coppia di chiavi SSH che è stata menzionata in precedenza nella descrizione del tipo di dato @code{build-machine}."

msgid "Each build machine must authorize the key of the master machine so that it accepts store items it receives from the master:"
msgstr "Ogni macchina di build deve autorizzare la chiave della macchina principale in modo da accettare gli elementi dello store che riceve dal master:"

msgid "# guix archive --authorize < master-public-key.txt\n"
msgstr "# guix archive --authorize < master-public-key.txt\n"

msgid "Likewise, the master machine must authorize the key of each build machine."
msgstr "Allo stesso modo, la macchina principale deve autorizzare la chiave di ogni macchina di build."

msgid "All the fuss with keys is here to express pairwise mutual trust relations between the master and the build machines.  Concretely, when the master receives files from a build machine (and @i{vice versa}), its build daemon can make sure they are genuine, have not been tampered with, and that they are signed by an authorized key."
msgstr "Tutto questo trambusto con le chiavi serve per esprimere relazioni di fiducia reciproca a coppie tra la macchina principale e le macchine di build. Concretamente, quando la macchina principale riceve file da una macchina di build (e @i{viceversa}), il suo demone di build può assicurarsi che siano genuini, che non siano stati manomessi e che siano firmati da una chiave autorizzata."

msgid "offload test"
msgstr "test di offload"

msgid "To test whether your setup is operational, run this command on the master node:"
msgstr "Per verificare se la tua configurazione è operativa, esegui questo comando sul nodo principale:"

msgid "# guix offload test\n"
msgstr "# guix offload test\n"

msgid "This will attempt to connect to each of the build machines specified in @file{/etc/guix/machines.scm}, make sure Guix is available on each machine, attempt to export to the machine and import from it, and report any error in the process."
msgstr "Questo tenterà di connettersi a ciascuna delle macchine di build specificate in @file{/etc/guix/machines.scm}, si assicurerà che Guix sia disponibile su ogni macchina, tenterà di esportare sulla macchina e di importare da essa, e segnalerà qualsiasi errore nel processo."

msgid "If you want to test a different machine file, just specify it on the command line:"
msgstr "Se vuoi testare un file di macchine diverso, specificalo semplicemente sulla riga di comando:"

msgid "# guix offload test machines-qualif.scm\n"
msgstr "# guix offload test machines-qualif.scm\n"

msgid "Last, you can test the subset of the machines whose name matches a regular expression like this:"
msgstr "Infine, puoi testare il sottoinsieme delle macchine il cui nome corrisponde a un'espressione regolare come questa:"

msgid "# guix offload test machines.scm '\\.gnu\\.org$'\n"
msgstr "# guix offload test machines.scm '\\.gnu\\.org$'\n"

msgid "offload status"
msgstr "stato dell'offload"

msgid "To display the current load of all build hosts, run this command on the main node:"
msgstr "Per visualizzare il carico corrente di tutti gli host di build, esegui questo comando sul nodo principale:"

msgid "# guix offload status\n"
msgstr "# guix offload status\n"

msgid "SELinux, daemon policy"
msgstr "SELinux, policy del demone"

msgid "mandatory access control, SELinux"
msgstr "controllo di accesso obbligatorio, SELinux"

msgid "security, guix-daemon"
msgstr "sicurezza, guix-daemon"

msgid "Guix includes an SELinux policy file at @file{etc/guix-daemon.cil} that can be installed on a system where SELinux is enabled, in order to label Guix files and to specify the expected behavior of the daemon.  Since Guix System does not provide an SELinux base policy, the daemon policy cannot be used on Guix System."
msgstr "Guix include un file di policy SELinux in @file{etc/guix-daemon.cil} che può essere installato su un sistema in cui SELinux è abilitato, al fine di etichettare i file di Guix e di specificare il comportamento atteso del demone. Poiché Guix System non fornisce una policy di base SELinux, la policy del demone non può essere usata su Guix System."

msgid "Installing the SELinux policy"
msgstr "Installare la policy SELinux"

msgid "SELinux, policy installation"
msgstr "SELinux, installazione della policy"

msgid "The @code{guix-install.sh} binary installation script offers to perform the steps below for you (@pxref{Binary Installation})."
msgstr "Lo script di installazione binaria @code{guix-install.sh} offre di eseguire i passaggi seguenti per te (@pxref{Binary Installation})."

msgid "To install the policy run this command as root:"
msgstr "Per installare la policy, esegui questo comando come root:"

msgid "semodule -i /var/guix/profiles/per-user/root/current-guix/share/selinux/guix-daemon.cil\n"
msgstr "semodule -i /var/guix/profiles/per-user/root/current-guix/share/selinux/guix-daemon.cil\n"

msgid "Then, as root, relabel the file system, possibly after making it writable:"
msgstr "Poi, come root, rietichetta il file system, eventualmente dopo averlo reso scrivibile:"

msgid ""
"mount -o remount,rw /gnu/store\n"
"restorecon -R /gnu /var/guix\n"
msgstr ""
"mount -o remount,rw /gnu/store\n"
"restorecon -R /gnu /var/guix\n"

msgid "At this point you can start or restart @command{guix-daemon}; on a distribution that uses systemd as its service manager, you can do that with:"
msgstr "A questo punto puoi avviare o riavviare @command{guix-daemon}; su una distribuzione che usa systemd come gestore di servizi, puoi farlo con:"

msgid "systemctl restart guix-daemon\n"
msgstr "systemctl restart guix-daemon\n"

msgid "Once the policy is installed, the file system has been relabeled, and the daemon has been restarted, it should be running in the @code{guix_daemon_t} context.  You can confirm this with the following command:"
msgstr "Una volta che la policy è installata, il file system è stato rietichettato e il demone è stato riavviato, dovrebbe essere in esecuzione nel contesto @code{guix_daemon_t}. Puoi confermarlo con il seguente comando:"

msgid "ps -Zax | grep guix-daemon\n"
msgstr "ps -Zax | grep guix-daemon\n"

msgid "Monitor the SELinux log files as you run a command like @code{guix build hello} to convince yourself that SELinux permits all necessary operations."
msgstr "Monitora i file di log di SELinux mentre esegui un comando come @code{guix build hello} per convincerti che SELinux permette tutte le operazioni necessarie."

msgid "SELinux, limitations"
msgstr "SELinux, limitazioni"

msgid "This policy is not perfect.  Here is a list of limitations or quirks that should be considered when deploying the provided SELinux policy for the Guix daemon."
msgstr "Questa policy non è perfetta. Ecco un elenco di limitazioni o stranezze che dovrebbero essere considerate quando si implementa la policy SELinux fornita per il demone Guix."

msgid "@code{guix_daemon_socket_t} isn’t actually used.  None of the socket operations involve contexts that have anything to do with @code{guix_daemon_socket_t}.  It doesn’t hurt to have this unused label, but it would be preferable to define socket rules for only this label."
msgstr "@code{guix_daemon_socket_t} non è effettivamente utilizzato. Nessuna delle operazioni sulle socket coinvolge contesti che abbiano a che fare con @code{guix_daemon_socket_t}. Non fa male avere questa etichetta inutilizzata, ma sarebbe preferibile definire regole per le socket solo per questa etichetta."

msgid "@code{guix gc} cannot access arbitrary links to profiles.  By design, the file label of the destination of a symlink is independent of the file label of the link itself.  Although all profiles under @file{$localstatedir} are labelled, the links to these profiles inherit the label of the directory they are in.  For links in the user’s home directory this will be @code{user_home_t}.  But for links from the root user’s home directory, or @file{/tmp}, or the HTTP server’s working directory, etc, this won’t work.  @code{guix gc} would be prevented from reading and following these links."
msgstr "@code{guix gc} non può accedere a collegamenti arbitrari ai profili. Per progetto, l'etichetta del file di destinazione di un collegamento simbolico è indipendente dall'etichetta del file del collegamento stesso. Sebbene tutti i profili sotto @file{$localstatedir} siano etichettati, i collegamenti a questi profili ereditano l'etichetta della directory in cui si trovano. Per i collegamenti nella directory home dell'utente, questa sarà @code{user_home_t}. Ma per i collegamenti dalla directory home dell'utente root, o @file{/tmp}, o la directory di lavoro del server HTTP, ecc, questo non funzionerà. A @code{guix gc} verrebbe impedito di leggere e seguire questi collegamenti."

msgid "The daemon’s feature to listen for TCP connections might no longer work.  This might require extra rules, because SELinux treats network sockets differently from files."
msgstr "La funzione del demone di ascoltare le connessioni TCP potrebbe non funzionare più. Questo potrebbe richiedere regole extra, perché SELinux tratta le socket di rete diversamente dai file."

msgid "Currently all files with a name matching the regular expression @code{/gnu/store/.+-(guix-.+|profile)/bin/guix-daemon} are assigned the label @code{guix_daemon_exec_t}; this means that @emph{any} file with that name in any profile would be permitted to run in the @code{guix_daemon_t} domain.  This is not ideal.  An attacker could build a package that provides this executable and convince a user to install and run it, which lifts it into the @code{guix_daemon_t} domain.  At that point SELinux could not prevent it from accessing files that are allowed for processes in that domain."
msgstr "Attualmente, a tutti i file con un nome che corrisponde all'espressione regolare @code{/gnu/store/.+-(guix-.+|profile)/bin/guix-daemon} viene assegnata l'etichetta @code{guix_daemon_exec_t}; questo significa che @emph{any} file con quel nome in qualsiasi profilo sarebbe autorizzato a essere eseguito nel dominio @code{guix_daemon_t}. Questo non è l'ideale. Un aggressore potrebbe creare un pacchetto che fornisce questo eseguibile e convincere un utente a installarlo ed eseguirlo, il che lo eleva al dominio @code{guix_daemon_t}. A quel punto SELinux non potrebbe impedirgli di accedere ai file consentiti per i processi in quel dominio."

msgid "You will need to relabel the store directory after all upgrades to @file{guix-daemon}, such as after running @code{guix pull}.  Assuming the store is in @file{/gnu}, you can do this with @code{restorecon -vR /gnu}, or by other means provided by your operating system."
msgstr "Dovrai rietichettare la directory dello store dopo tutti gli aggiornamenti a @file{guix-daemon}, come dopo aver eseguito @code{guix pull}. Supponendo che lo store sia in @file{/gnu}, puoi farlo con @code{restorecon -vR /gnu}, o con altri mezzi forniti dal tuo sistema operativo."

msgid "We could generate a much more restrictive policy at installation time, so that only the @emph{exact} file name of the currently installed @code{guix-daemon} executable would be labelled with @code{guix_daemon_exec_t}, instead of using a broad regular expression.  The downside is that root would have to install or upgrade the policy at installation time whenever the Guix package that provides the effectively running @code{guix-daemon} executable is upgraded."
msgstr "Potremmo generare una policy molto più restrittiva al momento dell'installazione, in modo che solo il nome @emph{exact} del file dell'eseguibile @code{guix-daemon} attualmente installato verrebbe etichettato con @code{guix_daemon_exec_t}, invece di usare un'espressione regolare generica. Lo svantaggio è che l'utente root dovrebbe installare o aggiornare la policy al momento dell'installazione ogni volta che il pacchetto Guix che fornisce l'eseguibile @code{guix-daemon} effettivamente in esecuzione viene aggiornato."

msgid "Invoking @command{guix-daemon}"
msgstr "Invocare @command{guix-daemon}"

msgid "guix-daemon"
msgstr "guix-daemon"

msgid "The @command{guix-daemon} program implements all the functionality to access the store.  This includes launching build processes, running the garbage collector, querying the availability of a build result, etc.  It is normally run as @code{root} like this:"
msgstr "Il programma @command{guix-daemon} implementa tutte le funzionalità per accedere allo store. Ciò include l'avvio dei processi di build, l'esecuzione del garbage collector, l'interrogazione sulla disponibilità di un risultato di build, ecc. Di solito viene eseguito come @code{root} in questo modo:"

msgid "socket activation, for @command{guix-daemon}"
msgstr "attivazione socket, per @command{guix-daemon}"

msgid "This daemon can also be started following the systemd ``socket activation'' protocol (@pxref{Service De- and Constructors, @code{make-systemd-constructor},, shepherd, The GNU Shepherd Manual})."
msgstr "Questo demone può anche essere avviato seguendo il protocollo di ``attivazione socket'' di systemd (@pxref{Service De- and Constructors, @code{make-systemd-constructor},, shepherd, The GNU Shepherd Manual})."

msgid "For details on how to set it up, @pxref{Setting Up the Daemon}."
msgstr "Per i dettagli su come configurarlo, @pxref{Setting Up the Daemon}."

msgid "container, build environment"
msgstr "container, ambiente di build"

msgid "deduplication"
msgstr "deduplicazione"

msgid "emacs"
msgstr "emacs"

msgid "Networking"
msgstr "Rete"

msgid "profile"
msgstr "profilo"

msgid "Going further"
msgstr "Andare oltre"

msgid "reproducibility"
msgstr "riproducibilità"

msgid "Update the file database."
msgstr "Aggiorna il database dei file."

msgid "derivation"
msgstr "derivation"

msgid "archive"
msgstr "archivio"

msgid "Voilà!"
msgstr "Ecco fatto!"

msgid "guix shell\n"
msgstr "guix shell\n"

msgid "container"
msgstr "container"

msgid "source"
msgstr "source"

msgid "build-system"
msgstr "build-system"

msgid "synopsis"
msgstr "synopsis"

msgid "description"
msgstr "description"

msgid "license"
msgstr "license"

msgid "home-page"
msgstr "home-page"

msgid "revision"
msgstr "revision"

msgid "module"
msgstr "module"

msgid "build"
msgstr "build"

msgid "Tip"
msgstr "Suggerimento:"

msgid "G-expression"
msgstr "espressione-G"

msgid "package transformation"
msgstr "trasformazione dei pacchetti"

msgid "package variants, transformation"
msgstr "varianti di pacchetto, trasformazione"

msgid "package"
msgstr "package"

msgid "inputs"
msgstr "inputs"

msgid "self"
msgstr "self"

msgid ""
"@dots{}\n"
"\n"
msgstr ""
"@dots{}\n"
"\n"

msgid "auto-login to TTY"
msgstr "auto-login to TTY"

msgid ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (services %my-services))\n"
msgstr ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (services %my-services))\n"

msgid "bootloader"
msgstr "bootloader"

msgid "input"
msgstr "input"

msgid "destination"
msgstr "destination"

msgid "log"
msgstr "log"

msgid "Bitmask"
msgstr "Bitmask"

msgid "Web Service Discovery Daemon"
msgstr "Demone per la scoperta dei servizi web"

msgid "mpd"
msgstr "mpd"

msgid "image"
msgstr "image"

msgid "authentication"
msgstr "authentication"

msgid "Shells Home Services"
msgstr "Servizi Home per le Shell"

msgid "Mcron Home Service"
msgstr "Servizio Home Mcron"

msgid "Power Management Home Services"
msgstr "Servizi Home di gestione energetica"

msgid "Shepherd Home Service"
msgstr "Servizio Home Shepherd"

msgid "Sway window manager"
msgstr "Window manager Sway"

msgid "contributing.texi"
msgstr "contributing.it.texi"

msgid "The Nix-based software distributions, Nixpkgs and NixOS, have also been an inspiration for Guix."
msgstr "Le distribuzioni software basate su Nix, Nixpkgs e NixOS, sono state anche un'ispirazione per Guix."

msgid "GNU@tie{}Guix itself is a collective work with contributions from a number of people.  See the @file{AUTHORS} file in Guix for more information on these fine people.  The @file{THANKS} file lists people who have helped by reporting bugs, taking care of the infrastructure, providing artwork and themes, making suggestions, and more---thank you!"
msgstr "GNU@tie{}Guix stesso è un lavoro collettivo con contributi di diverse persone. Consulta il file @file{AUTHORS} in Guix per maggiori informazioni su queste persone. Il file @file{THANKS} elenca le persone che hanno contribuito segnalando bug, curando l'infrastruttura, fornendo grafica e temi, dando suggerimenti e altro ancora --- grazie!"

msgid "license, GNU Free Documentation License"
msgstr "licenza, GNU Free Documentation License"

msgid "fdl-1.3.texi"
msgstr "fdl-1.3.texi"
