Fix broken links for jammit (heroku#338)

Co-authored-by: Johnathan Lyman <[email protected]>

content/cs/processes.md

@@ -9,6 +9,6 @@ V nejjednodušším případě je kód samostatný skript, běhové prostředí
 
 Paměť nebo souborový systém procesu mohou být využity jako krátkodobá cache pro jednu transakci. Například ke stažení velkého souboru, práce s ním a následné uložení výsledku do databáze. Twelve-factor aplikace nikdy nespoléhá, že cokoliv je nacachované v paměti nebo na disku, bude dostupné i v dalším požadavku. Při velkém počtu běžících procesů je vysoká pravděpodobnost, že další požadavek bude odbaven jiným procesem. I kdyby běžel pouze jeden proces, restart (způsobený nasazením nového kódu, změnou konfigurace nebo přemístěním procesu na jiné fyzické umístění) obvykle smaže všechny lokální (například pamět nebo souborový systém) stavy.
 
-Balíčkovače jako je [django-assetpackager](http:https://code.google.com/p/django-assetpackager/) používají souborový systém jako dočasné uložiště pro zkompilované soubory. Twelve-factor aplikace preferují kompilaci během [fáze sestavení](/build-release-run). Balíčkovače jako jsou [Jammit](http:https://documentcloud.github.com/jammit/) a [Rails asset pipeline](http:https://ryanbigg.com/guides/asset_pipeline.html) mohou být nastaveny tak, že soubory zabalí již během fáze sestavení.
+Balíčkovače jako je [django-assetpackager](http:https://code.google.com/p/django-assetpackager/) používají souborový systém jako dočasné uložiště pro zkompilované soubory. Twelve-factor aplikace preferují kompilaci během [fáze sestavení](/build-release-run). Balíčkovače jako jsou [Jammit](http:https://documentcloud.github.io/jammit/) a [Rails asset pipeline](http:https://ryanbigg.com/guides/asset_pipeline.html) mohou být nastaveny tak, že soubory zabalí již během fáze sestavení.
 
 Některé webové aplikace spoléhají na ["sticky sessions"](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence), tedy cachování uživatelských session v paměti procesu a směrování budoucích požadavků stejného návštěvníka na stejný proces. Sticky session jsou porušením twelve-factor metodiky a neměli by se používat a ani by se na ně nemělo jakkoliv spoléhat. Sticky session data jsou vhodným kandidátem pro uložiště, která podporují časovou expiraci dat, jako jsou například [Memcached](http:https://memcached.org/) nebo [Redis](http:https://redis.io/).

content/de/processes.md

@@ -9,6 +9,6 @@ Im einfachsten Fall ist der Code ein Stand-alone-Skript, die Ausführungsumgebun
 
 Der RAM oder das Dateisystem des Prozesses kann als kurzfristiger Cache für die Dauer einer Transaktion verwendet werden. Zum Beispiel kann ein Prozess eine Datei herunterladen, sie verarbeiten und die Ergebnisse in einer Datenbank speichern. Die Zwölf-Faktor-App geht nie davon aus, dass irgendetwas aus dem RAM oder im Dateisystem zwischengespeichertes für einen künftigen Request oder Job verfügbar sein wird. Es ist gut möglich, dass ein künftiger Request von einem anderen Prozess bedient wird. Selbst wenn nur ein Prozess läuft, wird ein Neustart (verursacht durch Code Deployment, Konfigurationsänderung oder der Verlagerung der Ausführungsumgebung auf einen anderen physikalischen Ort) den gesamten lokalen Zustand (RAM und Dateisystem) löschen.
 
-Asset-Paketierer (wie [Jammit](http:https://documentcloud.github.com/jammit/) oder [django-compressor](http:https://django-compressor.readthedocs.org/)) benutzen das Dateisystem als Cache für kompilierte Assets. Eine Zwölf-Faktor-App wie die [Rails asset pipeline](http:https://guides.rubyonrails.org/asset_pipeline.html) würde diese Art von Kompilation eher in der [Build-Phase](./build-release-run) erledigen anstatt zur Laufzeit.
+Asset-Paketierer (wie [Jammit](http:https://documentcloud.github.io/jammit/) oder [django-compressor](http:https://django-compressor.readthedocs.org/)) benutzen das Dateisystem als Cache für kompilierte Assets. Eine Zwölf-Faktor-App wie die [Rails asset pipeline](http:https://guides.rubyonrails.org/asset_pipeline.html) würde diese Art von Kompilation eher in der [Build-Phase](./build-release-run) erledigen anstatt zur Laufzeit.
 
 Manche Web-Systeme verlassen sich auf ["Sticky Sessions"](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence) -- sie cachen Benutzer-Session-Daten im RAM des App-Prozesses und erwarten, dass künftige Requests desselben Benutzers zum selben Prozess geschickt werden. Sticky Sessions sind eine Verletzung der zwölf Faktoren und eine guter Kandidat für einen Datenspeicher, der ein zeitabhängiges Löschen anbietet, wie [Memcached](http:https://memcached.org/) oder [Redis](http:https://redis.io/).

content/el/processes.md

@@ -9,6 +9,6 @@
 
 Ο χώρος μνήμης ή το σύστημα αρχείων μιας διεργασίας μπορούν να χρησιμοποιηθούν ως μία σύντομη, μια και έξω προσωρινή μνήμη. Για παράδειγμα, να κατεβάσει ένα μεγάλο αρχείο, να δράσει πάνω σε αυτό, και να αποθηκέυσει τα αποτελέσματα στη βάση δεδομένων. Η εφαρμογή δώδεκα παραγόντων ποτέ δεν θεωρεί ως δεδομένο πως οτιδήποτε αποθηκέυτηκε προσωρινά στη μνήμη της ή στο δίσκο θα είναι διαθέσιμο και σε μια μελλοντική αίτηση για εξυπηρέτηση ή εργασία -- με πολλές διεργασίες κάθε τύπου να τρέχουν, οι πιθανότητες είναι υψηλές πως μια μελλοντική αίτηση για εξυπηρέτηση θα εξυπηρετηθεί από μια άλλη διεργασία. Ακόμα και εάν τρέχει μόνο μία διεργασία, μια επανεκκίνηση (πυροδοτημένη απο μια ανάπτυξη κώδικα, αλλαγή παραμέτρων, ή από το περιβάλλον εκτέλεσης που αλλάζει τη φυσική τοποθεσία της διεργασίας) συνήθως θα σβήσει όλη την τοπική (π.χ, μνήμη και σύστημα αρχείων) κατάσταση (state).
 
-Οι συσκευαστές περιουσιακών στοιχείων της εφαρμογής (asset packagers) όπως το [django-assetpackager](http:https://code.google.com/p/django-assetpackager/) χρησιμοποιούν το σύστημα αρχείων σαν προσωρινή μνήμη για μεταγλωττισμένα στοιχεία (compiled assets). Μια εφαρμογή δώδεκα παραγόντων προτιμά να κάνει αυτή τη μεταγλώττιση κατά το [στάδιο κατασκευής (build stage)](./build-release-run). Μερικοί συσκευαστές όπως το [Jammit](http:https://documentcloud.github.com/jammit/) και το [Rails asset pipeline](http:https://ryanbigg.com/guides/asset_pipeline.html) μπορούν να ρυθμιστούν ώστε να συσκευάσουν τα assets κατά το στάδιο κατασκευής.
+Οι συσκευαστές περιουσιακών στοιχείων της εφαρμογής (asset packagers) όπως το [django-assetpackager](http:https://code.google.com/p/django-assetpackager/) χρησιμοποιούν το σύστημα αρχείων σαν προσωρινή μνήμη για μεταγλωττισμένα στοιχεία (compiled assets). Μια εφαρμογή δώδεκα παραγόντων προτιμά να κάνει αυτή τη μεταγλώττιση κατά το [στάδιο κατασκευής (build stage)](./build-release-run). Μερικοί συσκευαστές όπως το [Jammit](http:https://documentcloud.github.io/jammit/) και το [Rails asset pipeline](http:https://ryanbigg.com/guides/asset_pipeline.html) μπορούν να ρυθμιστούν ώστε να συσκευάσουν τα assets κατά το στάδιο κατασκευής.
 
 Μερικά συστήματα ιστού (web systems) βασίζονται σε ["επίμονες συνεδρίες" ("sticky sessions")](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence) -- δηλαδή, αποθηκέυουν προσωρινά τη συνεδρία χρήστη στη μνήμη της διεργασίας της εφαρμογής και θεωρούν πως οι μελλοντικές αιτήσεις για εξυπηρέτηση απο τον ίδιο χρήστη θα δρομολογηθούν στην ίδια διεργασία. Οι επίμονες συνεδρίες συνιστούν παράβαση των δώδεκα παραγόντων και δεν θα πρέπει ποτέ να χρησιμοποιούνται ή η εφαρμογή να βασίζεται σε αυτές. Τα δεδομένα κατάστασης συνεδρίας είναι καλύτερα να αποθηκευτούν σε μια αποθήκη δεδομένων (datastore) που διαθέτει χρόνο λήξης, όπως το [Memcached](http:https://memcached.org/) ή το [Redis](http:https://redis.io/).

content/en/processes.md

@@ -9,6 +9,6 @@ In the simplest case, the code is a stand-alone script, the execution environmen
 
 The memory space or filesystem of the process can be used as a brief, single-transaction cache. For example, downloading a large file, operating on it, and storing the results of the operation in the database. The twelve-factor app never assumes that anything cached in memory or on disk will be available on a future request or job -- with many processes of each type running, chances are high that a future request will be served by a different process. Even when running only one process, a restart (triggered by code deploy, config change, or the execution environment relocating the process to a different physical location) will usually wipe out all local (e.g., memory and filesystem) state.
 
-Asset packagers like [django-assetpackager](http:https://code.google.com/p/django-assetpackager/) use the filesystem as a cache for compiled assets. A twelve-factor app prefers to do this compiling during the [build stage](/build-release-run). Asset packagers such as [Jammit](http:https://documentcloud.github.com/jammit/) and the [Rails asset pipeline](http:https://ryanbigg.com/guides/asset_pipeline.html) can be configured to package assets during the build stage.
+Asset packagers like [django-assetpackager](http:https://code.google.com/p/django-assetpackager/) use the filesystem as a cache for compiled assets. A twelve-factor app prefers to do this compiling during the [build stage](/build-release-run). Asset packagers such as [Jammit](http:https://documentcloud.github.io/jammit/) and the [Rails asset pipeline](http:https://ryanbigg.com/guides/asset_pipeline.html) can be configured to package assets during the build stage.
 
 Some web systems rely on ["sticky sessions"](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence) -- that is, caching user session data in memory of the app's process and expecting future requests from the same visitor to be routed to the same process. Sticky sessions are a violation of twelve-factor and should never be used or relied upon. Session state data is a good candidate for a datastore that offers time-expiration, such as [Memcached](http:https://memcached.org/) or [Redis](http:https://redis.io/).

content/es/processes.md

@@ -9,6 +9,6 @@ El caso más sencillo que podemos plantear es que el código es un script indepe
 
 Tanto el espacio de memoria de un proceso como el sistema de ficheros se pueden usar como si fueran una cache temporal para hacer transacciones. Por ejemplo, descargar un fichero de gran tamaño, realizar alguna operación sobre él, y almacenar sus resultados en una base de datos. Las aplicaciones "twelve-factor" nunca dan por hecho que cualquier cosa cacheada en memoria o en el disco vaya a estar disponible al realizar una petición al ejecutar diferentes procesos. Con muchos procesos de cada tipo ejecutándose al mismo tiempo, existe una gran probabilidad de que otro proceso distinto sirva una petición en el futuro. Incluso cuando solo está corriendo un solo proceso, un reinicio (provocado por el despliegue de código, un cambio de configuración o un cambio de contexto del proceso) normalmente elimina todo el estado local (e.g. memoria y sistema de ficheros).
 
-Los compresores de estáticos (como [Jammit](http:https://documentcloud.github.com/jammit/) o [django-compressor](http:https://django-compressor.readthedocs.org/)) usan el sistema de ficheros como una cache para ficheros compilados. En las aplicaciones "twelve-factor" es preferible realizar esta compilación durante la [fase de construcción](./build-release-run), como con el [asset pipeline de Rails](http:https://guides.rubyonrails.org/asset_pipeline.html), en lugar de hacerlo en tiempo de ejecución.
+Los compresores de estáticos (como [Jammit](http:https://documentcloud.github.io/jammit/) o [django-compressor](http:https://django-compressor.readthedocs.org/)) usan el sistema de ficheros como una cache para ficheros compilados. En las aplicaciones "twelve-factor" es preferible realizar esta compilación durante la [fase de construcción](./build-release-run), como con el [asset pipeline de Rails](http:https://guides.rubyonrails.org/asset_pipeline.html), en lugar de hacerlo en tiempo de ejecución.
 
 Algunos sistemas webs dependen de ["sticky sessions"](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence), esto quiere decir que cachean la información de la sesión de usuario en la memoria del proceso de la aplicación y esperan peticiones futuras del mismo visitante para redirigirle al mismo proceso. Las "sticky sessions" son una violación de "twelve-factor" y no deberían usarse nunca ni depender de ellas. La información del estado de la sesión es un candidato perfecto para almacenes de información que ofrecen mecanismos de tiempo de expiración, como [Memcached](http:https://memcached.org/) o [Redis](http:https://redis.io/).

content/fr/processes.md

@@ -9,7 +9,7 @@ Dans la situation la plus simple, le code est un script indépendant, l'environn
 
 L'espace mémoire ou le système de fichier du processus peut être utilisé comme cache momentané pour des transactions uniques. Par exemple, télécharger un gros fichier, effectuer une opération dessus, puis stocker le résultat de l'opération dans la base de données. Les applications 12 facteurs ne supposent jamais que quelque chose ayant été mis en cache en mémoire ou sur le disque sera disponible dans une future requête ou job — avec plusieurs processus de chaque type qui s'exécutent, il y a de grandes chances qu'une future requête soit effectuée par un processus différent. Même lorsque l'on fait tourner seulement un processus, un redémarrage (déclenché par le déploiement du code, un changement de configuration, ou l'environnement d'exécution qui déplace le processus vers un lieu physique différent) va généralement balayer toutes les modifications locales (c'est-à-dire en mémoire et sur le disque).
 
-Des outils de création de paquets de ressources (ou "asset packagers") (tel que [Jammit](http:https://documentcloud.github.com/jammit/) ou [django-compressor](http:https://django-compressor.readthedocs.org/)) utilisent le système de fichier comme cache pour les ressources compilées. Une application 12 facteurs préfère faire cette compilation durant l'[étape d'assemblage](./build-release-run), comme avec le [pipeline des ressources de Rails](http:https://guides.rubyonrails.org/asset_pipeline.html), plutôt que durant l'exécution.
+Des outils de création de paquets de ressources (ou "asset packagers") (tel que [Jammit](http:https://documentcloud.github.io/jammit/) ou [django-compressor](http:https://django-compressor.readthedocs.org/)) utilisent le système de fichier comme cache pour les ressources compilées. Une application 12 facteurs préfère faire cette compilation durant l'[étape d'assemblage](./build-release-run), comme avec le [pipeline des ressources de Rails](http:https://guides.rubyonrails.org/asset_pipeline.html), plutôt que durant l'exécution.
 
 Certains systèmes web s'appuient sur des ["sessions persistantes" (en)](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence) -- c'est-à-dire, mettre en cache les données de session utilisateur dans le processus de l'application et attendre que les requêtes futures du même visiteur seront routées dans le même processus. Les sessions persistantes sont une violation des 12 facteurs, qu'il ne faudrait jamais utiliser.
 Les états de session sont de bons candidats pour un datastore qui offre des dates d'expiration, comme [Memcached](http:https://memcached.org/) ou [Redis](http:https://redis.io/).

content/it/processes.md

@@ -9,6 +9,6 @@ Nel caso più semplice, il codice non è che uno script stand-alone, l'ambiente
 
 Lo spazio di memoria o il filesystem di un processo possono essere visti come una "singola transazione" breve. Come il download di un file, le successive operazioni su di esso e infine la memorizzazione del risultato sul database. Un'app twelve-factor non assume mai che qualsiasi cosa messa in cache sarà poi disponibile successivamente -- con tanti processi in esecuzione, le possibilità che una certa richiesta venga servita da un altro processo sono molto alte. Comunque, anche nel caso in cui si usi un singolo processo in esecuzione, un riavvio (dovuto a deployment di codice, cambio di file di configurazione e così via) resetterà lo stato in cui si trova il sistema.
 
-I packager di asset (come [Jammit](http:https://documentcloud.github.com/jammit/) o [django-compressor](http:https://django-compressor.readthedocs.org/)) usano il filesystem come cache per gli asset compilati. Un'app twelve-factor vuole questa compilazione durante la [fase di build](./build-release-run), così come [l'asset pipeline di Rails](http:https://guides.rubyonrails.org/asset_pipeline.html), e non a runtime.
+I packager di asset (come [Jammit](http:https://documentcloud.github.io/jammit/) o [django-compressor](http:https://django-compressor.readthedocs.org/)) usano il filesystem come cache per gli asset compilati. Un'app twelve-factor vuole questa compilazione durante la [fase di build](./build-release-run), così come [l'asset pipeline di Rails](http:https://guides.rubyonrails.org/asset_pipeline.html), e non a runtime.
 
 Alcuni sistemi web si basano inoltre sulle cosiddette ["sticky sessions"](http:https://en.wikipedia.org/wiki/Load_balancing_%28computing%29#Persistence) -- che consistono nel mettere in cache i dati di sessione dell'utente presenti nella memoria del processo, aspettandosi future richieste identiche dallo stesso visitatore, venendo quindi reindirizzati allo stesso processo. Le sticky session sono una palese violazione della metodologia twelve-factor. I dati di sessione sono un ottimo candidato per quei sistemi di datastore che offrono la feature di scadenza, come [Memcached](http:https://memcached.org/) o [Redis](http:https://redis.io/).