glossary.yml

- slug: 68_95_997_rule
  de:
    term: "68-95-99.7 Regel"
    def: >
      Drückt die Tatsache aus, dass 68% der Werte innerhalb einer
      [Standardabweichung](#standard_deviation) vom Mittelwert liegen,
      95% innerhalb von zwei und 99,7% innerhalb von drei. Umgekehrt
      liegen etwa 0,3% der Werte in den meisten Fällen mehr als drei
      Standardabweichungen über oder unterhalb des Mittelwerts.
  en:
    term: "68-95-99.7 rule"
    def: >
      Expresses the fact that 68% of values lie within one [standard
      deviation](#standard_deviation) of the [mean](#mean), 95% lie within two, and
      99.7% lie within three. Conversely, about 0.3% of values lie more than three
      standard deviations above or below the mean in most cases.
  af:
    term: "68-95-99.7 reël"
    def: >
      Beskryf die beginsel dat 68% van alle waardes binne een
      [standaardafwyking](#standard_deviation) van die [gemiddelde](#mean) val, 95%
      val binne twee en 99.7% val binne drie standaardafwykings. Omgekeerd, in die
      meeste gevalle val 0.3% van die waardes meer as drie standaardafwykings bo of
      onder die gemiddelde.
  pt:
    term: "regra 68-95-99,7"
    def: >
      Expressa o fato de que 68% dos valores estão dentro de um [desvio padrão](#standard_deviation)
      da [média](#mean), 95% estão dentro de dois e 99,7% estão dentro de três. Inversamente,
      aproximadamente 0,3% dos valores estão mais do que três desvios padrões acima ou abaixo da média
      na maioria dos casos.
  fr:
    term: "règle de 68-95-99.7"
    def: >
      Exprime le fait que 68% des valeurs sont localisées à l'intérieur d'un (1)
      [écart-type](#standard_deviation) de la [moyenne](#mean), 95% à l'intérieur de
      deux (2) écarts-types, et 99,7% à l'interieur de trois (3) écarts-types.
      Inversement et dans la plupart des cas, environ 0.3% des valeurs se situent à
      plus de 3 écarts-types au-dessus ou au-dessous de la moyenne.
  ar:
    term: "القاعدة ٩٩,٧-٩٥-٦٨"
    def: >
        يُعبِر عن حقيقة أن ٦٨٪ من القيم تقع ضمن وحدة واحدة من
        [الانحراف المعياري](#standard_deviation)
        من
        [الوسط](#mean)
        ، بينما ٩٥٪ تقع ضمن وحدتين،
        و٩٩,٧٪ تقع ضمن ثلاث وحدات
        بالمقابل ، حوالي ٠,٣ ٪  من القيم تقع  في أكثر من ثلاثة وحدات
        من الانحرافات المعيارية أعلى أو أقل من المتوسط في معظم الحالات.


- slug: abandonware
  de:
    term: "Abandonware"
    def: >
      Software die nicht länger weiterentwickelt wird.
  en:
    term: "abandonware"
    def: >
      Software that is no longer being maintained.
  pt:
    term: "abandonware"
    def: >
      Software que não é mais mantido.
  af:
    term: "afgooiware"
    def: >
      Sagteware wat nie meer onderhou word nie.
  es:
    term: "abandonware"
    def: >
      Software cuyo mantenimiento ha sido abandonado.
  fr:
    term: "abandonware"
    def: >
      Un logiciel qui n'est plus maintenu.
  ar:
    term: "البرمجيات المهجورة أو المتروكة"
    def: >
       هي البرامج التى لايتوفر لها دعم من أي برمجيات أُخرى
       ولم تعد على قيد الصيانة.


- slug: absolute_error
  de:
    term: "Absoluter Fehler"
    def: >
      Der absolute Wert der Differenz zwischen dem beobachteten und
      dem korrekten Wert. Der absolute Fehler ist normalerweise
      weniger nützlich als der [relative Fehler](#relative_error).
  en:
    term: "absolute error"
    def: >
      The absolute value of the difference between the observed and the correct value.
      Absolute error is usually less useful than [relative error](#relative_error).
  af:
    term: "absolute fout"
    def: >
      Die absolute fout is die absolute waarde van die verskil tussen die waargenome-
      en die korrekte waarde. Die absolute fout is gewoonlik van minder waarde as die
      [relatiewe](#relative_error) fout.
  pt:
    term: "erro absoluto"
    def: >
      O valor absoluto da diferença entre um valor observado e o valor correto. O erro
      absoluto é normalmente menos útil do que o [erro relativo](#relative_error).
  fr:
    term: "erreur absolue"
    def: >
      La valeur absolue de la différence entre la valeur observée et la valeur
      correcte. L'erreur absolue est généralement moins pertinente que l'[erreur relative](#relative_error).
  ar:
    term: "الخطأ المُطلق"
    def: >
       هو عبارة عن القيمة المطلقة للفرق بين القيمة المرصودة والقيمة الواقعية الصحيحة،
       مع العِلم أن
       الخطأ المُطلق عادة مايكون أقل فائدة من
       [الخطأ النسبي](#relative_error).


- slug: absolute_path
  ref:
    - relative_path
  en:
    term: "absolute path"
    def: >
      A path that points to the same location in the [filesystem](#filesystem)
      regardless of where it is evaluated. An absolute path is the equivalent of
      latitude and longitude in geography.
  af:
    term: "absolute roete"
    def: >
      'n Roete wat dieselfde posisie in die [lêerstelsel](#filesystem) aandui ongeag
      die posisie vanwaar dit geëvalueer word. Die absolute roete is die ekwivalent
      van lengtegraad en breedtegraad in geografie.
  fr:
    term: "chemin d'accès absolu"
    def: >
      Un chemin d'accès absolu indique la même position dans le système de fichier
      quelque soit l'emplacement où il est evalué. Un chemin d'accès absolu est
      l'équivalent de la latitude et longitude en géographie.
  es:
    term: "ruta absoluta"
    def: >
      Una ruta que dirige a la misma ubicación en el sistema de archivos
      independientemente del contexto donde sea evaluada. Una ruta absoluta es el
      equivalente a la latitud y longitud en geografía.
  pt:
    term: "caminho absoluto"
    def: >
      Um caminho que leva ao mesmo local no sistema de arquivos independente do
      contexto em que é avaliado. Um caminho absoluto pode ser comparado com a
      latitude e longitude em geografia.
  ar:
    term: "المسار المُطلق"
    def: >
        المسار الذي يُشير إلى ذات الموقع في
        [نظام الملفات](#filesystem)،
        بغض النظر عن مكان تقييمها،
        وللتبسيط يمكن أن يُقال أن
        المسار المُطلق يُعادل خطوط الطول والعرض في الجغرافيا.


- slug: absolute_row_number
  de:
    term: "Absolute Zeilennummer"
    def: >
      Der sequentielle Index einer Zeile in einer Tabelle, unabhängig
      davon, welche Abschnitte der Tabelle angezeigt werden.
  en:
    term: "absolute row number"
    def: >
      The sequential index of a row in a table, regardless of what sections of the
      table is being displayed.
  af:
    term: "absolute rynommer"
    def: >
      Die opeenvolgende indeks van 'n ry in 'n tabel, ongeag die gedeelte van die
      tabel wat vertoon word.
  es:
    term: "número de fila absoluto"
    def: >
      El índice secuencial que indentifica una fila en un tablero, sin importar qué
      secciones se estén mostrando.
  pt:
    term: "número de linha absoluto"
    def: >
      O índice sequencial de uma linha em uma tabela, independente de qual seção da
      tabela está sendo exibida.
  he:
    term: "מספר שורה מוחלט"
    def: >
      המספר הסידורי של שורה בטבלה, ללא קשר לאילו חלקים של הטבלה מוצגים
  ar:
    term: "رقم الصف المُطلق"
    def: >
        هو الفهرس المتسلسل لصف في جدول، بغض النظر عن أي قسم من اقسام الجدول يتم عرضها.


- slug: abstract_method
  de:
    term: "Abstrakte Methode"
    def: >
      In der [objektorientierten Programmierung](#oop) eine
      [Methode](#method), die zwar definiert, aber nicht implementiert
      ist. Programmierer definieren eine abstrakte Methode in einer
      [übergeordneten Klasse](#parent_class), um Operationen zu
      spezifizieren, die die [untergeordneten Klassen](#child_class)
      bereitstellen müssen.
  en:
    term: "abstract method"
    def: >
      In [object-oriented programming](#oop), a [method](#method) that is defined but
      not implemented. Programmers will define an abstract method in a [parent
      class](#parent_class) to specify operations that [child classes](#child_class)
      must provide.
  af:
    term: "abstrakte metode"
    def: >
      'n [Metode](#method), in [objekgeoriënteerde programmering](#oop), wat
      gedefiniëer maar nie geïmplementeer is nie. Programmeerders sal 'n abstrakte
      metode in 'n [voorsaatklas](#parent_class) definiëer wat in
      [nasaatklasse](#child_class) geïmplementeer moet word.
  pt:
    term: "método abstrato"
    def: >
      In [programação orientada a objetos](#oop), um [método](#method) que é definido
      mas não implementado. Pessoas programadoras definem um método abstrato em uma [classe base](#parent_class)
      para especificar operações que as [classes derivadas](#child_class) devem prover.
  ar:
    term: "الطريقة المجردة"
    def: >
      الطريقة المجردة هو تعبير يُتخدم
      في
      [البرمجة الشيئية](#oop)
      ،
      هذه
       [الطريقة](#method)
      يتم تعريفها ولكن لم لايتم تنفيذها،
      بمعنى آخر، المبرمجون يُعرِفون عادة طريقة مجردة في
      [الفئه الرئيسية](#parent_class)
      لتحديد العمليات التي يجب أن تقدمها
      [الفئات الفرعية](#child_class).


- slug: abstract_syntax_tree
  en:
    term: "abstract syntax tree"
    acronym: "AST"
    def: >
      A deeply nested data structure, or [tree](#tree), that represents the structure
      of a program. For example, the AST might have a [node](#node) representing a
      [`while` loop](#while_loop) with one [child](#child_tree) representing the loop
      condition and another representing the [loop body](#loop_body).
  af:
    term: "abstrakte sintaksisontledingsboom"
    def: >
      'n Diepgeneste datastruktuur, of [boom](#tree), wat die struktuur van 'n program
      verteenwoordig. Byvoorbeeld, as die abstrakte sintaksontledingsboom 'n
      [nodus](#node) het wat 'n [`doen` terwyl-lus](#while_loop) verteenwoordig wat
      met een [naasaatontledingsboom](#child_tree) die lustoestand verteenwoordig en
      'n ander nasaatontledingsboom wat die [lusraam](#loop_body) verteenwoordig.


- slug: actual_result
  de:
    term: "Tatsächliche Ergebnis"
    def: >
      Der Wert, der durch Ausführen von Code in einem Test erzeugt
      wird. Wenn dieser Wert mit dem [erwarteten
      Ergebnis](#expected_result) übereinstimmt, ist der Test
      bestanden; wenn die beiden Werte unterschiedlich sind, [schlägt
      der Test fehl](#fail_test).
  en:
    term: "actual result (of test)"
    def: >
      The value generated by running code in a test. If this matches the [expected
      result](#expected_result), the test [passes](#pass_test); if the two are
      different, the test [fails](#fail_test).
  af:
    term: "absolute resultaat (van 'n toets)"
    def: >
      Die waarde wat deur 'n toets gegenereer is. Indien dié waarde gelyk is aan die
      [verwagte resultaat](#actual_result), is die toets suksesvol; as die twee
      waardes verskil het die toets gefaal.
  ar:
    term: "النتيجة الفعلية للإختِبار"
    def: >
      القيمة الناتجة عن تشغيل إختبار للتعليمات البرمجية، إذا كانت هذه النتيجة تُطابِق
      [النتيجة المتوقعة](#expected_result)
      فإن الإختبار
      [تم نجاحه](#pass_test)
      و اذا كان النتيجتين مختلفتين فان الاختبار قد
      [فشل](#fail_test).


- slug: affordance
  en:
    term: "affordance"
    def: >
      A property of something that suggests how it can be used, such as a handle or button.
  af:
    term: "bekostigbaarheid"
    def: >
      'n Einskap van iets wat aandui hoe dit gebruik kan word, bevoorbeeld 'n
      lêerhanteerder of 'n knoppie.


- slug: aggregation
  en:
    term: "aggregation"
    def: >
      To combine many values into one, e.g., by summing a set of numbers or
      concatenating a set of strings.
  es:
    term: "agregación"
    def: >
      Combinar muchos valores en uno, por ejemplo, sumando una serie de números o
      concatenando un conjunto de cadenas de caracteres.
  fr:
    term: "agrégation"
    def: >
      Synthétise plusieurs valeurs en une seule, example, en sommant plusieurs nombres
      ou en concaténant un ensemble de caractères.
  af:
    term: "samevoeging"
    def: >
      Om 'n groep waardes in een te kombineer bv. om 'n versameling getalle op te som
      of om 'n versameling alfabetiese stringe aaneen te skakel.
  pt:
    term: "agregação"
    def: >
      Combinar vários valores em um, por exemplo, somando um conjunto numérico ou
      concatenando um conjunto de caracteres.


- slug: aggregation_function
  en:
    term: "aggregation function"
    def: >
      A function that combines many values into one, such as `sum` or `max`.
  es:
    term: "función de agregación"
    def: >
      Una función que combina varios valores en uno, como `sum` o `max`.
  fr:
    term: "fonction d'agrégation"
    def: >
      Une fonction qui permet de synthétiser plusieurs valeurs en une seule, example,
      'sum' ou 'max'.
  pt:
    term: "função de agregação"
    def: >
      Uma função que combina muitos valores em um só, como `sum` ou `max`.
  af:
    term: "aggregaatfunksie"
    def: >
      'n Funksie wat 'n groep waardes saamvoeg, bv. `sum` (summering) en `max`
      (maksimale waarde)


- slug: agile
  en:
    term: "agile development"
    def: >
      A software development methodology that emphasizes lots of small steps and
      continuous feedback instead of up-front planning and long-term scheduling.
      [Exploratory programming](#exploratory_programming) is often agile.
  af:
    term: "lenige ontwikkeling"
    def: >
      'n Sagteware-ontwikkelingsmetode wat die klem lê op vele klein stappies en
      deurlopende terugvoering in plaas van vooraf beplanning en langtermyn
      skeduluering. [Verkennende programmering](#exploratory_programming) is dikwel lenig.
  pt:
    term: "desenvolvimento ágil"
    def: >
      Um método de desenvolvimento de software que enfatiza vários passos pequenos e
      feedback contínuo ao invés de planejamento de longo prazo. [Programação exploratória](#exploratory_programming)
      costuma ser ágil.


- slug: aliasing
  en:
    term: "aliasing"
    def: >
      To have two or more references to the same thing, such as a data structure in
      memory or a file on disk.
  af:
    term: "aliasering"
    def: >
      Om twee of meer verwysing na dieselfde ding te hê, soos byvoorbeeld meer as een
      verwysing na 'n datastruktuur in geheue of na 'n lêer op 'n skyf.


- slug: anchor
  en:
    term: "anchor"
    def: >
      In a [regular expression](#regular_expression), a symbol that fixes a position
      without matching characters. `^` matches the start of the line, while `$`
      matches the end of the line and `\b` matches a break between word and non-word characters.
  af:
    term: "anker"
    def: >
      In 'n [gewone (reguliere) uitdrukking](#regular_expression), is 'n anker 'n
      simbool wat 'n posisie aandui, bv. `^` dui die begin van 'n lyn aan en `$` dui
      die einde van 'n lyn aan. 'n Uidrukking soos bv. `^Die` anker die soektog na die
      woord `Die` aan die begin van die lyn.
  fr:
    term: "ancre"
    def: >
      C'est un symbole utilisé dans les expressions régulières (#regular_expression)
      afin de déterminer une position sans pour autant identifier des charactères. `^`
      détermine le début d'une ligne, tandis que `$` détermine sa fin. `\b` identifie
      un espace entre un mot et un non-mot.
  pt:
    term: "âncora"
    def: >
      Em uma [expressão regular](#regular_expression), é um símbolo que fixa uma posição sem caracteres
      correspondentes. `^` identifica o começo de uma linha, enquanto `$` indica o fim de uma linha e
      `\b` identifica uma quebra entre caracteres que formam e que não formam uma palavra.


- slug: anonymous_function
  en:
    term: "anonymous function"
    def: >
      A function that has not been assigned a name. Anonymous functions are usually
      quite short, and are usually defined where they are used, e.g., as callbacks.
      In [Python](#python), these are called lambda functions and are created through use of the
      lambda reserved word.
  af:
    term: "anonieme funksie"
    def: >
      'n Funksie waaraan daar nie 'n naam toegeken is nie. Anonieme funksies is
      gewoonlik baie kort en word gewoonlik gedefinieer waar hulle gebruik word bv. in
      die geval van 'n [terugskakelfunksie](#callback).
  fr:
    term: "fonction anonyme"
    def: >
      Une fonction qui ne s'est pas vue assignée de nom. Les fonctions anonymes sont
      en général courtes et définies là où elles sont utilisées, exemple: callbacks
  ar:
    term: "دالة مجهولة"
    def: >
       هي دالة  لم يتم تعيين اسم لها، عادةً ما تكون الدوال المجهولة قصيرة جدًا
       وعادة ما يتم تحديدها في الموضع الذي يتم استخدامها ،مثل عمليات رد الإتصال
       (callback).
       لكن
       في 
       لغة
       [Python](#python)
        تسمى هذه وظائف lambda ويتم إنشاؤها من خلال استخدام كلمة lambda المتداوله.


- slug: anti_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "anti join"
    def: >
      A [join](#join) that keeps rows from table A whose keys do *not* match keys in
      table B.
  af:
    term: "anti-koppeling"
    def: >
      'n [Koppeling](#join) wat rye in tabel A bevat wie se sleutels *nie* die
      sleutels van tabel B bevat nie.


- slug: api
  en:
    term: "Application Programming Interface"
    acronym: "API"
    def: >
      A set of functions and procedures provided by one software library or web
      service through which another application can communicate with it. An API is not
      the code, the database, or the server: it's the access point.
  af:
    term: "Toepassing Programmeerderkoppelvlak"
    def: >
      n Versameling funksies en prosedures wat deur 'n sagtewareprogrammateek of
      webdiens voorsien word vir gebruik deur ander toepassings om met die
      programmateek of webdiens te kommunikeer. Die API is nie die kode, die databasis
      of die bediener nie, dit is die koppelvlak.


- slug: append_mode
  en:
    term: "append mode"
    def: >
      To add data to the end of an existing file instead of overwriting the previous
      contents of that file. Overwriting is the default, so most programming languages
      require programs to be explicit about wanting to append instead.
  af:
    term: "byvoeg modus"
    def: >
      Om data aan die einde van 'n lêer te voeg in plaas daarvan om die inhoud van
      dielêer te oorskryf. Oorskryf is die verstek, wat beteken dat
      meesteprogrammeertale verwag dat programme eksplisiet moet aandui dat daar
      bygevoeg inplaas van oorskryf moet word.


- slug: argument
  en:
    term: "argument"
    def: >
      The term should not be confused with, and is not a synonym for,
      [parameter](#parameter). An argument is one of possibly several expressions
      that are passed to a function. It is the actual value that is passed.
      Parameters and arguments are distinct, but related concepts. Parameters are
      variables and arguments are the values assigned to those variables.
  es:
    term: "argumento"
    def: >
      Un valor pasado a una función. Algunos autores usan el término como sinónimo de
      [parámetro](#parameter) y algunos no; Todo es muy confuso.
  pt:
    term: "argumento"
    def: >
      Um valor passado para uma função. Algumas pessoas autoras usam este termo como
      sinônimo de parâmetro(#parameter) e outras não fazem isso; é tudo bastante confuso.
  ar:
    term: "وسيطة"
    def: >
      قيمة يتم تمريرها إلى دالة أو وسيطة ، البعض يُطلِق عليها مصطلح
      [مُعطى](#parameter)
      والبعض الآخر يُطلِق عليها مصطلح وسيطة.
  af:
    term: "argument"
    def: >
      Die term moet nie verwar word met [parameter](#parameter) nie en is ook nie 'n
      sinoniem daarvoor nie. 'n Argument is die spesifieke waarde wat aan 'n funksie
      verskaf word in 'n lys van waardes wat deur kommas geskei word
      Die term moet nie verwar word met [parameter](#parameter) nie en is ook nie 'n
      sinoniem daarvoor nie. 'n Argument is die spesifieke waarde wat aan 'n funksie
      verskaf word in 'n lys van waardes wat deur kommas geskei word. Parameters is
      die veranderlikes en argumente is die waardes wat aan die veranderlikes toegeken is.


- slug: arithmetic_mean
  en:
    term: "arithmetic mean"
    def: >
      See [mean](#mean).
  pt:
    term: "média aritmética"
    def: >
      Veja [média](#mean).
  af:
    term: "rekenkundige gemiddelde"
    def: >
      Sien [gemiddelde](#mean).


- slug: ascii
  en:
    term: "ASCII"
    def: >
      A standard way to represent the characters commonly used in the Western European
      languages as 7- or 8-bit integers, now superceded by [Unicode](#unicode).
  af:
    term: "ASCII"
    def: >
      'n Standaard manier om karakters wat algemeen in Wes-Europese tale gebruik word,
      voor te stel as 7- of 8-bis heelgetalle. ASCII word vervang deur [Unicode](#unicode).


- slug: assertion
  en:
    term: "assertion"
    def: >
      A [Boolean](#boolean) expression that must be [true](#true) at a certain point in a
      program. Assertions may be built into the language (e.g., [Python](#python)'s
      `assert` statement) or provided as functions (e.g., [R](#r_language)'s `stopifnot`). They are
      often used in testing, but are also put in [production code](#production_code)
      to check that it is behaving correctly. In many languages, assertions should not be
      used to perform data-validation as they may be silently dropped by compilers and interpreters
      under optimization conditions. Using assertions for data validation can therefore
      introduce security risks. Unlike many languages, R does not have an `assert` statement
      which can be disabled, and so use of [package](#package) such as `assertr` for data
      validation does not create security holes.
  af:
    term: "bewering"
    def: >
      'n [Boole](#boolean)-uitdrukking wat waar moet wees op 'n spesifiek plek
      in 'n program. 'n Bewering kan ingebou wees in 'n programmeertaal (bv.
      [Python](#python) het 'n ingeboude beweerstelling - assert) of dit kan
      voorsien word as 'n funksie (bv. [R](#r_language) gebruik `stopifnot`).
      Bewerings word dikwels gebruik gedurende die toetsfase van sagtewareontwikkeling
      maar dit word ook gebruk in [produksieskode](#production_code) om te
      bevestig dat die kode reg werk. In sommige tale moet die gebruik van
      bewerings as 'n datageldigheidstoets vermy word aangesien sommige
      kompileerders en interpreteerders die bewering stilweg weggooi onder
      optimeringsvoorwaardes. Die gebruik van bewerings vir bevestiging van
      datageldigheid kan dus sekuriteitsrisikos veroorsaak. R het nie 'n
      beweringstelling wat gedeaktiveer kan word nie en dus sal die gebruik
      van 'n [pakket](#package) soos 'assertr' vir datageldigheid nie
      sekuriteitsgapings skep nie.


- slug: associative_array
  en:
    term: "associative array"
    def: >
      See [dictionary](#dictionary).
  af:
    term: "assosiatiewe skikking"
    def: >
      Sien [woordeboek](#dictionary).


- slug: asynchronous
  ref:
    - synchronous
  en:
    term: "asynchronous"
    def: >
      Not happening at the same time. In programming, an asynchronous operation is one
      that runs independently of another, or that starts at one time and ends at another.
  af:
    term: "asinchronies"
    def: >
      Asinchronies is die teenoorgestelde van sinchronies wat beteken dat twee of meer 
      aktiwiteite tergelykertyd plaasvind. In programering is 'n asinchorniese bewerking 'n 
      bewerking wat onafhanklik van 'n ander een plaasvind.


- slug: attribute
  en:
    term: "attribute"
    def: >
      A name-value pair associated with an object, used to store metadata about the
      object such as an array's dimensions.
  fr:
    term: "attribut"
    def: >
      Un couple nom-valeur associé à un objet et utilisé pour stocker des métadonnées
      concernant ce dernier, example, les dimensions d'un tableau.
  af:
    term: "eienskap"
    def: >
      'n Naam-waarde paar wat verband hou met 'n voorwerp en gebruik word om 
      metadata omtrent die voorwerp te stoor, bv. die afmetings van 'n skikking.


- slug: auto_completion
  en:
    term: "auto-completion"
    def: >
      A feature that allows the user to finish a word or code quickly through the use
      of pressing the TAB key to list possible words or code from which the user can select.
  fr:
    term: "auto-complétion"
    def: >
      Une fonctionnalité permettant à l'utilisateur de finir rapidement un mot ou du
      code à travers l'utilisation de la touche TAB qui liste le mot ou le code
      susceptible d'être choisi par l'utilisateur.
  pt:
    term: "auto-completar"
    def: >
      Uma funcionalidade que permite a pessoa usuária terminar uma palavra ou código rapidamente
      ao pressinar a tecla TAB para listar possíveis palavras ou códigos que podem ser escolhidos.
  af:
    term: "outomatiese voltooing"
    def: >
      'n Funksie wat 'n gebruiker toelaat om 'n woord of 'n kode vinnig te voltooi deur die 
      TAB sleutel te druk om 'n lys van moontlike woorde of kodes te vertoon waaruit die gebruiker
      kan kies.


- slug: automatic_variable
  ref:
    - makefile
  en:
    term: "automatic variable"
    def: >
      A variable that is automatically given a value in a [build rule](#build_rule).
      For example, Make automatically assigns the name of a rule's
      [target](#build_target) to the automatic variable `$@`. Automatic variables are
      frequently used when writing [pattern rules](#pattern_rule).
  af:
    term: "outomatiese veranderlike"
    def: >
      'n Veranderlike waaraan daar outomaties 'n waarde toegeken word in [boureël](#build_rule). Byvoorbeeld, 
      "Make" ken outomaties die naam van 'n reël se teiken aan die outomatiese veranderlike, '$@' toe. 
      Outomatiese veranderlikes word dikwels gebruik tydens die skryf van [patroonreëls](#pattern_rule).


- slug: backpropagation
  en:
    term: "backpropagation"
    def: >
      An algorithm that iteratively adjusts the weights used in a [neural
      network](#neural_network). Backpropagation is often used to implement 
      [gradient descent](#gradient_descent).
  af:
    term: "terugwaartse voortplanting"
    def: >
      'n Algoritme wat die gewigte wat in 'n [neurale netwerk](#neural_network) gebruik word iteratief aanpas. Terugwaartse
      voortplanting word dikwels gebruik om [gradiënte afdaling](#gradient_descent) te implementeer.


- slug: backward_compatible
  en:
    term: "backward-compatible"
    def: >
      Software which is able to be used the same way as earlier versions of itself
      without problems.
  fr:
    term: "compatibilité descendante"
    def: >
      Ce dit d'un logiciel qui est capable d'être utilisé de la même manière que ses
      versions précédentes sans difficulté.
  pt:
    term: "compatibilidade reversa"
    def: >
      Software que pode ser usado da mesma maneira que versão anteriores de si mesmo
      sem problemas. Também é chamado de retrocompatibilidade.


- slug: base_r
  ref:
    - tidyverse
  en:
    term: "base R"
    def: >
      The basic functions making up the [R](#r_language) language. The base packages can be found in
      `src/library` and are not updated outside of R; their version numbers follow R
      version numbering. Base packages are installed and loaded with R, while priority
      packages are installed with base R but must be loaded prior to use.
  pt:
    term: "R base"
    def: >
      As funções básicas que compõe a linguagem [R](#r_language). Os pacotes de base podem ser encontrados
      em `src/library` e não são atualizados fora do R; eles seguem a numeração de versão do
      próprio R. Pacotes de base são instalados e carregados junto do R, enquanto pacotes
      prioritários são instalados com o R base mas precisam ser carregados antes do uso.


- slug: bayes_rule
  en:
    term: "Bayes' Rule"
    def: >
      See [Bayes' Theorem](#bayes_theorem).


- slug: bayes_theorem
  ref:
    - bayesian_network
    - naive_bayes_classifier
    - prior_distribution
  en:
    term: "Bayes' Theorem"
    def: >
      An equation for calculating the probability that something is [true](#true) if something
      related to it is true. If P(X) is the probability that X is true and P(X|Y) is
      the probability that X is true given Y is true, then P(X|Y) = P(Y|X) * P(X) / P(Y).


- slug: bayesian_network
  ref:
    - bayes_theorem
    - markov_chain
    - naive_bayes_classifier
  en:
    term: "Bayesian network"
    def: >
      A graph that represents the relationships between random variables for a given problem.


- slug: bias
  ref:
    - variance
    - overfitting
    - classification
    - systematic_error
  en:
    term: "bias"
    def: >
      A statistic is biased if it is systematically or consistently different from the
      parameter it is supposed to estimate.
  pt:
    term: "viés"
    def: >
      Uma estatística é enviesada se estiver sistemática ou consistentemente diferente
      do parâmetro que deveria estimar.


- slug: big_data
  ref:
    - three_vs
  en:
    term: "big data"
    def: >
      Any data that until recently was too big for most people to work with on a
      single computer.


- slug: binary
  en:
    term: "binary"
    def: >
      A system which can have one of two possible states. In computing often
      represented as being in the state 0 or 1. Represented in [Boolean](#boolean)
      logic as [false](#false) (0) or [true](#true) (1). Computers are built upon
      systems which store 0s and 1s as [bits](#bit).
  pt:
    term: "binário"
    def: >
      Um sistema que pode ter dois estados possíveis. Em computação, frequentemente
      sendo no estado 0 ou 1. Representado na lógica [Booleana](#boolean) como
      [falso](#false) (0) ou [verdadeiro](#true) (1). Computadores são construídos
      sobre sistemas que armazenam 0s e 1s como [bits](#bit).


- slug: binary_expression
  ref:
    - nullary_expression
    - ternary_expression
    - unary_expression
  en:
    term: "binary expression"
    def: >
      An expression which has two parameters and takes two arguments, such as `1 + 2`.
  pt:
    term: "expressão binária"
    def: >
      Uma expressão com dois argumentos ou parâmetros, como `1 + 2`, por exemplo.


- slug: binomial_distribution
  ref:
    - discrete_random_variable
    - histogram
  en:
    term: "binomial distribution"
    def: >
      A [probability distribution](#probability_distribution) that arises when there
      are a fixed number of trials, each of which can produce one of two outcomes, and
      the probability of those outcomes does not change. As the number of trials
      increases, the binomial distribution approximates a [normal distribution](#normal_distribution).
  pt:
    term: "distribuição binomial"
    def: >
      Uma [distribuição de probabilidade](#probability_distribution) que emerge quando há
      um número fixo de tentativas, cada uma das quais podendo produzir um de dois resultados e
      quando a probabilidade destes resultados não muda. Na medida em que o número de tentativas aumenta,
      a distribuição binomial se aproxima da [distribuição normal](#normal_distribution).


- slug: bit
  ref:
    - binary
    - boolean
  en:
    term: "bit"
    def: >
      A unit of information representing representing alternatives, yes/no,
      [true](#true)/[false](#false). In computing a state of either 0 or 1.
  pt:
    term: "bit"
    def: >
      Uma unidade de informação representando alternativas, sim/não,
      [verdadeiro](#true)/[falso](#false). Em computação, um estado de 0 ou 1.


- slug: blob
  en:
    term: "binary large object"
    acronym: "BLOB"
    def: >
      Data that is stored in a database without being interpreted in any way, such as
      an audio file. The term is also now used to refer to data transferred over a
      network or stored in a [version control](#version_control_system)
      [repository](#repository) as uninterpreted bits.


- slug: block_comment
  en:
    term: "block comment"
    def: >
      A [comment](#comment) that spans multiple lines. Block comments may be marked
      with special start and end symbols, like `/*` and `*/` in C and its descendents,
      or each line may be prefixed with a marker like `#`.
  pt:
    term: "bloco de comentário"
    def: >
      Um [comentário](#comment) que abrange múltiplas linhas. Blocos de comentários
      podem ser indicados com símbolos especiais, como `/*` e `*/` em C e linguagens
      herdeiras dessa sintaxe, ou cada linha pode ser prefixada com uma indicação como `#`.


- slug: boilerplate
  en:
    term: "boilerplate"
    def: >
      Standard text that is included in legal contracts, licenses, and so on.


- slug: boolean
  ref:
    - truthy
    - falsy
    - binary
  en:
    term: "Boolean"
    def: >
      Relating to a variable or data type that can have either a logical value of
      [true](#true) or [false](#false). Named for George Boole, a 19th
      century mathematician. Binary systems, like all computers, are built on this
      foundation of systems of logical evaluations between states of true and false, 1
      or 0.
  ar:
    term: "التعبير المنطقي"
    def: >
        التعبير المنطقي هو عبارة عن تعبير يُستخدم لإنشاء جُمل إما تحمل
        [القيمة صح](#true)
        أو
        [القيمة خطأ](#false)
         وتستخدم التعبيرات المنطقية مع العبارات الشرطية في محركات البحث والخوارزميات،
         كما تُسمى التعبيرات المنطقية أيضا تعبيرات المقارنة والتعبيرات الشرطية
         والتعبيرات العلائقية.
  pt:
    term: "Booleano"
    def: >
      Relacionado a uma uma variável ou tipo de dado que pode ter um valor lógico de
      [verdadeiro](#true) ou [falso](#false). Nomeado em referêcia à George Boole, um
      matemático do século XIX. Sistemas binários, como todos os computadores, são construídos
      com base em sistemas de avaliação entre estados de verdadeiro e falso, 0 ou 1.


- slug: branch
  en:
    term: "branch"
    def: >
      See [Git branch](#git_branch).


- slug: branch_per_feature_workflow
  en:
    term: "branch-per-feature workflow"
    def: >
      A common strategy for managing work with [Git](#git) and other [version control
      systems](#version_control_system) in which a separate [branch](#git_branch) is
      created for work on each new feature or each [bug](#bug) fix and merged when that work
      is completed. This isolates changes from one another until they are completed.


- slug: breadcrumbs
  en:
    term: "breadcrumbs"
    def: >
      A set of supplementary navigational links included in many websites, usually
      placed at the top of the page. Breadcrumbs show the users where the current page
      lies in the website; the term comes from a fairy tale in which children left a
      trail of breadcrumbs behind themselves so that they could find their way home.


- slug: breadth_first
  ref:
    - depth_first
  en:
    term: "breadth first"
    def: >
      To go through a nested data structure such as a [tree](#tree) by exploring all
      of one level, then going on to the next level and so on, or to explore a problem
      by examining the first step of each possible solution, and then trying the next step
      for each.


- slug: bug
  en:
    term: "bug"
    def: >
      A missing or undesirable [feature](#feature_software) of a piece of software;
      the digital equivalent of a weed.


- slug: bug_report
  en:
    term: "bug report"
    def: >
      A collection of files, [logs](#log), or related information that describes either an
      unexpected output of some code or program, or an unexpected error or warning.
      This information is used to help find and fix a [bug](#bug) in the program or code.


- slug: bug_tracker
  en:
    term: "bug tracker"
    def: >
      A system that tracks and manages [reported bugs](#bug_report) for a software
      program, to make it easier to address and fix the [bugs](#bug).


- slug: build_manager
  ref:
    - build_rule
    - dependency
    - makefile
  en:
    term: "build manager"
    def: >
      A program that keeps track of how files depend on one another and runs commands
      to update any files that are out-of-date. Build managers were invented to
      [compile](#compile) only those parts of programs that had changed, but are now
      often used to implement workflows in which plots depend on results files, which
      in turn depend on raw data files or configuration files.


- slug: build_recipe
  en:
    term: "build recipe"
    def: >
      The part of a [build rule](#build_rule) that describes how to update something
      that has fallen out-of-date.


- slug: build_rule
  en:
    term: "build rule"
    def: >
      A specification for a [build manager](#build_manager) that describes how some
      files depend on others and what to do if those files are out-of-date.


- slug: build_stale
  en:
    term: "stale (in build)"
    def: >
      To be out-of-date compared to a [prerequisite](#prerequisite). A [build
      manager](#build_manager)'s job is to find and update things that are stale.


- slug: build_target
  ref:
    - makefile
    - default_target
  en:
    term: "build target"
    def: >
      The file(s) that a [build rule](#build_rule) will update if they are out-of-date
      compared to their [dependencies](#dependency).


- slug: byte_code
  en:
    term: "byte code"
    def: >
      A set of instructions designed to be executed efficiently by an [interpreter](#interpreter).


- slug: cache
  en:
    term: "cache"
    def: >
      Something that stores copies of data so that future requests for it can be
      satisfied more quickly. The CPU in a computer uses a hardware cache to hold
      recently-accessed values; many programs rely on a software cache to reduce
      network traffic and latency. Figuring out when something in a cache is out-of-date
      and should be replaced is one of the [two hard problems in computer science](#two_hard_problems).


- slug: caching
  en:
    term: "caching"
    def: >
      To save a copy of some data in a local [cache](#cache) to make future access faster.


- slug: call_stack
  en:
    term: "call stack"
    def: >
      A data structure that stores information about the active subroutines executed.


- slug: callback
  en:
    term: "callback function"
    def: >
      A function A that is passed to another function B so that B can call it at some
      later point. Callbacks can be used [synchronously](#synchronous), as in generic
      functions like `map` that invoke a callback function once for each element in a
      collection, or [asynchronously](#asynchronous), as in a [client](#client) that
      runs a callback when a [response](#http_response) is received in answer to a [request](#http_request).


- slug: camel_case
  ref:
    - kebab_case
    - pothole_case
  en:
    term: "camel case"
    def: >
      A style of writing code that involves naming variables and objects with no
      space, underscore (`_`), dot (`.`), or dash (`-`) characters, with each word being
      capitalized. Examples include `CalculateSum` and `findPattern`.


- slug: catch_exception
  ref:
    - condition
    - handle_condition
  en:
    term: "catch (an exception)"
    def: >
      To accept responsibility for handling an error or other unexpected event. [R](#r_language)
      prefers "handling a condition" to "catching an exception". [Python](#python), on the other hand,
      encourages raising and catching exceptions, and in some situations, requires it.
  ar:
    term: "إستثناء"
    def: >
      الإستثناء هو الشرط الخاص الذي يُعالج به الشذوذ أو الشيء الغير متوقع الذي حدث
      أثناء تنفيذ البرنامج.


- slug: causation


- slug: cc_0
  en:
    term: "CC-0"
    def: >
      A [Creative Commons](#cc_license) [license](#license) that imposes no
      restrictions whatsover, thereby putting a work in the public domain.
  pt:
    term: "CC-0"
    def: >
      Uma [licença](#license) [Creative Commons](#cc_license) que não impõe
      qualquer tipo de restrição, consequentemente colocando o trabalho em domínio público.


- slug: cc_by
  en:
    term: "CC-BY"
    def: >
      The [Creative Commons](#cc_license) - Attribution [license](#license) that
      requires people to give credit to the author of a work, but imposes no other restrictions.
  pt:
    term: "CC-BY"
    def: >
      Uma [licença](#license) [Creative Commons](#cc_license) com Atribuição, que requer que
      seja dado crédito às pessoas autoras do trabalho, mas que não impõe outras restrições.


- slug: cc_license
  en:
    term: "Creative Commons license"
    def: >
      A set of [licenses](#license) that can be applied to published work. Each
      license is formed by concatenating one or more of `-BY` (Attribution): users
      must cite the original source; `-SA` (ShareAlike): users must share their own
      work under a similar license; `-NC` (NonCommercial): work may not be used for
      commercial purposes without the creator's permission; `-ND` (NoDerivatives): no
      derivative works (e.g., translations) can be created without the creator's
      permission. Thus, `CC-BY-NC` means "users must give attribution and cannot use
      commercially without permission". The term `CC-0` (zero, not letter 'O') is
      sometimes used to mean "no restrictions", i.e., the work is in the public domain.
  pt:
    term: "Licença Creative Commons"
    def: >
      Um conjunto de [licenças](#license) que podem ser aplicadas à trabalhos publicados.
      Cada licença é formada pela concatenação de um ou mais dos termos a seguir:
      `-BY` (Atribuição): pessoas usuárias devem citar a fonte original;
      `-SA` (CompartilhaIgual): pessoas usuárias devem compartilhar o seu próprio trabalho
      utilizando uma licença similar; `-NC` (NãoComercial): o trabalho não pode ser usado
      para fins comerciais sem a permissão das pessoas criadoras; `-ND` (SemDerivações):
      nenhum trabalho derivado (como traduções, por exemplo) pode ser criado sem a permissão
      das pessoas criadoras. Assim, `CC-BY-NC` quer dizer "pessoas usuárias devem atribuir autoria
      e não podem o conteúdo de forma comercial sem permissão". O termo `CC-0` (zero, não a letra 'O')
      é às vezes usado com o sentido de "sem restrições", isto é, que o trabalho é de domínio público.


- slug: centroid
  en:
    term: "centroid"
    def: >
      The center or anchor of a group created by a [clustering](#clustering) algorithm.
  pt:
    term: "centróide"
    def: >
      O centro ou âncora de um grupo criado por um algoritmo de [agrupamento](#clustering).


- slug: character_encoding
  en:
    term: "character encoding"
    def: >
      A specification of how characters are stored as bytes. The most commonly-used
      encoding today is [UTF-8](#utf_8).
  ar:
    term: "ترميز"
    def: >
      إعادة تمثيل البيانات بصياغة أُخرى ليسهل التعامل معها وحفظها كبايت
      (bytes)
       ولا علاقة للترميز بالسرية والتشفير مطلقا، ومن صيغ ترميز البيانات المشهورة
       هو
       يو تي إف
       [(UTF-8)](#utf_8).


- slug: chi_square_test
  en:
    term: "chi-square test"
    def: >
      A statistical method for estimating whether two variables in a cross tabulation
      are [correlated](#correlation). A chi-square distribution varies from a [normal
      distribution](#normal_distribution) based on the [degrees of
      freedom](#degrees_of_freedom) used to calculate it.
  af:
    term: "chi-kwadraattoets"
    def: >
      'n Statistiese metode om te bepaal of twee veranderlikes in 'n kruistabellering
      gekorreleerd is. 'n Chi-kwadraatverdeling wissel vanaf 'n normale verspreiding
      gebaseer op die vryheidsgrade wat gebruik word om dit te bereken.


- slug: child_class
  en:
    term: "child class"
    def: >
      In [object-oriented programming](#oop), a [class](#class) derived from another class
      (called the [parent class](#parent_class)).
  es:
    term: "subclase"
    def: >
      En [programación orientada a objetos](#oop), es la extensión de otra
      clase (denominada [superclase](#parent_class)).
  pt:
    term: "classe derivada"
    def: >
      Em [programação orientada a objetos](#oop), a classe derivada de uma outra classe
      (chamada de [classe base](#parent_class)).


- slug: child_tree
  en:
    term: "child (in a tree)"
    def: >
      A [node](#node) in a [tree](#node) that is below another node (call the [parent](#parent_tree)).


- slug: class
  en:
    term: "class"
    def: >
      In [object-oriented programming](#oop), a structure that combines data and
      operations (called [methods](#method)). The program then uses a
      [constructor](#constructor) to create an [object](#object) with those
      properties and methods. Programmers generally put generic or reusable
      behavior in [parent classes](#parent_class), and more detailed or specific
      behavior in [child classes](#child_class).
  es:
    term: "clase"
    def: >
      En [programación orientada a objetos](#oop), es una estructura que combina
      datos y operaciones (denominadas [métodos](#method)). El programa emplea un
      [constructor](#constructor) para crear un [objeto](#object) con esas
      propiedades y métodos. Los programadores generalmente definen comportamientos
      genéricos o reutilizables en [superclases](#parent_class) y comportamientos
      más específicos o detallados en [subclases](#child_class).


- slug: classification
  ref:
    - supervised_learning
    - clustering
  en:
    term: "classification"
    def: >
      The process of identifying which predefined category an item belongs to, such as
      deciding whether an email message is spam or not. Many [machine
      learning](#machine_learning) algorithms perform classification.


- slug: cli
  en:
    term: "command-line interface"
    acronym: "CLI"
    def: >
      A user interface that relies solely on text for commands and output, typically
      running in a [shell](#shell).


- slug: client
  en:
    term: "client"
    def: >
      Typically, a program such as a web browser that gets data from a
      [server](#server) and displays it to, or interacts with, users. The term is used
      more generally to refer to any program A that makes requests of another program
      B. A single program can be both a client and a server.


- slug: closure
  en:
    term: "closure"
    def: >
      A set of variables defined in the same [scope](#scope) whose existence has been
      preserved after that scope has ended.


- slug: clustering
  ref:
    - centroid
    - classification
    - supervised_learning
    - unsupervised_learning
  en:
    term: "clustering"
    def: >
      The process of dividing data into groups when the groups themselves are not
      known in advance.
  pt:
    term: "agrupamento"
    def: >
      O processo de dividir os dados em grupos quando os grupos em si não são conhecidos
      antecipadamente.


- slug: code_coverage
  en:
    term: "code coverage (in testing)"
    def: >
      How much of a [library](#library) or program is executed when tests run. This is normally
      reported as a percentage of lines of code: for example, if 40 out of 50 lines in
      a file are run during testing, those tests have 80% code coverage.


- slug: code_review
  en:
    term: "code review"
    def: >
      To check a program or a change to a program by inspecting its source code.


- slug: coercion
  en:
    term: "coercion"
    def: >
      See [type coercion](#type_coercion).


- slug: cognitive_load
  en:
    term: "cognitive load"
    def: >
      The amount of working memory needed to accomplish a set of simultaneous tasks.


- slug: command_history
  en:
    term: "command history"
    def: >
      An automatically-created list of previously-executed commands. Most read-eval-print loops
      ([REPLs](#repl)), including the [Unix shell](#shell), record history and allow
      users to play back recent commands.


- slug: command_line_argument
  en:
    term: "command-line argument"
    def: >
      A filename or control flag given to a command-line program when it is run.


- slug: comment
  en:
    term: "comment"
    def: >
      Text written in a script that is not treated as code to be run, but rather as
      text that describes what the code is doing. These are usually short notes, often
      beginning with a `#` (in many programming languages).
  fr:
    term: "commentaire"
    def: >
      Text écrit dans un script qui n'est pas évalué lors de l'exécution du code. Il
      est utilisé pour décrire ce qui se passe lorsque le code est évalué. Les
      commentaires sont en général des notes brèves, qui commencent après un `#` (dans
      plusieurs langages de programmation)
  pt:
    term: "comentário"
    def: >
      Texto escrito em um script que não é tratado como código a ser executado, e sim
      como texto que descreve o que o código está fazendo. Normalmente é formado por
      notas curtas, frequentemente começando com um `#` (em várias linguagens de programação).


- slug: commit
  en:
    term: "commit"
    def: >
      As a verb, the act of saving a set of changes to a database or [version control](#version_control_system)
      [repository](#repository). As a noun, the changes saved.


- slug: commit_message
  en:
    term: "commit message"
    def: >
      A comment attached to a [commit](#commit) that explains what was done and why.


- slug: compile
  en:
    term: "compile"
    def: >
      To translate textual source into another form. Programs in [compiled
      languages](#compiled_language) are translated into machine instructions for a
      computer to run, and [Markdown](#markdown) is usually translated into
      [HTML](#html) for display.


- slug: compiled_language
  en:
    term: "compiled language"
    def: >
      Originally, a language such as C or Fortran that is translated into machine
      instructions for execution. Languages such as Java are also compiled before
      execution, but into [byte code](#byte_code) instead of machine instructions,
      while [interpreted languages](#interpreted_language) like [Python](#python)
      are compiled to byte code on the fly.


- slug: compiler
  en:
    term: "compiler"
    def: >
      An application that translates programs written in some languages into machine
      instructions or [byte code](#byte_code).
  ar:
    term: "مُترجِم"
    def: >
      هو برنامج يقوم بترجمة النصوص المصدرية إلى أوامر ومعلومات يفهمها الحاسب لذلك
      يُمكن للكمبيوتر فهم البرنامج وتشغيله دون استخدام برنامج البرمجة المستخدم لإنشائه
      أو مايُسمى
      [رموز البايت](#byte_code).


- slug: computational_linguistics
  ref:
    - nlp
  en:
    term: "computational linguistics"
    def: >
      The study or application of computational methods for [parsing](#parse) or understanding
      human languages. Early approaches were algorithmic; most modern approaches are statistical.


- slug: computational_notebook
  en:
    term: "computational notebook"
    def: >
      A combination of a document format that allows users to mix prose and code in a
      single file, and an application that executes that code interactively and in
      place. The Jupyter Notebook and [R Markdown](#r_markdown) files are both examples of
      computational notebooks.


- slug: condition
  ref:
    - handle_condition
  en:
    term: "condition"
    def: >
      An error or other unexpected event that disrupts the normal flow of control.


- slug: conditional_expression
  en:
    term: "conditional expression"
    def: >
      A [ternary expression](#ternary_expression) that serves the role of an if/else
      statement. For example, C and similar languages use the syntax `test : ifTrue ?
      ifFalse` to mean "choose the value `ifTrue` if `test` is true, or the value
      `ifFalse` if it is not".


- slug: confidence_interval
  en:
    term: "confidence interval"
    def: >
      A range around an estimate that indicates the margin of error, combined with a
      probability that the actual value falls in that range.
  af:
    term: "vertrouensinterval"
    def: >
      'n Variasiewydte rondom 'n beraming wat'n foutgrens aandui, gekombineerd met die waarskynlikheid
       dat die werklike getal binne die skatting val.


- slug: console
  en:
    term: "console"
    def: >
      A computer terminal where a user may enter commands, or a program, such as a shell
      that simulates such a device.


- slug: constant


- slug: constructor
  en:
    term: "constructor"
    def: >
      A function that creates an [object](#object) of a particular
      [class](#class). In the [S3](#s3) object system, constructors are a
      convention rather than a requirement.
  es:
    term: "constructor"
    def: >
      Una función que crea un [objeto](#object) de una [clase](#class)
      particular. En el sistema de objetos de [S3](#s3), los constructores
      son más una convención que un requisito.


- slug: continuation_prompt
  en:
    term: "continuation prompt"
    def: >
      A [prompt](#prompt) that indicates that the command currently being typed is not
      yet complete, and will not be run until it is.


- slug: continuous_integration
  en:
    term: "continuous integration"
    def: >
      A software development practice in which changes are automatically merged as
      soon as they become available.


- slug: continuous_random_variable
  ref:
    - discrete_random_variable
  en:
    term: "continuous random variable"
    def: >
      A [variable](#variable_data) whose value can be any real value, either
      within a range, or unbounded, such as age or distance.


- slug: copy_on_modify
  ref:
    - aliasing
  en:
    term: "copy-on-modify"
    def: >
      The practice of creating a new copy of aliased data whenever there is an attempt
      to modify it so that each reference will believe theirs is the only one.


- slug: correlation
  en:
    term: "correlation"
    def: >
      A measure of how well two variables agree with each other. Correlation is usually measured by
      calculating a [correlation coefficient](#correlation_coefficient), and does not
      imply [causation](#causation).
  pt:
    term: "correlação"
    def: >
      O quão bem duas variáveis concordam uma com a outra. A correlação é normalmente
      medida pelo cálculo de um [coeficiente de correlação](#correlation_coefficient),
      e não significa que precise existir causalidade.
  af:
    term: "korrelasie"
    def: >
      Hoe sterk twee veranderlikes met mekaar ooreenstem. Korrelasie word gewoonlik gemeet aan
      die berekening van 'n [korrelasiekoëffisiënt](#correlation_coefficient), maar
      impliseer nie oorsaaklikheid.


- slug: correlation_coefficient
  en:
    term: "correlation coefficient"
    def: >
      A measure of how well-[correlated](#correlation) two variables are. If the
      [correlation coefficient](#correlation_coefficient) between X and Y is 1.0,
      knowing X allows perfect prediction of Y. If the correlation coefficient is 0.0,
      knowing X tells you nothing about Y, and if it is -1.0, then X predicts Y, but
      a change in X causes an opposite change in Y.
  pt:
    term: "coeficiente de correlação"
    def: >
      Uma medida do quão bem duas variáveis estão [correlacionadas](#correlation). Se
      o [coeficiente de correlação](#correlation_coefficient) entre X e Y for 1.0,
      conhecer X permite uma previsão perfeita de Y. Se o coeficiente de correlação
      for 0.0, conhecer X não diz nada a respeito de Y, e se for -1.0, então X prevê
      Y, mas mudanças no valor de X gera uma mudança oposta em Y.
  af:
    term: "korrelasiekoëffisiënt"
    def: >
      'n Maatstaf van hoe sterk [gekorreleer](#correlation) twee veranderlikes is. As die
      korrelasiekoëffisiënt tussen X en Y gelyk is aan 1.0,
      dui dit aan dat X die perfekte voorspelling van Y is. As die korrelasiekoëffisiënt
      0,0 is, dui dit aan dat X nie verwant is aan Y nie. As dit -1,0 is, dan voorspel
      X vir Y, maar verandering in X veroorsaak 'n teenoorgestelde verandering in Y.


- slug: covariance
  en:
    term: "covariance"
    def: >
      How well two variables agree with each other. The [correlation
      coefficient](#correlation_coefficient) is a normalized measure of covariance.
  pt:
    term: "covariância"
    def: >
      O quão bem duas variáveis concordam uma com a outra. O [coeficiente de
      correlação](#correlation_coefficient) é uma medida normalizada da covariância.


- slug: cran
  ref:
    - base_r
    - tidyverse
  en:
    term: "Comprehensive R Archive Network"
    acronym: "CRAN"
    def: >
      A public repository of [R](#r_language) packages.


- slug: cross_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "cross join"
    def: >
      A [join](#join) that produces all possible combinations of rows from two tables.


- slug: cross_validation
  ref:
    - machine_learning
  en:
    term: "cross-validation"
    def: >
      A technique that divides data into [training data](#training_data) and [test
      data](#test_data). The training data and correct answers are used to find
      [parameters](#parameter), and the algorithm's effectiveness is then measured by examining the
      answers it gives on the test data.


- slug: cryptographic_hash_function
  en:
    term: "cryptographic hash function"
    def: >
      A [hash function](#hash_function) that produces an apparently-random value for
      any input.


- slug: css
  en:
    term: "Cascading Style Sheets"
    acronym: "CSS"
    def: >
      A way to control the appearance of HTML. CSS is typically used to specify fonts,
      colors, and layout.
  fr:
    term: "Feuilles de Style en Cascade"
    def: >
      Une manière de contrôler l'apparence du rendu HTML. Le CSS est généralement
      utilisé dans le but de spécifier les polices, les couleurs ainsi que la
      structure d'une page web.


- slug: csv
  en:
    term: "comma-separated values"
    acronym: "CSV"
    def: >
      A text format for tabular data in which each [record](#record) is one row and [fields](#field) are
      separated by commas. There are many minor variations, particularly around
      quoting of [strings](#string).


- slug: current_working_directory
  en:
    term: "current working directory"
    def: >
      The [folder](#folder) or [directory](#directory) location in which the program operates. Any action
      taken by the program occurs relative to this directory.
  pt:
    term: "diretório de trabalho"
    def: >
      O local, pasta ou diretório, em que o programa está operando. Qualquer ação do
      programa acontece relativa a esse diretório.
  fr:
    term: "répertoire de travail"
    def: >
      L'emplacement du système de fichiers dans lequel le programme en cours est en train d'opérer.
      Chaque opération effectuée par le programme se fait relativement à cet emplacement.


- slug: data_engineer
  ref:
    - data_scientist
    - data_wrangling
  en:
    term: "data engineer"
    def: >
      Someone who sets up and runs data analyses. Data engineers are often responsible
      for installing software, managing databases, generating reports, and archiving results.


- slug: data_engineering
  ref:
    - data_science
  en:
    term: "data engineering"
    def: >
      The pragmatic steps taken to make data usable, such as writing short programs to
      put mailing addresses in a uniform format.


- slug: data_frame
  ref:
    - tidy_data
  en:
    term: "data frame"
    def: >
      A two-dimensional data structure for storing tabular data in memory. Rows
      represent [records](#record) and columns represent [variables](#variable_data).
  fr:
    term: "trame de données"
    def: >
      Une structure bi-dimensionnelle pour enregistrer des données tabulaires. Les
      lignes représentent les [entrées](#record) et les colonnes représentent les [variables](#variable_data).


- slug: data_mining
  en:
    term: "data mining"
    def: >
      The use of computers to search for patterns in large datasets. The term [data
      science](#data_science) is now more commonly used.


- slug: data_package
  en:
    term: "data package"
    def: >
      A software package that, mostly, contains only data. Is used to make it simpler
      to disseminate data for easier use.


- slug: data_science
  en:
    term: "data science"
    def: >
      The combination of statistics, programming, and hard work used to extract
      knowledge from data.
  pt:
    term: "ciência de dados"
    def: >
      A combinação de estatística, programação e trabalho duro usados para extrair
      conhecimento a partir de dados.


- slug: data_scientist
  en:
    term: "data scientist"
    def: >
      Someone who uses programming skills to solve statistical problems.
  pt:
    term: "cientista de dados"
    def: >
      Alguém que usa habilidades de programação para resolver problemas estatísticos.


- slug: data_wrangling
  en:
    term: "data wrangling"
    def: >
      A colloquial name for small-scale [data engineering](#data_engineering).


- slug: decision_tree
  ref:
    - random_forests
  en:
    term: "decision tree"
    def: >
      A tree whose [nodes](#node) are questions and whose [branches](#branch) eventually lead to a
      decision or [classification](#classification).


- slug: decorator_pattern
  en:
    term: "Decorator pattern"
    def: >
      A [design pattern](#design_pattern) in which a function adds additional features
      to another function or a [class](#class) after its initial definition.
      Decorators are a feature of [Python](#python) and can be implemented in most
      other languages as well.


- slug: deep_learning
  en:
    term: "deep learning"
    def: >
      A family of [neural network](#neural_network) algorithms that use multiple
      layers to extract features at successively higher levels.


- slug: default_target
  en:
    term: "default target"
    def: >
      The [build target](#build_target) that is used when none is specified explicitly.


- slug: default_value
  en:
    term: "default value"
    def: >
      A value assigned to a function [parameter](#parameter) when the caller does not specify a
      value. Default values are specified as part of the function's definition.


- slug: defensive_programming
  en:
    term: "defensive programming"
    def: >
      A set of programming practices that assumes mistakes will happen and either
      reports or corrects them, such as inserting [assertions](#assertion) to report
      situations that are not ever supposed to occur.


- slug: degrees_of_freedom


- slug: delegate_pattern
  en:
    term: "Delegate pattern"
    def: >
      A [design pattern](#design_pattern) in which an [object](#object) does most of the work to
      complete a task, but uses one of a set of other objects to complete some
      specific parts of the work. Delegation is often used instead of inheritance to
      customize objects' behavior.


- slug: dependency
  en:
    term: "dependency"
    def: >
      See [prerequisite](#prerequisite).


- slug: dependent_variable
  en:
    term: "dependent variable"
    def: >
      A variable whose value depends on the value of another variable, which is called
      the [independent variable](#independent_variable).
  pt:
    term: "variável dependente"
    def: >
      Uma variável cujo valor dependa do valor de outra variável, que é chamada de
      [variável independente](#independent_variable).


- slug: depth_first
  en:
    term: "depth first"
    def: >
      To go through a nested data structure such as a [tree](#tree) by going as far as
      possible down one path, then as far as possible down the next and so on, or to
      explore a problem by following one solution to its conclusion and then trying
      the next.


- slug: design_pattern
  ref:
    - iterator_pattern
    - singleton_pattern
    - template_method_pattern
    - visitor_pattern
  en:
    term: "design pattern"
    def: >
      A recurring pattern in software design that is specific enough to be worth
      naming, but not so specific that a single best implementation can be provided by
      a [library](#library). For example, [data frames](#data_frame) and database
      [tables](#table) are instances of the same pattern.


- slug: destructuring_assignment
  en:
    term: "destructuring assignment"
    def: >
      Unpacking values from data structures and assigning them to multiple variables
      in a single statement.


- slug: dictionary
  en:
    term: "dictionary"
    def: >
      A data structure that allows items to be looked up by value, sometimes called an
      [associative array](#associative_array). Dictionaries are often implemented
      using [hash tables](#hash_table).


- slug: dimension_reduction
  ref:
    - principal_component_analysis
  en:
    term: "dimension reduction"
    def: >
      Reducing the number of dimensions in a dataset, typically by finding the
      dimensions along which it varies most.


- slug: directory


- slug: discrete_random_variable
  ref:
    - continuous_random_variable
  en:
    term: "discrete random variable"
    def: >
      A [variable](#variable_data) whose value can take on only one of a fixed
      set of values, such as [true](#true) or [false](#false).


- slug: distro
  en:
    term: "distro"
    def: >
      See [software distribution](#software_distribution).


- slug: docstring
  en:
    term: "docstring"
    def: >
      Short for "documentation string", a string appearing at the start of a module,
      class, or function in [Python](#python) that automatically becomes that object's documentation.


- slug: documentation_generator
  en:
    term: "documentation generator"
    def: >
      A software tool that extracts specially-formatted comments or
      [dostrings](#docstring) from code and generates cross-referenced developer documentation.


- slug: doi
  ref:
    - orcid
  en:
    term: "Digital Object Identifier"
    acronym: "DOI"
    def: >
      A unique persistent identifier for a book, paper, report, dataset, software release, or
      other digital artefact.


- slug: dom
  en:
    term: "Document Object Model"
    acronym: "DOM"
    def: >
      A standard, in-memory representation of [HTML](#html) and [XML](#xml). Each
      [element](#element) is stored as a [node](#node) in a [tree](#tree) with a set
      of named [attributes](#attribute); contained elements are [child
      nodes](#child_tree). Modern programming languages provide many [libraries](#library) for
      searching and modifying the DOM.


- slug: dom_selector
  ref:
    - regular_expression
  en:
    term: "DOM selector"
    def: >
      A pattern that identifies [nodes](#node) in a [DOM](#dom) [tree](#tree). For
      example, `#alpha` matches nodes whose `id` [attribute](#attribute) is "alpha",
      while `.beta` matches nodes whose `class` [attribute](#attribute) is "beta".


- slug: domain_knowledge
  en:
    term: "domain knowledge"
    def: >
      Understanding of a specific problem domain, e.g., knowledge of transportation logistics.


- slug: double
  en:
    term: "double"
    def: >
      Short for "double-precision floating-point number", meaning a 64-bit numeric
      value with a fractional part and an exponent.


- slug: double_square_brackets
  ref:
    - single_square_brackets
  en:
    term: "double square brackets"
    def: >
      An index enclosed in `[[...]]`, used to return a single value of the underlying type.


- slug: down_vote
  ref:
    - up_vote
  en:
    term: "down-vote"
    def: >
      A vote against something.


- slug: dry
  en:
    term: "Don't Repeat Yourself principle"
    acronym: "DRY"
    def: >
      The Don't Repeat Yourself (DRY) principle states that — Every piece of knowledge
      must have a single, unambiguous, authoritative representation within a system.
      The term comes from The Pragmatic Programmer, by Andrew Hunt and David Thomas.
      Programs that follow the DRY Principle avoid duplication of definitions and logic,
      so that a change in their behaviour only requires each modification to be made in
      one part of the code. The goal is to create code that is easier to maintain.


- slug: dynamic_loading
  en:
    term: "dynamic loading"
    def: >
      To [import](#import) a [module](#module) into the memory of a program while it
      is already running. Most [interpreted languages](#interpreted_language) use
      dynamic loading, and provide tools so that programs can find and load modules
      dynamically to configure themselves.


- slug: dynamic_lookup
  en:
    term: "dynamic lookup"
    def: >
      To find a function or a property of an [object](#object) by name while a program
      is running. For example, instead of getting a specific property of an object
      using `obj.name`, a program might use `obj[someVariable]`, where `someVariable`
      could hold `"name"` or some other property name.


- slug: dynamic_scoping
  en:
    term: "dynamic scoping"
    def: >
      To find the value of a [variable](#variable_program) by looking at what is on
      the [call stack](#call_stack) at the moment the lookup is done. Almost all
      programming languages use [lexical_scoping](#lexical_scoping) instead, since it
      is more predictable.


- slug: edge
  en:
    term: "edge"
    def: >
      A connection between two [nodes](#node) in a [graph](#graph). An edge may have
      data associated with it, such as a name or distance.


- slug: element
  ref:
    - empty_element
  en:
    term: "element"
    def: >
      A named component in an [HTML](#html) or [XML](#xml) document. Elements are
      usually written `<name>`...`</name>`, where "..." represents the content of the
      element. Elements often have [attributes](#attribute).


- slug: emacs
  en:
    term: "Emacs (editor)"
    def: >
      A text editor that is popular among Unix programmers.


- slug: empty_element
  en:
    term: "empty element"
    def: >
      An [element](#element) of an [HTML](#html) or [XML](#xml) document that has no
      [children](#child_tree). Empty elements can always be written as
      `<name></name>`, but may also be written using the shorthand notation `<name/>`
      (with a slash after the name inside the angle brackets).


- slug: empty_vector
  en:
    term: "empty vector"
    def: >
      A vector that contains no elements. Empty vectors have a type such as logical or
      character, and are *not* the same as [null](#null).
  fr:
    term: "vecteur vide"
    def: >
      Un vecteur qui ne contient aucun élément. Les vecteurs vides peuvent être de
      type logique ou caractère, et sont *differents* des vecteurs [null](#null).


- slug: environment
  en:
    term: "environment"
    def: >
      A structure that stores a set of variable names and the values they refer to.


- slug: error_handling
  en:
    term: "error handling"
    def: >
      What a program does to detect and correct for errors. Examples include printing
      a message and using a default configuration if the user-specified configuration
      cannot be found.


- slug: error_test
  en:
    term: "error (in a test)"
    def: >
      Signalled when something goes wrong in a [unit test](#unit_test) itself rather
      than in the system being tested. In this case, we do not know anything about the
      correctness of the system.


- slug: escape_sequence
  en:
    term: "escape sequence"
    def: >
      A sequence of characters added as a prefix to some other character that would
      otherwise have a special meaning, temporarily altering the meaning of the character.
      For example, the escape sequence `\"` is used to represent a double-quote character
      inside a double-quoted string.


- slug: evaluation
  en:
    term: "evaluation"
    def: >
      The process of taking an expression such as `1+2*3/4` and turning it into a
      single, irreducible value.


- slug: exception
  en:
    term: "exception"
    def: >
      An object that stores information about an error or other unusual event in a
      program. One part of a program will create and [raise an
      exception](#raise_exception) to signal that something unexpected has happened;
      another part will [catch](#catch_exception) it.


- slug: exception_handler
  en:
    term: "exception handler"
    def: >
      A piece of code that deals with an [exception](#exception) after it is
      [caught](#catch_exception), e.g., by writing a [log message](#log_message),
      retrying the operation that failed, or performing an alternate operation.


- slug: expected_result
  ref:
    - actual_result
  en:
    term: "expected result (of test)"
    def: >
      The value that a piece of software is supposed to produce when tested in a
      certain way, or the state in which it is supposed to leave the system.


- slug: exploratory_programming
  en:
    term: "exploratory programming"
    def: >
      A software development methodology in which requirements emerge or change as the
      software is being written, often in response to results from early runs.


- slug: export
  en:
    term: "export"
    def: >
      To make something visible outside a [module](#module) so that other parts of a
      program can [import](#import) it. In most languages a module must export things
      explicitly in an attempt to avoid [name collision](#name_collision).


- slug: fail_test
  ref:
    - pass_test
  en:
    term: "fail (a test)"
    def: >
      A test fails if the [actual result](#actual_result) does not match the [expected result](#expected_result).


- slug: "false"
  ref:
    - truthy
    - falsy
  en:
    term: "false"
    def: >
      The logical ([Boolean](#boolean)) state opposite of "[true](#true)". Used in
      logic and programming to represent a [binary](#binary) state of something.


- slug: falsy
  ref:
    - truthy
  en:
    term: "falsy"
    def: >
      Evaluating to [false](#false) in a [Boolean](#boolean) context.


- slug: faq
  en:
    term: "Frequently Asked Questions"
    acronym: "FAQ"
    def: >
      A curated list of questions commonly asked about a subject, along with answers.


- slug: feature_branch
  ref:
    - master_branch
  en:
    term: "feature branch"
    def: >
      A [branch](#branch) within a [Git](#git) [repository](#repository)
      containing [commits](#commit) dedicated to a specific feature, e.g., a
      [bug](#bug) fix or a new function. This branch can be merged into another branch.


- slug: feature_data
  en:
    term: "feature (in data)"
    def: >
      A variable or observable in a dataset.


- slug: feature_engineering
  en:
    term: "feature engineering"
    def: >
      The process of choosing the variables to be used as inputs to a [model](#model).
      Choosing good features often depends on [domain knowledge](#domain_knowledge).


- slug: feature_request
  en:
    term: "feature request"
    def: >
      A request to the maintainers or developers of a software program to add a
      specific functionality (a feature) to that program.


- slug: feature_software
  en:
    term: "feature (in software)"
    def: >
      Some aspect of software that was deliberately designed or built. A [bug](#bug)
      is an undesired feature.


- slug: field
  en:
    term: "field"
    def: >
      A component of a [record](#record) containing a single value. Every record in a
      [tibble](#tibble) or database [table](#table) has the same fields.
  fr:
    term: "champ"
    def: >
      Composant d'une [entrée](#record) contenant une seule valeur. Chaque entrée dans
      une [tibble](#tibble) ou [table](#table) de base de données contient les mêmes champs.


- slug: filename_extension
  en:
    term: "filename extension"
    def: >
      The last part of a filename, usually following the '.' symbol. Filename
      extensions are commonly used to indicate the type of content in the file, though
      there is no guarantee that this is correct.


- slug: filename_stem
  en:
    term: "filename stem"
    def: >
      The part of the filename that does not include the [extension](#filename_extension).
      For example, the stem of `glossary.yml` is `glossary`.


- slug: filesystem
  en:
    term: "filesystem"
    def: >
      The part of the [operating system](#operating_system) that manages how files
      are stored and retrieved. Also used to refer to all of those files and
      [directories](#directory) or the specific way they are stored (as in "the Unix filesystem").


- slug: filter
  en:
    term: "filter"
    def: >
      As a verb, to choose a set of [records](#record) (i.e., rows of a table) based
      on the values they contain. As a noun, a command-line program that reads lines
      of text from files or [standard input](#stdin), performs some operation on them
      (such as filtering), and writes to a file or [stdout](#stdout).
  fr:
    term: "filtrer"
    def: >
      Le fait de sélectionner un ensemble d'[observations](#record) (example,
      certaines lignes d'une table) en se basant sur leurs valeurs.


- slug: fixture
  en:
    term: "fixture"
    def: >
      The thing on which a test is run, such as the [parameters](#parameter) to the function being
      tested or the file being processed.


- slug: folder
  en:
    term: "folder"
    def: >
      Another term for a [directory](#directory).


- slug: for_loop
  ref:
    - while_loop
  en:
    term: "for loop"
    def: >
      A construct in a program that repeats one or more other statements (the [loop
      body](#loop_body)) once for each item in a sequence, such as each number in a
      range or each element of a list.


- slug: fork
  ref:
    - branch
  en:
    term: "fork"
    def: >
      A copy of one person's [Git](#git) [repository](#repository)
      that lives in another person's GitHub account. Changes to the content of a fork
      can be submitted to the [upstream repository](#upstream_repository) via a
      [pull request](#pull_request).


- slug: full_identifier_git
  en:
    term: "full identifier (of a commit)"
    def: >
      A unique 160-bit identifier for a [commit](#commit) in a [Git](#git)
      [repository](#repository), usually written as a 20-character
      [hexadecimal](#hexadecimal) character [string](#string).


- slug: full_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "full join"
    def: >
      A [join](#join) that returns all rows and all columns from two tables A and B.
      Where the [keys](#key) of A and B match, values are combined; where they do not,
      missing values from either table are filled with [null](#null), [NA](#na), or
      some other [missing value](#missing_value) signifier.


- slug: fully_qualified_name
  en:
    term: "fully-qualified name"
    def: >
      An unambiguous name of the form `package::thing`, indicating the original source
      of the [object](#object) in question.


- slug: functional_programming
  ref:
    - higher_order_function
    - oop
  en:
    term: "functional programming"
    def: >
      A style of programming in which data is transformed through successive
      application of functions, rather than by using control structures such as loops.
      In functional programming, there must be a direct relationship between the input
      to a function and the output produced by the function, meaning the result should not
      be affected by the current values of global variables or other parts of the [global
      program state](#global_environment). It also requires that functions do not produce [side effects](#side_effect),
      meaning they do not modify the global program state, or do anything other than computing
      the return value, such as writing output to a [log](#log) file, or printing to the [console](#console).


- slug: generator_function
  ref:
    - iterator_pattern
  en:
    term: "generator function"
    def: >
      A function whose state is automatically saved when it returns a value so that
      execution can be restarted from that point the next time it is called.
      One example of generator functions use is to produce
      streams of values that can be processed by [for loops](#for_loop).


- slug: generic_function
  en:
    term: "generic function"
    def: >
      A collection of functions with similar purpose, each operating on a different
      class of data.
  fr:
    term: "fonction générique"
    def: >
      Une collection de fonctions ayant un objectif similaire, chacune opérant sur une
      classe de données différente.
  pt:
    term: "função genérica"
    def: >
      Um conjunto de funções com propósito similar, cada uma operando em uma classe diferente
      de dados.
  es:
    term: "función genérica"
    def: >
      Un conjunto de funciones con propósitos similares, cada una operando en una clase
      diferente de datos.


- slug: geometric_mean


- slug: git
  en:
    term: "Git"
    def: >
      A [version control tool](#version_control_system) to record and manage changes to a project.
  fr:
    term: "Git"
    def: >
      Un outil de gestion des versions qui permet d'enregistrer et de piloter les
      modifications effectuées au niveau d'un projet.
  ja:
    term: "Git(ギット)"
    def: >
       プロジェクトなどの変更履歴を記録・追跡するための分散型バージョン管理システムです。
  pt:
    term: "Git"
    def: >
      Uma ferramenta de controle de versão para registrar e gerenciar mudanças em um projeto.


- slug: git_branch
  ref:
    - feature_branch
    - fork
    - master_branch
  en:
    term: "Git branch"
    def: >
      A snapshot of a version of a [Git](#git) [repository](#repository).
      Multiple branches can capture multiple versions of the same repository.
  fr:
    term: "Git branch"
    def: >
      Une photographie d'une version d'un dépôt Git. Plusieurs branches peuvent
      capturer plusieurs versions au niveau d'un même dépôt.
  pt:
    term: "Git branch"
    def: >
      Uma fotografia de uma versão de um repositório Git. Múltiplos branches podem
      capturar múltiplas versões de um mesmo repositório.


- slug: git_clone
  en:
    term: "Git clone"
    def: >
      Copies (and usually downloads) of a [Git](#git) [remote repository](#remote_repository)
      on a local computer.
  fr:
    term: "Git clone"
    def: >
      Permet de copier (et générallement de télécharger) un [dépôt
      éloigné](#remote_repository) Git au niveau de l'ordinateur local.


- slug: git_conflict
  en:
    term: "Git conflict"
    def: >
      A situation in which incompatible or overlapping changes have been made on
      different [branches](#branch) that are now being [merged](#git_merge).


- slug: git_fork
  ref:
    - git_clone
  en:
    term: "Git fork"
    def: >
      To make a new copy of a [Git](#git) [repository](#repository)
      on a [server](#server), or the copy that is made.


- slug: git_merge
  en:
    term: "Git merge"
    def: >
      Merging branches in [Git](#git) incorporates development
      histories of two [branches](#branch) in one. If changes are made to similar
      parts of the branches on both branches a [conflict](#git_conflict) will occur and
      this must be resolved before the merge will be completed.


- slug: git_pull
  en:
    term: "Git pull"
    def: >
      Downloads and synchronizes changes between a [remote
      repository](#remote_repository) and a local [repository](#repository).
  fr:
    term: "Git pull"
    def: >
      Télécharge et synchronise des modifications entre le [dépôt
      éloigné](#remote_repository) et le [dépôt](#repository) local.


- slug: git_push
  en:
    term: "Git push"
    def: >
      Uploads and synchronizes changes between a local [repository](#repository) and a
      [remote repository](#remote_repository).
  fr:
    term: "Git push"
    def: >
      Charge et synchronise des modifications entre le [dépôt](#repository) local et
      le [dépôt éloigné](#remote_repository).


- slug: git_remote
  en:
    term: "Git remote"
    def: >
      A short name for a [remote repository](#remote_repository) (like a bookmark).


- slug: github
  en:
    term: "GitHub"
    def: >
      A cloud-based platform built around [Git](#git) that allows you to save versions
      of your project online and collaborate with other Git users.
  fr:
    term: "GitHub"
    def: >
      Une platefome dans le Cloud, construite autour de [Git](#git) qui permet de
      sauvegarder en ligne les versions d'un projet et de collaborer avec d'autres
      utilisateurs Git.
  pt:
    term: "GitHub"
    def: >
      Uma plataforma baseada em nuvem construída em torno do [Git](#git) que permite
      salvar versões do seu projeto online e colaborar com outras pessoas usuárias do Git.


- slug: global_environment
  en:
    term: "global environment"
    def: >
      The [environment](#environment) that holds top-level definitions in a programming language, e.g.,
      those written directly in the interpreter.
  fr:
    term: "environnement global"
    def: >
      L'[environnement](#environment) qui contient des définitions de premier niveau
      dans un langage de programmation, example, celles écrites directement dans l'intérpreteur.


- slug: global_installation
  ref:
    - local_installation
  en:
    term: "global installation"
    def: >
      Installing a package in a location where it can be accessed by all users and projects.
  fr:
    term: "installation globale"
    def: >
      Le fait d'installer un package dans un emplacement où il peut être accessible
      par tous les utilisateurs ainsi que tous les projets.


- slug: global_variable
  ref:
    - local_variable
  en:
    term: "global variable"
    def: >
      A variable defined outside any particular function or [package](#package) namespace, which is therefore visible
      to all functions.
  es:
    term: "variable global"
    def: >
      Una variable definida fuera de alguna función en particular, por lo que es
      visible para todas las funciones.
  fr:
    term: "variable globale"
    def: >
      Une variable définie en dehors d'une fonction donnée, qui est par conséquent
      visible pour toutes les fonctions.


- slug: globbing
  en:
    term: "globbing"
    def: >
      To specify a set of filenames using a simplified form of [regular
      expressions](#regular_expression), such as `*.dat` to mean "all files whose
      names end in `.dat`". The name is derived from "global".


- slug: gnu
  ref:
    - gpl
  en:
    term: "GNU Operating System"
    acronym: "GNU"
    def: >
      "GNU" is an [operating system](#operating_system) that is free software.
      GNU is a recursive acronym for "GNU is Not Unix!". The GNU operating
      system consists of GNU [packages](#package) as well as free software realeased by third parties.


- slug: gpl
  ref:
    - gnu
  en:
    term: "GNU Public License"
    acronym: "GPL"
    def: >
      A [license](#license) that allows people to re-use software as long as they
      distribute the source of their changes.


- slug: gradient_boosting
  en:
    term: "gradient boosting"
    def: >
      A [machine learning](#machine_learning) technique that produces an ensemble of
      weak prediction models (typically [decision trees](#decision_tree)) in a
      stepwise fashion.


- slug: gradient_descent
  ref:
    - backpropagation
  en:
    term: "gradient descent"
    def: >
      An optimization algorithm that repeatedly calculates the gradient at the current
      point takes a small step in the direction in which the gradient is decreasing,
      and then recalculates the gradient.


- slug: graph
  ref:
    - tree
  en:
    term: "graph"
    def: >
      1. A plot or a chart that displays data, or 2. a data structure in which
      [nodes](#node) are connected to one another by [edges](#edge).


- slug: group
  en:
    term: "group"
    def: >
      To divide data into subsets according to a set of criteria while leaving records in
      a single structure.


- slug: gui
  en:
    term: "graphical user interface"
    acronym: "GUI"
    def: >
      A user interface that relies on windows, menus, pointers, and other graphical
      elements, as opposed to a [command-line interface](#cli) or voice-driven interface.
  pt:
    term: "interface gráfica de usuário"
    acronym: "GUI"
    def: >
      Uma interface de usuário cujo uso depende de janelas, menus, ponteiros e outros
      elementos gráficos, em oposição a uma [interface de linha de comando](#cli) ou
      interface comandada por voz.


- slug: handle_condition
  ref:
    - condition
    - exception
  en:
    term: "handle (condition)"
    def: >
      To accept responsibility for handling an error or other unexpected event. [R](#r_language)
      prefers "handling a condition" to "[catching an exception](catch_exception)". [Python](#python), on the other hand,
      encourages raising and catching exceptions, and in some situations, requires it.


- slug: harmonic_mean


- slug: hash_function
  en:
    term: "hash function"
    def: >
      A function that turns arbitrary data into a bit array, or a [key](#key), of a fixed size. Hash
      functions are used to determine where data should be stored in a [hash table](#hash_table).


- slug: hash_table
  en:
    term: "hash table"
    def: >
      A data structure that calculates a pseudo-random key (location) for each value passed to it and stores
      the value in that location. Hash tables enable fast lookup for arbitrary data. This occurs
      at the cost of extra memory because hash tables must always be larger than the amount
      of information they need to store, to avoid the possibility of data collisions, when the
      hash function returns the same key for two different values.


- slug: header_row
  ref:
    - csv
  en:
    term: "header row"
    def: >
      If present, the first row of a data file that defines column names (but
      not their data types or units).


- slug: heterogeneous
  ref:
    - homogeneous
  en:
    term: "heterogeneous"
    def: >
      Containing mixed data types. For example, in [Python](#python) and [R](#r_language), a [list](#list) can contain a mix of numbers, character
      strings, and values of other types.


- slug: hexadecimal
  en:
    term: "hexadecimal"
    def: >
      A base-16 number system. Hexadecimal values are usually written using the digits
      0-9 and the characters A-F in either upper or lower case. Hexadecimal is often
      used to represent [binary](#binary) values, since two hexadecimal digits use exactly
      one byte of storage.


- slug: higher_order_function
  en:
    term: "higher-order function"
    def: >
      A function that operates on other functions. For example, the higher-order
      function `map` executes a given function once on each value in a [list](#list).
      Higher-order functions are heavily used in [functional programming](#functional_programming).


- slug: hippocratic_license
  en:
    term: "Hippocratic License"
    def: >
      An ethical software [license](#license) that allows free use for any purpose
      that does not contravene the Universal Declaration of Human Rights.


- slug: histogram
  en:
    term: "histogram"
    def: >
      A graphical representation of the distribution of a set of numeric data, usually
      a vertical bar graph.


- slug: hitchhiker
  en:
    term: "hitchhiker"
    def: >
      Someone who is part of a project but does not actually do any work on it.


- slug: home_directory
  en:
    term: "home directory"
    def: >
      A directory that contains a user's files. Each user on a multi-user computer
      will have their own home directory; a personal computer will often only have one
      home directory.


- slug: homogeneous
  ref:
    - heterogeneous
  en:
    term: "homogeneous"
    def: >
      Containing a single data type. For example, a [vector](#vector) must be homogeneous: its
      values must all be numeric, logical, etc.


- slug: html
  ref:
    - xml
  en:
    term: "HyperText Markup Language"
    acronym: "HTML"
    def: >
      The standard [markup language](#markup_language) used for web pages. HTML is
      represented in memory using [DOM](#dom) (Digital Object Model).


- slug: http
  en:
    term: "HyperText Transfer Protocol"
    acronym: "HTTP"
    def: >
      The standard [protocol](#protocol) for data transfer on the World-Wide Web. HTTP
      defines the format of [requests](#http_request) and [responses](#http_response),
      the meanings of standard error codes, and other features.


- slug: http_header
  en:
    term: "HTTP header"
    def: >
      A key-value pair at the top of an [HTTP](#http) [request](#http_request) or
      [response](#http_response) that carries additional information such as the
      user's preferred language or the length of the data being transferred.


- slug: http_request
  ref:
    - http_response
  en:
    term: "HTTP request"
    def: >
      A message sent from a [client](#client) to a [server](#server) using the
      [HTTP](#http) [protocol](#protocol) asking for data. A request usually asks for
      a web page, image, or other data.


- slug: http_response
  en:
    term: "HTTP response"
    def: >
      A reply sent from a [server](#server) to a [client](#client) using the
      [HTTP](#http) [protocol](#protocol) in response to a [request](#http_request).
      The response usually contains a web page, image, or data.


- slug: ide
  ref:
    - repl
  en:
    term: "Integrated Development Environment"
    acronym: "IDE"
    def: >
      An application that helps programmers develop software. IDEs typically have a
      built-in editor, a [console](#console) to execute code immediately, and browsers for
      exploring data structures in memory and files on disk.
  es:
    term: "Entorno de Desarrollo Integrado"
    acronym: "EDI"
    def: >
      Una aplicación que ayuda a programadores a desarrollar software. Los EDI
      usualmente tiene un editor incorporado, una consola que ejecuta el código
      inmediatamente y navegadores para explorar estructuras de datos en la memoria y
      archivos en el disco.


- slug: import
  en:
    term: "import"
    def: >
      To bring things from a [module](#module) into a program for use. In most
      languages, a program can only import things that the module explicitly [exports](#export).


- slug: impostor_syndrome
  en:
    term: "impostor syndrome"
    def: >
      The [false](#false) belief that one's successes are a result of accident or luck rather
      than ability.


- slug: in_place_operator
  en:
    term: "in-place operator"
    def: >
      An operator that updates one of its operands. For example, the expression
      `x += 2` uses the in-place operator `+=` to add 2 to the current value of `x` and
      assign the result back to `x`.


- slug: independent_variable


- slug: inner_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "inner join"
    def: >
      A [join](#join) that returns the combination of rows from two tables, A and B, whose
      [keys](#key) exist in both tables.


- slug: instance
  en:
    term: "instance"
    def: >
      An [object](#object) of a particular [class](#class).


- slug: integration_test
  ref:
    - unit_test
  en:
    term: "integration test"
    def: >
      A test that checks whether the parts of a system work properly when put together.


- slug: interpreted_language
  en:
    term: "interpreted language"
    def: >
      A high-level language that is not executed directly by the computer, but instead
      is run by an [interpreter](#interpreter) that translates program instructions
      into machine commands on the fly.


- slug: interpreter
  en:
    term: "interpreter"
    def: >
      A program whose job it is to run programs written in a high-level [interpreted language](#interpreted_language).
      Interpreters can run interactively, but may also execute commands saved in a file.


- slug: invariant
  en:
    term: "invariant"
    def: >
      Something that is must be [true](#true) at all times inside of a program or during the
      [lifecycle](#lifecycle) of an [object](#object). Invariants are often expressed using [assertions](#assertion).
      If an invariant expression is not true, this is indicative of a problem, and
      may result in failure or early temrination of the program.


- slug: iso_date_format
  en:
    term: "ISO date format"
    def: >
      An international for formatting dates. While the full standard is complex, the
      most common form is `YYYY-MM-DD`, i.e., a four-digit year, a two-digit month,
      and a two-digit day, separated by hyphens.


- slug: issue
  en:
    term: "issue"
    def: >
      A [bug report](#bug_report), feature request, or other to-do item associated
      with a project. Also called a [ticket](#ticket).


- slug: issue_label
  en:
    term: "label (an issue)"
    def: >
      A short textual tag associated with an [issue](#issue) to categorize it. Common
      labels include [`bug`](#bug) and `feature request`.


- slug: issue_tracking_system
  en:
    term: "issue tracking system"
    def: >
      Similar to a [bug tracking system](#bug_tracker) in that it tracks ["issues"](#issue)
      made to a [repository](#repository), usually in the form of [feature
      requests](#feature_request), [bug reports](#bug_report), or some other to-do item.


- slug: iterator_pattern
  ref:
    - visitor_pattern
  en:
    term: "Iterator pattern"
    def: >
      A [design pattern](#design_pattern) in which a temporary [object](#object) or [generator
      function](#generator_function) produces each value from a collection in turn for
      processing. This pattern hides the differences between different kinds of data
      structures so that everything can be processed using loops.


- slug: join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "join"
    def: >
      One of several operations that combine values from two [tables](#table).


- slug: json
  ref:
    - yaml
  en:
    term: "JavaScript Object Notation"
    acronym: "JSON"
    def: >
      A way to represent data by combining basic values like numbers and character
      strings in [lists](#list) and [key/value](#dictionary) structures. The acronym stands for "JavaScript
      Object Notation"; unlike better-defined standards like [XML](#xml), it is
      unencumbered by a syntax for comments or ways to define a [schema](#schema).
  fr:
    term: "JavaScript Object Notation"
    acronym: "JSON"
    def: >
      Un façon de représenter des données textuelles ou numériques en combinant des
      ensembles de paires nom/valeurs et des listes de valeurs. L'acronyme signifie
      "JavaScript Object Notation", car il s'agit d'un format dérivé de la notation
      des objets du langage JavaScript. Contrairement à d'autres standards plus
      structurés comme [XML](#xml), JSON ne permet pas de définir un [schéma](#schema)
      de données, ni ne supporte l'ajout de commentaires.


- slug: k_means_clustering
  ref:
    - clustering
  en:
    term: "k-means clustering"
    def: >
      An [unsupervised_learning](#unsupervised_learning) algorithm that forms *k*
      groups by repeatedly calculating the [centroid](#centroid) of the current groups
      and then reallocating data points to the nearest centroid until the centroids no
      longer move.


- slug: k_nearest_neighbors
  en:
    term: "k-nearest neighbors"
    def: >
      A [classification](#classification) algorithm that classifies data points based
      on their similarity to their *k* nearest neighbours.


- slug: kebab_case
  ref:
    - camel_case
    - pothole_case
  en:
    term: "kebab case"
    def: >
      A naming convention in which the parts of a name are separated with dashes, as
      in `first-second-third`.


- slug: key
  en:
    term: "key"
    def: >
      1. A [field](#field) or combination of fields whose value(s) uniquely identify a
      [record](#record) within a [table](#table) or dataset. Keys are often used to
      select specific records and in [joins](#join).
      2. Part of a key/value pair, used as a unique identifier in a data structure
      such as a [dictionary](#dictionary).


- slug: keyword_argument
  ref:
    - named_argument
    - variable_arguments
  en:
    term: "keyword arguments"
    def: >
      Extra (often optional) arguments given to a function as key/value pairs.


- slug: latent_variable
  en:
    term: "latent variable"
    def: >
      A variable that is not observed directly but instead is inferred from the states
      or values of other variables.


- slug: latex
  en:
    term: "LaTeX"
    def: >
      A typesetting system for document preparation that uses a specialized [markup language](#markup_language) to define a document structure
      (e.g. headings), stylise text, insert mathematical equations, and manage citations and cross-references. LaTeX is widely
      used in academia, in particular for scientific papers and theses in mathematics, physics, engineering, and computer science.
  fr:
    term: "LaTeX"
    def: >
      Un système de composition de documents qui utilise un [langage de balisage](#markup_language) pour définir la structure et mise en page
      d'un document, composer des formules mathématiques et gérer citations et références. Le format LaTeX est très utilisé
      dans les domaines scientifiques et techniques pour la production d'articles et de mémoires.


- slug: lazy_evaluation
  ref:
    - short_circuit_test
  en:
    term: "lazy evaluation"
    def: >
      Delaying evaluation of an expression until the value is actually needed
      or, in the case of a conditional expression, only evaluating as much of
      the expression as is necessary. For instance, the second half of `A and B`
      will only be evaluated if A is [truthy](#truthy).


- slug: left_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "left join"
    def: >
      A [join](#join) that combines data from two tables, A and B, where [keys](#key) in table
      A match keys in table B, [fields](#field) are concatenated. Where a key in table
      A does *not* match a key in table B, columns from table B are filled with
      [null](#null), [NA](#na), or some other [missing value](#missing_value). Keys from table B
      that do not match keys from table A are excluded for the result.


- slug: lexical_scoping
  en:
    term: "lexical scoping"
    def: >
      To look up the value associated with a name according to the textual structure
      of a program. Most programming languages use lexical scoping instead of [dynamic
      scoping](#dynamic_scoping) because the latter is less predictable.


- slug: library
  en:
    term: "library"
    def: >
      A reusable software [package](#package), also often called a [module](#module).
  pt:
    term: "biblioteca"
    def: >
      Um pacote de programas reutilizáveis, também frequentemente referido como um [módulo](#module).


- slug: license
  en:
    term: "license"
    def: >
      A legal document describing how something can be used, and by whom.


- slug: lifecycle
  en:
    term: "lifecycle"
    def: >
      The steps that something is allowed or required to go through. The lifecycle of
      an [object](#object) runs from its [construction](#constructor) through the
      operations it can or must perform before it is destroyed; the lifecycle of an
      [issue](#issue) may be: "created", "assigned", "in progress", "ready for review",
      and "completed".


- slug: lift
  en:
    term: "lift"
    def: >
      How well a model predicts or [classifies](#classification) things, measured as the ratio of the
      response in the segment identified to the response in the population as a whole.
      A lift of 1 means the model does no better than chance; higher lift means the
      model is doing better.


- slug: line_comment
  en:
    term: "line comment"
    def: >
      A [comment](#comment) in a program that spans part of a single line, as opposed
      to a [block comment](#block_comment) that may span multiple lines.
  pt:
    term: "comentário de linha"
    def: >
      Um [comentário](#comment) em um programa que abrange parte de uma única linha,
      em contraste a um [bloco de comentário](#block_comment) que pode abranger
      mútiplas linhas.


- slug: linear_regression
  ref:
    - logistic_regression
  en:
    term: "linear regression"
    def: >
      A method for finding the best straight-line fit between two datasets, typically
      by minimizing the squares of the distances between the points and a regression line.


- slug: linter
  en:
    term: "linter"
    def: >
      A program that checks for common problems in software, such as violations of
      indentation rules or variable naming conventions. The name comes from the first
      tool of its kind, called `lint`.


- slug: lisp
  en:
    term: "Lisp"
    def: >
      A family of programming languages that represent programs and data as nested
      lists. Many other programming languages have borrowed ideas from Lisp.


- slug: list
  en:
    term: "list"
    def: >
      A [vector](#vector) that can contain values of many different ([heterogeneous](#heterogeneous)) types.


- slug: list_comprehension
  en:
    term: "list comprehension"
    def: >
      In [Python](#python), an expression that creates a new list in place. For
      example, `[2*x for x in values]` creates a new list whose items are the doubles
      of those in `values`.


- slug: literate_programming
  ref:
    - computational_notebook
    - r_markdown
  en:
    term: "literate programming"
    def: >
      A programming paradigm that mixes prose and code.
  fr:
    term: "programmation lettrée"
    def: >
      Une approche de la programmation qui mélange langage naturel (prose) et code.


- slug: local_installation
  ref:
    - global_installation
  en:
    term: "local installation"
    def: >
      Placing a [package](#package) inside a particular project so that it is only accessible
      within that project.


- slug: local_variable
  ref:
    - closure
    - global_variable
  en:
    term: "local variable"
    def: >
      A variable defined inside a function which is only visible within that function.
  es:
    term: "variable local"
    def: >
      Una variable definida dentro de una función, por lo que solo es visible dentro
      de ella.


- slug: log
  en:
    term: "log"
    def: >
      A record of a program's execution containing [messages](#log_message) written
      via a [logging framework](#logging_framework) for later inspection.


- slug: log_message
  en:
    term: "log message"
    def: >
      A single entry in a [log](#log) of a program's execution. Log messages are
      usually highly structured so that data (such as the time or the severity) can be
      recovered later.


- slug: logging_framework
  en:
    term: "logging framework"
    def: >
      A software [library](#library) that manages internal reporting for programs.


- slug: logging_level
  en:
    term: "logging level"
    def: >
      A setting that controls how much information is generated by a [logging
      framework](#logging_framework). Typical logging levels include `DEBUG`,
      `WARNING`, and `ERROR`.


- slug: logical_indexing
  en:
    term: "logical indexing"
    def: >
      To index a [vector](#vector) or other structure with a vector of [Booleans](#boolean), keeping only the
      values that correspond to [true](#true) values. Also referred to as [masking](#masking).


- slug: logistic_regression
  ref:
    - linear_regression
  en:
    term: "logistic regression"
    def: >
      A method for fitting a model to some data that uses logistic (S-shaped) curves
      instead of straight lines.


- slug: long_identifier_git
  ref:
    - short_identifier_git
  en:
    term: "long identifier (of commit)"
    def: >
      See [full identifier](#full_identifier_git).


- slug: long_option
  ref:
    - short_option
  en:
    term: "long option"
    def: >
      A full-word identifier for a [command line argument](#command_line_argument).
      While most common flags are a single letter preceded by a dash, such as `-v`,
      long options typically use two dashes and a readable name, such as `--verbose`.


- slug: loop_body
  en:
    term: "loop body"
    def: >
      The statement or statements executed by a loop.


- slug: machine_learning
  en:
    term: "machine learning"
    def: >
      The study or use of algorithms whose performance improves as they are given more
      data. Machine learning algorithms often use [training data](#training_data) to
      build a [model](#model). Their performance is then measured by how well they
      predict the properties of [test data](#test_data).


- slug: magic_number
  en:
    term: "magic number"
    def: >
      An unnamed numerical constant that appears in a program without explanation.


- slug: make
  en:
    term: "Make"
    def: >
      The original [build manager](#build_manager) for Unix, still in daily use after
      more than forty years.


- slug: makefile
  en:
    term: "Makefile"
    def: >
      A file containing commands for [Make](#make), often actually called `Makefile`.


- slug: markdown
  en:
    term: "Markdown"
    def: >
      A [markup language](#markup_language) with a simple syntax intended as a replacement for [HTML](#html).
      Markdown is often used for README files, and is the basis for [R markdown](#r_markdown).
  fr:
    term: "Markdown"
    def: >
      Un [langage de balisage](#markup_language) à la syntaxe simple visant à remplacer [HTML](#html).
      Markdown est souvent utilisé dans les fichiers LISEZ MOI (README), et forme la base du
      [R markdown](#r_markdown).


- slug: markov_chain
  ref:
    - bayesian_network
    - monte_carlo
  en:
    term: "Markov Chain"
    def: >
      Any [model](#model) describing a series of events in which the
      probability of each event depends only on the current state, not on the path
      taken to reach that state.


- slug: markup_language
  ref:
    - latex
    - xml
  en:
    term: "markup language"
    def: >
      A set of rules for annotating text to define its meaning or how it should be
      displayed. The markup is usually not displayed, but instead controls how the
      underlying text is interpreted or shown. [Markdown](#markdown) and [HTML](#html)
      are widely-used markup languages for web pages.
  fr:
    term: "langage de balisage"
    def: >
      Un ensemble de règles pour annoter un texte afin d'en définir la structure ou d'en modifier
      l'affichage. Des balises déterminent comment le texte
      qu'elles délimitent doit être interprété ou affiché. Le [Markdown](#markdown) et [HTML](#html)
      sont des exemples de langages de balisage utilisés pour des pages web.


- slug: marthas_rules
  en:
    term: "Martha's Rules"
    def: >
      A simple set of rules for making decisions in small groups.


- slug: masking


- slug: master_branch
  ref:
    - feature_branch
  en:
    term: "master branch"
    def: >
      A dedicated, permanent, central [branch](#branch) which should contain a "ready product".
      After a new feature is developed on a separate branch to avoid breaking the main
      code, it can be [merged](#git_merge) into the master branch.


- slug: maximum_likelihood_estimation
  en:
    term: "maximum likelihood estimation"
    def: >
      To choose the [parameters](#parameter) for a [probability
      distribution](#probability_distribution) in order to maximize the likelihood of
      obtaining observed data.
  af:
    term: "maksimumaanneemlikheidsberaming"
    def: >
      Om die parameters vir 'n [waarskynlikheids verdeling](#probability_distribution)
      te verkry, te maksimeer.


- slug: mean
  ref:
    - median
    - mode
  en:
    term: "mean"
    def: >
      The average value of a dataset, more properly known as the [arithmetic
      mean](#arithmetic_mean) to distinguish it from the [geometric](#geometric_mean)
      and [harmonic](#harmonic_mean) means.
  af:
    term: "gemiddeld"
    def: >
      Die gemiddelde waarde van 'n datastel, beter bekend as die
      [rekenkundige gemiddeld](#arithmetic_mean) om dit van die [meetkundige](#geometric_mean)
      en die [harmoniese](#harmonic_mean) gemiddelde te onderskei.
  pt:
    term: "média"
    def: >
      O valor médio de um conjunto de dados, mais apropriadamente conhecido como
      [média aritmética](#arithmetic_mean) para que seja distinguido da média
      [geométrica](#geometric_mean) e da [harmônica](#harmonic_mean).


- slug: mean_absolute_error
  ref:
    - mean_squared_error
    - root_mean_squared_error
  en:
    term: "mean absolute error"
    def: >
      The average error of all predicted values compared with actual values.


- slug: mean_squared_error
  ref:
    - root_mean_squared_error
  en:
    term: "mean squared error"
    def: >
      The average of the squares of all the errors of all predicted values compared
      with actual values. Squaring makes larger errors count for more,
      and transforms negative errors into positive values, making this a
      more popular measure than [mean absolute error](#mean_absolute_error).


- slug: median
  ref:
    - mode
  en:
    term: "median"
    def: >
      A value separating the upper and lower halves of a sorted dataset. The median
      often gives a better idea of what is typical of the dataset than the
      [mean](#mean), which can be influenced by a small number of extreme [outliers](#outlier).
      If the dataset contains an even number of elements, this is the average of the
      two central elements.
  af:
    term: "mediaan"
    def: >
      'n Waarde wat die boonste en onderste helfte van 'n gesorteerde datastel skei. Die mediaan
      gee dikwels 'n beter idee van wat tipies is vir die datastel as die
      [mediaan](#mean), wat beïnvloed kan word deur 'n klein aantal ekstreme uitskieters.


- slug: merge_git
  en:
    term: "merge (Git)"
    def: >
      See [Git merge](#git_merge)


- slug: method
  en:
    term: "method"
    def: >
      An implementation of a [generic function](#generic_function) that handles
      objects of a specific class.
  es:
    term: "método"
    def: >
      Una implementación de una [función genérica](#generic_function) que
      manipula objetos de una clase específica.


- slug: milestone
  en:
    term: "milestone"
    def: >
      A target that a project is trying to meet, often represented as a set of
      [issues](#issue) that all have to be resolved by a certain time.


- slug: mime_type
  en:
    term: "MIME type"
    def: >
      A standard way to identify the contents of files on the internet. The term is an
      acronym of "multi-purpose Internet mail extension", and MIME types are often
      identified by [filename extensions](#filename_extension), such as `.png` for
      PNG-formatted images.


- slug: missing_value
  en:
    term: "missing value"
    def: >
      A special value such as [null](#null) or [NA](#na) used to indicate the absence
      of data. Missing values can signal that data was not collected or that the data
      did not exist in the first place (e.g., the middle name of someone who does not
      have one).


- slug: mit_license
  en:
    term: "MIT License"
    def: >
      A [license](#license) that allows people to re-use software with no restrictions.


- slug: mock_object
  en:
    term: "mock object"
    def: >
      A simplified replacement for part of a program whose behavior is easy to control
      and predict. Mock objects are used in [unit tests](#unit_test) to simulate
      databases, web services, and other complex systems.


- slug: mode
  ref:
    - mean
    - median
  en:
    term: "mode"
    def: >
      The value, or values, that occurs most frequently in a dataset.
  af:
    term: "modus"
    def: >
      Die waarde wat die meeste in 'n datastel voorkom.


- slug: model
  en:
    term: "model"
    def: >
      A specification of the mathematical relationship between different variables.


- slug: module
  en:
    term: "module"
    def: >
      A reusable software [package](#package), also often called a [library](#library).


- slug: monte_carlo
  ref:
    - markov_chain
  en:
    term: "Monte Carlo method"
    def: >
      Any method or algorithm that relies on artificially-injected randomness.


- slug: moving_average
  en:
    term: "moving average"
    def: >
      The [mean](#mean) of each set of several consecutive values from [time
      series](#time_series) data.


- slug: multi_threaded
  en:
    term: "multi-threaded"
    def: >
      Capable of performing several operations simultaneously. Multi-threaded programs
      are usually more efficient than [single-threaded](#single_threaded) ones, but
      also harder to understand and debug.


- slug: mutation
  en:
    term: "mutation"
    def: >
      Changing data in place, such as modifying an element of an array or adding a
      record to a database.


- slug: n_gram
  en:
    term: "n-gram"
    def: >
      A sequence of $N$ items, typically words in natural language. For example, a
      trigram is a sequence of three words. N-grams are often used as input in
      [computational linguistics](#computational_linguistics).


- slug: na
  ref:
    - "null"
  en:
    term: "NA"
    def: >
      A special value used to represent data that is not available.
  ar:
    term: "لاشيء"
    def: >
      هو رمز مميز يٌمثِل حرفاً بلا قيمة أو قيمة مفقودة أي انه يرمز إلى عدم وجود أي
      قيمة على الإطلاق.


- slug: naive_bayes_classifier
  en:
    term: "naive Bayes classifier"
    def: >
      Any [classification](#classification) algorithm based on [Bayes'
      Theorem](#bayes_theorem) that assumes every [feature](#feature_data) being
      classified is independent of every other feature.


- slug: name_collision
  ref:
    - call_stack
    - fully_qualified_name
  en:
    term: "name collision"
    def: >
      The ambiguity that arises when two or more things in a program that have the
      same name are active at the same time. Most languages use
      [namespaces](#namespace) to prevent such collisions.


- slug: named_argument
  ref:
    - keyword_argument
    - variable_arguments
  en:
    term: "named argument"
    def: >
      A function [parameter](#parameter) that is given a value by explicitly naming it in a function call.


- slug: namespace
  ref:
    - name_collision
    - scope
  en:
    term: "namespace"
    def: >
      A collection of names in a program that exists in isolation from other
      namespaces. Each function, [object](#object), [class](#class), or
      [module](#module) in a program typically has its own namespace so that
      references to "X" in one part of a program do not accidentally refer to
      something called "X" in another part of the program. Scope is a distinct, but related, concept.


- slug: nano_editor
  en:
    term: "Nano (editor)"
    def: >
      A very simple text editor found on most Unix systems.


- slug: negative_selection
  en:
    term: "negative selection"
    def: >
      To specify the [elements](#element) of a [vector](#vector) or other data structure that are not desired
      by negating their indices.


- slug: neural_network
  ref:
    - deep_learning
    - backpropagation
    - perceptron
  en:
    term: "neural network"
    def: >
      One of a large family of algorithms for identifying patterns in data by
      mimicking the way neurons interact. A neural network consists of one or more
      layers of [nodes](#node), each of which is connected to nodes in the preceding and
      subsequent layer. If enough of a node's inputs are active, that node activates
      as well.


- slug: nlp
  en:
    term: "natural language processing"
    acronym: "NLP"
    def: >
      See [computational linguistics](#computational_linguistics).


- slug: node
  en:
    term: "node"
    def: >
      An element of a [graph](#graph) that is connected to other nodes by
      [edges](#edge). Nodes typically have data associated with them, such as names or weights.


- slug: non_blocking_execution
  en:
    term: "non-blocking execution"
    def: >
      To allow a program to continue running while an operation is in progress. For
      example, many systems support non-blocking execution for file I/O so that the
      program can continue doing work while it waits for data to be read from or
      written to the [filesystem](#filesystem) (which is typically much slower than
      the CPU).


- slug: normal_distribution
  en:
    term: "normal distribution"
    def: >
      A continuous random distribution with a symmetric bell-curve shape. As datasets
      get larger, some of their most important statistical properties can be modeled
      using a normal distribution.


- slug: nosql_database
  en:
    term: "NoSQL database"
    def: >
      Any database that does not use the [relational](#relational_database) model. The name comes from
      the fact that such databases do not use [SQL](#sql) as a query language.
  fr:
    term: "base de données NoSQL"
    def: >
      Une base de données qui ne suit pas le modèle [relationnel](#relational_database), ainsi nommée car
      n'utilisant en principe pas le langage de requête [SQL](#sql).


- slug: "null"
  en:
    term: "null"
    def: >
      A special value used to represent a missing object. Null is not the same as NA,
      and neither is it the same as an [empty vector](#empty_vector).


- slug: null_hypothesis
  ref:
    - p_value
  en:
    term: "null hypothesis"
    def: >
      The claim that any patterns seen in data are entirely due to chance. Other
      claims (e.g., "X causes Y") must be much more likely than the null hypothesis in
      order to be substantiated.
  pt:
    term: "hipótese nula"
    def: >
      A afirmação de que quaisquer padrões observados nos dados foram gerados
      inteiramente ao acaso. Outras afirmações (por exemplo, "X causa Y") devem ser
      mais prováveis de acontecer do que a hipótese nula para que possam ser sustentadas.


- slug: nullary_expression
  ref:
    - binary_expression
    - ternary_expression
    - unary_expression
  en:
    term: "nullary expression"
    def: >
      An "expression" with no arguments, such as the value 3.


- slug: object
  en:
    term: "object"
    def: >
      In [object-oriented programming](#oop), a structure that contains the data
      for a specific instance of a [class](#class). The operations the object is
      capable of are defined by the class's [methods](#method).
  es:
    term: "objeto"
    def: >
      En [programación orientada a objetos](#oop), es una estructura que contiene
      los datos de una instancia específica de una [clase](#class). Las
      operaciones que son capaces de realizar estos objetos están definidas
      por los [métodos](#method) de la clase.


- slug: objective_function
  ref:
    - gradient_descent
  en:
    term: "objective function"
    def: >
      A function of one or more variables used to measure or compare the goodness of
      different solutions in an optimization problem.


- slug: observation
  en:
    term: "observation"
    def: >
      A value or property of a specific member of a population.


- slug: off_by_one_error
  en:
    term: "off-by-one error"
    def: >
      A common error in programming in which the program refers to element `i` of a
      structure when it should refer to element `i-1` or `i+1`, or processes `N`
      elements when it should process `N-1` or `N+1`.


- slug: oop
  en:
    term: "object-oriented programming"
    acronym: "OOP"
    def: >
      A style of programming in which functions and data are bound together in
      [objects](#object) that only interact with each other through well-defined
      interfaces.
  es:
    term: "programación orientada a objetos"
    acronym: "POO"
    def: >
      Un paradigma de programación en el cual los datos (atributos) y funciones
      (métodos) se agrupan en objetos que interactúan entre sí a través de
      interfaces bien definidas.
  pt:
    term: "programação orientada a objetos"
    acronym: "POO"
    def: >
      Um paradigma de programação no qual dados (atributos) e funções (métodos)
      são encapsulados em objetos que interagem entre si por meio de
      interfaces bem definidas.


- slug: open_license
  en:
    term: "open license"
    def: >
      A [license](#license) that permits general re-use, such as the [MIT
      License](#mit_license) or [GPL](#gpl) for software and [CC-BY](#cc_by) or
      [CC-0](#cc_0) for data, prose, or other creative outputs.


- slug: open_science
  en:
    term: "open science"
    def: >
      A generic term for making scientific software, data, and publications generally available.


- slug: operating_system
  en:
    term: "operating system"
    def: >
      A program that provides a standard interface to whatever hardware it is running
      on. Theoretically, any program that only interacts with the operating system
      should run on any computer that operating system runs on.


- slug: optional_parameter
  en:
    term: "optional_parameter"
    def: >
      A [parameter](#parameter) that does not have to be given a value when a function
      is called. Most programming languages require programmers to define [default
      values](#default_value) for optional parameters, or assign them a special value automatically.
      Arguments passed to optional parameters will often be specified using [keyword
      arguments](#keyword_argument).


- slug: orcid
  en:
    term: "ORCID"
    def: >
      An Open Researcher and Contributor ID that uniquely and persistently identifies
      an author of scholarly works. ORCIDs are for people what [DOIs](#doi) are for documents.


- slug: orthogonality
  en:
    term: "orthogonality"
    def: >
      The ability to use various features of software in any order or combination. Orthogonal
      systems tend to be easier to understand, since features can be combined without
      worrying about unexpected interactions.


- slug: outlier
  ref:
    - overfitting
  en:
    term: "outlier"
    def: >
      Extreme values that might be measurement or recording errors, or might actually
      be rare events. Outliers are sometimes ignored when doing statistics, or handled
      or visualized separately.


- slug: overfitting
  ref:
    - outlier
  en:
    term: "overfitting"
    def: >
      Fitting a [model](#model) so closely to one dataset that it does not generalize
      to others.


- slug: p_value
  en:
    term: "p value"
    def: >
      The probability of obtaining a result at least as strong as the one observed if
      the [null_hypothesis](#null_hypothesis) is [true](#true) (i.e., if variation is purely
      due to chance). The lower the p-value, the more likely it is that something
      other than chance is having an effect.


- slug: package
  en:
    term: "package"
    def: >
      A collection of code, data, and documentation that can be distributed and
      re-used. Also referred to in some languages as a [library](#library) or [module](#module).


- slug: package_manager
  en:
    term: "package manager"
    def: >
      A program that does its best to keep track of the different software
      installed on a computer and their dependencies on one another.


- slug: pager
  en:
    term: "pager"
    def: >
      A program that displays a few lines of text at a time.


- slug: parameter
  en:
    term: "parameter"
    def: >
      A variable specified in a function definition whose value is passed to the function
      when the function is called. Parameters and arguments are distinct, but related concepts.
      Parameters are variables and [arguments](#argument) are the values assigned to those variables.


- slug: parent_class
  en:
    term: "parent class"
    def: >
      In [object-oriented programming](#oop), the [class](#class) from which a sub
      class (called the [child class](#child_class)) is derived.
  es:
    term: "superclase"
    def: >
      En [programación orientada a objetos](#oop), es la clase a partir de
      la cual se derivan otras clases (denominadas [subclases](#child_class)).
  pt:
    term: "classe base"
    def: >
      Em [programação orientada a objetos](#oop), a classe a partir da qual outra
      classe (chamada [classe derivada](#child_class)) é produzida.


- slug: parent_directory
  ref:
    - subdirectory
  en:
    term: "parent directory"
    def: >
      The [directory](#directory) that contains another directory of interest. Going from a
      directory to its parent, then its parent, and so on eventually leads to the
      [root directory](#root_directory) of the [filesystem](#filesystem).


- slug: parent_tree
  en:
    term: "parent (in a tree)"
    def: >
      A [node](#node) in a [tree](#node) that is above another node (call a
      [child](#child_tree)). Every node in a tree except the [root node](#root_tree)
      has a single parent.


- slug: parse
  en:
    term: "parse"
    def: >
      To translate the text of a program or web page into a data structure in memory
      that the program can then manipulate.


- slug: pass_test
  ref:
    - fail_test
  en:
    term: "pass (a test)"
    def: >
      A test passes if the [actual result](#actual_result) matches the [expected result](#expected_result).


- slug: patch
  en:
    term: "patch"
    def: >
      A single file containing a set of changes to a set of files, separated by markers
      that indicate where each individual change should be applied.


- slug: path
  ref:
    - absolute_path
    - relative_path
  en:
    term: "path (in filesystem)"
    def: >
      A [string](#string) that specifies a location in a [filesystem](#filesystem). In Unix, the
      [directories](#directory) in a path are joined using `/`.


- slug: pattern_rule
  en:
    term: "pattern rule"
    def: >
      A generic [build rule](#build_rule) that describes how to update any file whose
      name matches a pattern. Pattern rules often use [automatic
      variables](#automatic_variable) to represent the actual filenames.


- slug: peanuts
  en:
    term: "Peanuts"
    def: >
      An American comic strip by Charles M. Schulz which has inspired the names of [R](#r_language) versions.


- slug: perceptron
  en:
    term: "perceptron"
    def: >
      The simplest kind of [neural network])(#neural_network), which approximates a
      single neuron with _N_ binary inputs by computing a weighted sum of its inputs and
      firing if that value is zero or greater.


- slug: permalink
  en:
    term: "permalink"
    def: >
      Short for "permanent link", a URL that is intended to last forever.


- slug: phony_target
  en:
    term: "phony target"
    def: >
      A [build target](#build_target) that does not correspond to an actual file.
      Phony targets are often used to store commonly-used commands in a [Makefile](#makefile).


- slug: pipe_operator
  en:
    term: "pipe operator"
    def: >
      The `%>%` used to make the output of one function the input of the next.


- slug: pipe_shell
  en:
    term: "pipe (in the Unix shell)"
    def: >
      The `|` used to make the output of one command the input of the next.


- slug: pivot_table
  en:
    term: "pivot table"
    def: >
      A technique for summarizing tabular data in which each cell represents the sum,
      average, or other function of the subset of the original data identified by the
      cell's row and column heading.


- slug: plus_one
  de:
    term: "+1"
    def: >
      Eine Zustimmung zu etwas.
  en:
    term: "+1"
    def: >
      A vote in favor of something.
  fr:
    term: "+1"
    def: >
      Un vote en faveur de quelque chose.
  es:
    term: "+1"
    def: >
      Un voto a favor de alguna cosa.


- slug: poisson_distribution
  en:
    term: "Poisson distribution"
    def: >
      A [discrete random distribution](#discrete_random_variable) that expresses the
      probability of $N$ events occurring in a fixed time interval if the events occur
      at a constant rate, independent of the time since the last event.


- slug: positional_argument
  ref:
    - keyword_argument
    - named_argument
  en:
    term: "positional argument"
    def: >
      An argument to a function that gets its value according to its place in the
      function's definition, as opposed to a named argument that is
      explicitly matched by name.


- slug: posterior_distribution


- slug: pothole_case
  ref:
    - camel_case
    - kebab_case
  en:
    term: "pothole case"
    def: >
      A naming style that separates the parts of a name with underscores, as in `first_second_third`.


- slug: prerequisite
  ref:
    - dependency
  en:
    term: "prerequisite"
    def: >
      Something that a [build target](#build_target) depends on.


- slug: principal_component_analysis
  ref:
    - dimension_reduction
  en:
    term: "principal component analysis"
    acronym: "PCA"
    def: >
      An algorithm that find the axis along which data varies most, then the axis that
      accounts for the largest part of the remaining variation, and so on.


- slug: prior_distribution
  en:
    term: "prior distribution"
    def: >
      The [probability distribution](#probability_distribution) that is assumed as a
      starting point when using [Bayes' Theorem](#bayes_theorem) and used to construct
      a more accurate [posterior_distribution](#posterior_distribution).


- slug: prng
  ref:
    - seed
  en:
    term: "pseudo-random number generator"
    acronym: "PRNG"
    def: >
      A function that can generate [pseudo-random numbers](#pseudo_random_number).


- slug: probability_distribution
  en:
    term: "probability distribution"
    def: >
      A mathematical description of all possible outcomes of a random event, and the
      probability of each occurring.


- slug: procedural_programming
  en:
    term: "procedural programming"
    def: >
      A style of programming in which functions operate on data that is passed into
      them. The term is used in contrast to other programming styles, such as
      [object-oriented programming](#oop) and [functional programming](#functional_programming).


- slug: process
  en:
    term: "process"
    def: >
      An [operating system](#operating_system)'s representation of a running program.
      A process typically has some memory, the identity of the user who is running it,
      and a set of connections to open files.


- slug: product_manager
  en:
    term: "product manager"
    def: >
      The person responsible for defining what features a product should have.


- slug: production_code
  en:
    term: "production code"
    def: >
      Software that is delivered to an end user. The term is used to distinguish such
      code from test code, deployment infrastructure, and everything else that
      programmers write along the way.


- slug: project_manager
  en:
    term: "project manager"
    def: >
      The person responsible for ensuring that a project moves forward.


- slug: prompt
  ref:
    - continuation_prompt
  en:
    term: "prompt"
    def: >
      The text printed by an [REPL](#repl) or [shell](#shell) that indicates it is
      ready to accept another command. The default prompt in the Unix shell is usually
      `$`, while in [Python](#python) it is `>>>`, and in [R](#r_language) it is `>`.


- slug: protocol
  en:
    term: "protocol"
    def: >
      Any standard specifying how two pieces of software interact. A network protocol
      such as [HTTP](#http) defines the messages that [clients](#client) and
      [servers](#server) exchange on the World-Wide Web; [object-oriented](#oop)
      programs often define protocols for interactions between [objects](#object) of
      different [classes](#class).


- slug: provenance
  en:
    term: "provenance"
    def: >
      A record of where data originally came from and what was done to process it.


- slug: pseudo_random_number
  en:
    term: "pseudo-random number"
    def: >
      A value generated in a repeatable way that resembles the [true](#true) randomness of the
      universe well enough to fool observers.


- slug: psf
  en:
    term: "Python Software Foundation"
    acronym: "PSF"
    def: >
      A non-profit organization that oversees and promotes the development and use of [Python](#python).


- slug: pull_indexing
  ref:
    - push_indexing
  en:
    term: "pull indexing"
    def: >
      Vectorized indexing in which the value at location `i` in the index [vector](#vector)
      specifies which [element](#element) of the source vector is being pulled into that location
      in the result vector, i.e., `result[i] = source[index[i]]`.


- slug: pull_request
  en:
    term: "pull request"
    def: >
      The request to merge a new feature or correction created on a user's [fork](#fork) of a
      [Git](#git) [repository](#repository)repository into the [upstream repository](#upstream_repository).
      The developer will be notified of the change, review it, make or suggest changes, and potentially
      [merge](#git_merge) it.


- slug: push_indexing
  ref:
    - pull_indexing
  en:
    term: "push indexing"
    def: >
      Vectorized indexing in which the value at location `i` in the index [vector](#vector)
      specifies an [element](#element) of the result vector that gets the corresponding element of
      the source vector, i.e., `result[index[i]] = source[i]`. Push indexing can
      easily produce gaps and collisions.


- slug: python
  en:
    term: "Python"
    def: >
      A popular interpreted open-source programming language that relies on
      indentation to define control structure.


- slug: quantile
  en:
    term: "quantile"
    def: >
      If a set of sorted values are divided into groups of each size, each group is
      called a quantile. For example, if there are five groups, each is called a
      *quintile*; the bottom quintile contains the lowest 20% of the values, while the
      top quintile contains the highest 20%.


- slug: query_string
  en:
    term: "query string"
    def: >
      The portion of a [URL](#url) after the quesiton mark `?` that specifies extra
      parameters for the [HTTP request](#http_request) as name-value pairs.


- slug: quosure
  en:
    term: "quosure"
    def: >
      A data structure containing an unevaluated expression and its environment.


- slug: quoting_function
  en:
    term: "quoting function"
    def: >
      A function that is passed expressions rather than the values of those expressions.


- slug: r_consortium
  en:
    term: "R Consortium"
    def: >
      A group that supports the worldwide community of users, maintainers and
      developers of [R](#r_language). Its members include leading institutions and
      companies dedicated to the use, development, and growth of R.


- slug: r_foundation
  en:
    term: "R Foundation"
    def: >
      A non-profit founded by the R development core team providing support for [R](#r_language). It
      is a member of the [R Consortium](#r_consortium).


- slug: r_hub
  en:
    term: "R Hub"
    def: >
      A free platform available to check an [R](#r_language) [package](#package) on several different platforms
      in preparation for the CRAN submission process.


- slug: r_language
  en:
    term: "R (programming language)"
    def: >
      A popular open-source programming language used primarily for data science.
  fr:
    term: "R (langage de programmation)"
    def: >
      Un langage de programmation et logiciel libre principalement utilisé en statistique et en science des données.
  pt:
    term: "R (linguagem de programação)"
    def: >
      Uma linguagem de programação de código aberto usada principalmente para ciência de dados.


- slug: r_markdown
  ref:
    - computational_notebook
    - literate_programming
  en:
    term: "R Markdown"
    def: >
      A dialect of [Markdown](#markdown) that allows authors to mix prose and code (usually written in
      [R](#r_language)) in a single document.
  es:
    term: "R Markdown"
    def: >
      Un dialecto de [Markdown](#markdown) que permite a sus autores mezclar prosa y
      código (usualmente escrito en [R](#r_language)) en un mismo documento.
  fr:
    term: "R Markdown"
    def: >
      Un dialecte de [Markdown](#markdown) qui permet à ses auteurs de mélanger langage naturel et code
      (habituellement écrit en langage [R](#r_language)) dans un même document.
      Voir aussi programmation lettrée.


- slug: raise_exception
  ref:
    - throw_exception
  en:
    term: "raise (an exception)"
    def: >
      To signal that something unexpected or unusual has happened in a program by
      creating an [exception](#exception) and handing it to the [error-handling](#error_handling) system,
      which then tries to find a point in the program that will
      [catch](#catch_exception) it.


- slug: random_forests
  en:
    term: "random forests"
    def: >
      An algorithm used for regression or [classification](#classification) that uses a collection of
      [decision trees](#decision_tree), called a forest. Each tree votes for a classification, and the
      algorithm chooses the classification having the most votes over all the trees in the forest.


- slug: raster_image
  en:
    term: "raster image"
    def: >
      An image stored as a matrix of pixels.


- slug: reactive_programming
  en:
    term: "reactive programming"
    def: >
      A style of programming in which actions are triggered by external events.


- slug: reactive_variable
  en:
    term: "reactive variable"
    def: >
      A variable whose value is automatically updated when some other value or values
      change. Reactive variables are used extensively in [Shiny](#shiny).

- slug: readme
  ref:
    - markdown
    - vignette
  en:
    term: "README"
    def: >
      A plain text file containing important information about a project or software package.


- slug: record
  en:
    term: "record"
    def: >
      A group of related values that are stored together. A record may be represented
      as a [tuple](#tuple) or as a row in a [table](#table); in the latter case, every
      record in the table has the same [fields](#field).
  fr:
    term: "entrée"
    def: >
      Un groupe de valeurs liées qui sont enregistrées ensemble. Une entrée peut être
      représentée comme un [tuple](#tuple) ou une ligne dans une [table](#table); dans
      ce dernier cas, chaque entrée dans la table comporte les même [champs](#field).


- slug: recursion
  en:
    term: "recursion"
    def: >
      Calling a function from within a call to that function, or defining a term using
      a simpler version of the same term.
  fr:
    term: "récursion"
    def: >
      Faire appel à une fonction au sein de cette même fonction, ou définir un terme
      en utilisant une version simplifiée du même terme.


- slug: recycle
  en:
    term: "recycle"
    def: >
      To re-use values from a shorter [vector](#vector) in order to generate a sequence of the
      same length as a longer one. In [Python](#python) NumPy, this is called broadcasting.
  es:
    term: "reciclar"
    def: >
      Reutilizar valores de un vector más corto con el fin de generar una secuencia
      del mismo largo que el vector más largo.


- slug: redirection
  en:
    term: "redirection"
    def: >
      To send a request for a web page or web service to a different page or service.


- slug: refactoring
  en:
    term: "refactoring"
    def: >
      Reorganizing software without changing its behavior.


- slug: regression_testing
  en:
    term: "regression testing"
    def: >
      Testing software to ensure that things which used to work have not been broken.


- slug: regular_expression
  en:
    term: "regular expression"
    def: >
      A pattern for matching text, written as text itself. Regular expressions are
      sometimes called "regexp", "regex", or "RE", and are powerful tools for working with text.
  es:
    term: "expresión regular"
    def: >
      Un patrón para buscar coincidencias en texto, que están a su vez escritas como
      texto. Las expresiones regulares a veces son llamadas "regexp", "regex", o "RE",
      y son poderosas.


- slug: reinforcement_learning
  ref:
    - supervised_learning
    - unsupervised_learning
  en:
    term: "reinforcement learning"
    def: >
      Any [machine learning](#machine_learning) algorithm which is not given specific
      goals to meet, but instead is given feedback on whether or not it is making progress.


- slug: relational_database
  ref:
    - sql
  en:
    term: "relational database"
    def: >
      A database that organizes information into [tables](#table), each of which has a fixed set
      of named [fields](#field) (shown as columns) and a variable number of [records](#record) (shown as rows).
  es:
    term: "base de datos relacional"
    def: >
      Una base de datos que organiza la información en [tablas](#table), cada una de las cuales
      tiene un set fijo de [campos](#field) con nombre (que se muestran como columnas) y un
      número variable de [registros](#record) (que se muestran como filas).
  fr:
    term: "base de données relationnelle"
    def: >
      Une base de données dont le contenu est organisé sous forme de [tables](#table),
      chacune avec un ensemble déterminé de [champs](#field) (représentés sous forme de colonnes)
      et un nombre variable d'[entrées](#record) (représentées sous forme de lignes).


- slug: relative_error
  en:
    term: "relative error"
    def: >
      The absolute value of the difference between the actual and correct value
      divided by the correct value. For example, if the actual value is 9 and the
      correct value is 10, the relative error is 0.1. Relative error is usually more
      useful than [absolute error](#absolute_error).
  pt:
    term: "erro relativo"
    def: >
      O valor absoluto da diferença entre um valor observado e o valor correto,
      dividido pelo vaor correto. Por exemplo, se o valor observado é 9 e o correto é
      10, o erro relativo é 0.1. Erro relativo é normalmente mais útil do que o [erro absoluto](#absolute_error).
  fr:
    term: "erreur relative"
    def: >
      La valeur absolue de la différence entre la valeur observée et la valeur correcte,
      divisée par la valeur désirée. Par exemple, si la valeur observée est 9 et la valeur
      correcte est 10, l'erreur absolue est 0.1. L'erreur relative est généralement
      plus utile que [l'erreur absolue](#absolute_error).


- slug: relative_path
  ref:
    - absolute_path
  en:
    term: "relative path"
    def: >
      A path whose destination is interpreted relative to some other location, such as
      the [current working directory](#current_working_directory). A relative path is
      the equivalent of giving directions using terms like "straight" and "left".
  pt:
    term: "caminho relativo"
    def: >
      Um caminho cujo destino é interpretado de maneira relativa a outro local, como o
      [diretório de trabalho](#current_working_directory). Um caminho relativo é o
      equivalente a indicar um destino com termos como "siga em frente" e "vire a esquerda".
  fr:
    term: "chemin d'accès relatif"
    def: >
      Un chemin d'accès dont la destination est définie relativement à un autre emplacement,
      par exemple le [répertoire de travail actuel](#current_working_directory). Utiliser
      un chemin relatif équivaut à se déplacer à l'aide d'instructions telles que "tout droit"
      ou "tourner à gauche".


- slug: relative_row_number
  en:
    term: "relative row number"
    def: >
      The index of a row in a displayed portion of a table, which may or may not be
      the same as the [absolute row number](#absolute_row_number) within the table.
  pt:
    term: "número de linha relativo"
    def: >
      O índice de uma linha em uma parte da tabela em exibição, que pode ou não ser
      igual ao [número de linha absoluto](#absolute_row_number) na tabela.


- slug: remote_login
  en:
    term: "remote login"
    def: >
      Starting an interactive session on one computer from another computer, e.g., by
      using [SSH](#ssh).


- slug: remote_repository
  en:
    term: "remote repository"
    def: >
      A [repository](#repository) located on another computer. Tools such as [Git](#git) are
      designed to synchronize changes between local and remote
      repositories in order to share work.


- slug: repl
  ref:
    - ide
  en:
    term: "read-eval-print loop"
    acronym: "REPL"
    def: >
      An interactive program that reads a command typed in by a user, executes it,
      prints the result, and then waits patiently for the next command. REPLs are
      often used to explore new ideas, or for debugging.


- slug: repository
  ref:
    - git
    - github
  en:
    term: "repository"
    def: >
      A place where a [version control system](#version_control_system) stores the
      files that make up a project and the metadata that describes their history.
  es:
    term: "repositorio"
    def: >
      Lugar en el que un [sistema de control de versión](#version_control_system)
      guarda los archivos que conforman un proyecto y los metadatos que describen su historia.
  pt:
    term: "repositório"
    def: >
      Um local onde um [sistema de controle de versão](#version_control_system)
      armazena os arquivos que compõem um projeto e os metadados que descrevem sua história.
  ja:
    term: "リポジトリ"
    def: >
       [バージョン管理システム](#version_control_system)において、管理対象となるプロジェクトを構成するファイルとその履歴を説明するメタデータを保存する場所。

- slug: reprex
  en:
    term: "reprex"
    def: >
      A reproducible example. When asking questions about coding problems online or
      filing issues on [GitHub](#github), you should always include a reprex so others can
      reproduce your problem and help. The [reprex](https://github.com/tidyverse/reprex)
      package can help!


- slug: reproducible_example
  en:
    term: "reproducible example"
    def: >
      See [reprex](#reprex).


- slug: reproducible_research
  en:
    term: "reproducible research"
    def: >
      The practice of describing and documenting research results in such a way that
      another researcher or person can re-run the analysis code on the same data to
      obtain the same result.
  pt:
    term: "pesquisa reprodutível"
    def: >
      A prática de escrever e documentar resultados de pesquisa de forma que outras
      pessoas pesquisadoras possam executar novamente o código de análise com os
      mesmos dados para obter os mesmos resultados.


- slug: restructured_text
  ref:
    - markdown
  en:
    term: "reStructured Text"
    acronym: "reST"
    def: >
      A plaintext [markup](#markup_language) format used primarily in [Python](#python) documentation.


- slug: revision
  en:
    term: "revision"
    def: >
      See [commit](#commit).


- slug: right_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "right join"
    def: >
      A [join](#join) that combines data from two tables, A and B. Where [keys](#key) in table
      A match keys in table B, [fields](#field) are concatenated. Where a key in table
      B does *not* match a key in table A, columns from table A are filled with
      [null](#null), [NA](#na), or some other [missing value](#missing_value) signifier.
      Keys from table A that do not exist in table B are dropped.


- slug: root_directory
  en:
    term: "root directory"
    def: >
      The [directory](#directory) that contains everything else, either directly or indirectly. The root
      directory is written `/` (a bare forward slash).


- slug: root_mean_squared_error
  ref:
    - mean_absolute_error
  en:
    term: "root mean squared error"
    acronym: "RMSE"
    def: >
      The square root of the [mean squared error](#mean_squared_error). Like the
      [standard deviation](#standard_deviation), it is in the same units as the
      original data.


- slug: root_tree
  en:
    term: "root (in a tree)"
    def: >
      The [node](#node) in a [tree](#tree) of which all other nodes are direct or indirect
      [children](#child_tree), or equivalently the only node in the tree that has no [parent](#parent_tree).


- slug: rotating_file
  en:
    term: "rotating file"
    def: >
      A set of files used to store recent information. For example, there might be one
      file with results for each day of the week, so that results from last Tuesday
      are overwritten this Tuesday.


- slug: rse
  en:
    term: "research software engineer"
    acronym: "RSE"
    def: >
      Someone whose primary responsibility is to build the specialized software that
      other researchers depend on.


- slug: s3
  en:
    term: "S3"
    def: >
      A framework for [object-oriented programming](#oop) in [R](#r_language).
  es:
    term: "S3"
    def: >
      Un entorno para la [programación orientada a objetos](#oop) en [R](#r_language).


- slug: s4
  en:
    term: "S4"
    def: >
      A framework for [object-oriented programming](#oop) in [R](#r_language).


- slug: s_language
  en:
    term: "S"
    def: >
      A language originally developed in Bell Labs for data analysis, statistical
      modeling, and graphics. [R](#r_language) is a dialect of S.
  es:
    term: "S"
    def: >
      Un lenguaje para análisis de datos, modelado estadístico y gráficos desarrollado
      originalmente en los Laboratorios Bell. [R](#r_language) es un dialecto de S.


- slug: sandbox
  en:
    term: "sandbox"
    def: >
      A testing environment that is separate from the production system, or an
      environment that is only allowed to perform a restricted set of operations for
      security reasons.


- slug: scalar
  en:
    term: "scalar"
    def: >
      A single value of a particular type, such as 1 or "a". Scalars exist in most languages, but do not really
      exist in [R](#r_language); in R, values that appear to be scalars are actually [vectors](#vector) of unit length.
  es:
    term: "escalar"
    def: >
      Un único valor de un tipo particular, como 1 o "a". Los escalares realmente no
      existen en [R](#r_language); los valores que parecen ser escalares son en realidad vectores de
      largo uno.


- slug: schema
  en:
    term: "schema"
    def: >
      A specification of the format of a dataset, including the name, format, and
      content of each [table](#table).
  fr:
    term: "schéma"
    def: >
      Spécification du format d'un ensemble de données qui inclut le nom, format et
      contenu de chaque [table](#table).


- slug: scope
  ref:
    - namespace
  en:
    term: "scope"
    def: >
      The portion of a program within which a definition can be seen and used. See
      [closure](#closure), [global variable](#global_variable), and [local variable](#local_variable).


- slug: script
  en:
    term: "script"
    def: >
      Originally, a program written in a language too user-friendly for "real" programmers to
      take seriously; the term is now synonymous with program.


- slug: search_path
  en:
    term: "search path"
    def: >
      The list of directories that a program searches to find something. For example,
      the Unix [shell](#shell) uses the search path stored in the `PATH` variable when
      trying to find a program whose name it has been given.


- slug: seed
  en:
    term: "seed"
    def: >
      A value used to initialize a [pseudo-random number generator](#prng).


- slug: select
  en:
    term: "select"
    def: >
      To choose entire columns or rows from a table by name or location.


- slug: self_join
  ref:
    - anti_join
    - cross_join
    - full_join
    - inner_join
    - left_join
    - right_join
    - self_join
  en:
    term: "self join"
    def: >
      A [join](#join) that combines a table with itself.


- slug: semantic_versioning
  en:
    term: "semantic versioning"
    def: >
      A standard for identifying software releases. In the version identifier
      `major.minor.patch`, `major` changes when a new version of software is
      incompatible with old versions, `minor` changes when new features are added to
      an existing version, and `patch` changes when small [bugs](#bug) are fixed.


- slug: sense_vote
  ref:
    - marthas_rules
  en:
    term: "sense vote"
    def: >
      A preliminary vote used to determine whether further discussion is needed in a meeting.


- slug: server
  en:
    term: "server"
    def: >
      Typically, a program such as a database manager or web server that provides data
      to a [client](#client) upon request.


- slug: shebang
  en:
    term: "shebang"
    def: >
      In Unix, a character sequence such as `#!/usr/bin/python` in the first line of an
      executable file that tells the [shell](#shell) what program to use to run that file.


- slug: shell
  en:
    term: "shell"
    def: >
      A [command-line interface](#cli) that allows a user to interact with the
      [operating system](#operating_system), such as Bash (for Unix and MacOS) or PowerShell (for Windows).


- slug: shell_script
  en:
    term: "shell script"
    def: >
      A set of commands for the [shell](#shell) stored in a file so that they can be
      re-executed. A shell script is effectively a program.


- slug: shell_variable
  en:
    term: "shell variable"
    def: >
      A variable set and used in the [Unix shell](#shell). Commonly-used shell
      variables include `HOME` (the user's home directory) and `PATH` (their [search path](#search_path)).


- slug: shiny


- slug: short_circuit_test
  ref:
    - lazy_evaluation
  en:
    term: "short circuit test"
    def: >
      A logical test that only evaluates as many arguments as it needs to. For
      example, if `A` is [false](#false), then most languages never evaluate `B` in the
      expression `A and B`.


- slug: short_identifier_git
  en:
    term: "short identifier (of commit)"
    def: >
      The first few characters of a [full identifier](#full_identifier_git). Short
      identifiers are easy for people to type and say aloud, and are usually unique
      within a [repository's](#repository) recent history.


- slug: short_option
  ref:
    - long_option
  en:
    term: "short option"
    def: >
      A single-letter identifier for a [command line
      argument](#command_line_argument). Most common flags are a single letter
      preceded by a dash, such as `-v`.


- slug: side_effect
  en:
    term: "side effect"
    def: >
      A change made by a function while it runs that is visible after the function
      finishes, such as modifying a [global variable](#global_variable) or writing to
      a file. Side effects make programs harder for people to understand, since the
      effects are not necessarily clear at the point in the program where the function is called.


- slug: signal
  en:
    term: "signal (a condition)"
    def: >
      A way of indicating that something has gone wrong in a program, or that some
      other unexpected event has occurred. [R](#r_language) prefers "signalling a condition" to
      "raising an exception". [Python](#python), on the other hand,
      encourages [raising](#raise_exception) and [catching exceptions](#catch_exception),
      and in some situations, requires it.


- slug: single_square_brackets
  ref:
    - double_square_brackets
  en:
    term: "single square brackets"
    def: >
      One set of square brackets `[ ]`, used to select a structure from another structure based
      on an index value, or range of values, inside the square brackets.


- slug: single_threaded
  en:
    term: "single-threaded"
    def: >
      A model of program execution in which only one thing can happen at a time.
      Single-threaded execution is easier for people to understand, but less efficient
      than [multi-threaded](#multi_threaded) execution.


- slug: singleton
  ref:
    - singleton_pattern
  en:
    term: "singleton"
    def: >
      A set with only one element, or a [class](#class) with only one [instance](#instance).


- slug: singleton_pattern
  en:
    term: "Singleton pattern"
    def: >
      A [design pattern](#design_pattern) that creates a [singleton](#singleton)
      [object](#object) to manage some resource or service, such as a database or
      [cache](#cache). In [object-oriented programming](#oop), the pattern is usually
      implemented by hiding the [constructor](#constructor) of the [class](#class) in some way
      so that it can only be called once.


- slug: slug
  en:
    term: "slug"
    def: >
      An abbreviated portion of a page's URL that uniquely identifies it. In the
      example `https://www.mysite.com/category/post-name`, the slug is `post-name`.


- slug: snake_case
  ref:
    - camel_case
    - kebab_case
  en:
    term: "snake case"
    def: >
      See [pothole case](#pothole_case).


- slug: software_distribution
  ref:
    - distro
  en:
    term: "software distribution"
    def: >
      A set of programs that are built, tested, and distributed as a collection so
      that they can run together.


- slug: source_distribution
  en:
    term: "source distribution"
    def: >
      A [software distribution](#software_distribution) that includes the source code,
      typically so that programs can be recompiled on the target computer when they
      are installed.


- slug: sprint
  en:
    term: "sprint"
    def: >
      A short, intense period of work on a project.


- slug: sql
  en:
    term: "SQL"
    def: >
      The language used for writing queries for a [relational
      database](#relational_database). The term is an acronym for
      Structured Query Language.
  es:
    term: "SQL"
    def: >
      Lenguaje utilizado para escribir consultas para una [base de datos
      relacional](#relational_database). El término está un acrónimo del
      inglés Structured Query Language (Lenguage Estructurado de Consulta).
  fr:
    term: "SQL"
    def: >
      Langage employé pour composer des requêtes dans une [base de données relationnelle](#relational_database).
      Le terme était originellement l'acronyme de "Structured Query Language" (langage de requête structurée).


- slug: ssh
  en:
    term: "Secure Shell"
    acronym: "SSH"
    def: >
      A program that allows secure access to remote computers.


- slug: ssh_key
  en:
    term: "SSH key"
    def: >
      A string of random bits stored in a file that is used to identify a user for
      [SSH](#ssh). Each SSH key has separate public and private parts; the public part
      can safely be shared, but if the private part becomes known, the key is compromised.


- slug: stack_frame
  en:
    term: "stack frame"
    def: >
      A section of the [call stack](#call_stack) that records details of a single call
      to a specific function.


- slug: stack_overflow
  en:
    term: "Stack Overflow"
    def: >
      A question-and-answer site popular among programmers.
  pt:
    term: "Stack Overflow"
    def: >
      Um site de perguntas e respostas popular entre pessoas programadoras.


- slug: standard_deviation
  ref:
    - 68_95_997_rule
  en:
    term: "standard deviation"
    def: >
      How widely values in a dataset differ from the [mean](#mean). It is calculated
      as the square root of the [variance](#variance).
  pt:
    term: "desvio padrão"
    def: >
      O quanto os valores de um conjunto de dados diferem da [média](#mean). É calculado
      como a raiz quadrada da [variância](#variance).


- slug: standard_normal_distribution
  en:
    term: "standard normal distribution"
    def: >
      A [normal distribution](#normal_distribution) with a [mean](#mean) of 0 and a
      [standard deviation](#standard_deviation) of 1. Values from normal distributions
      with other [parameters](#parameter) can easily be rescaled to be on a standard normal distribution.


- slug: stderr
  ref:
    - stdin
    - stdout
  en:
    term: "standard error"
    def: >
      A predefined communication channel for a [process](#process), typically used for
      error messages.


- slug: stdin
  ref:
    - stderr
    - stdout
  en:
    term: "standard input"
    def: >
      A predefined communication channel for a [process](#process), typically used to
      read input from the keyboard or from the previous process in a [pipe](#pipe_shell).


- slug: stdout
  ref:
    - stderr
    - stdin
  en:
    term: "standard output"
    def: >
      A predefined communication channel for a [process](#process), typically used to
      send output to the screen or to the next process in a [pipe](#pipe_shell).


- slug: stratified_sampling
  en:
    term: "stratified sampling"
    def: >
      Selecting values by dividing the overall population into [homogeneous](#homogeneous)
      groups and then taking a random sample from each group.


- slug: stream
  en:
    term: "stream"
    def: >
      A sequential flow of data, such as the [bits](#bit) arriving across a network connection
      or the bytes read from a file.


- slug: string
  en:
    term: "string"
    def: >
      A block of text in a program. The term is short for "character string".
  es:
    term: "secuencia de caracteres"
    def: >
      Bloque de texto en un programa.


- slug: string_interpolation
  en:
    term: "string interpolation"
    def: >
      The process of inserting text corresponding to specified values into a [string](#string),
      usually to make output human-readable.


- slug: students_t_distribution
  en:
    term: "student's t-distribution"
    def: >
      See [t-distribution](#t_distribution).


- slug: subcommand
  en:
    term: "subcommand"
    def: >
      A command that is part of a larger family of commands. For example, `git commit`
      is a subcommand of [Git](#git).


- slug: subdirectory
  ref:
    - parent_directory
  en:
    term: "subdirectory"
    def: >
      A directory that is below another directory.


- slug: supervised_learning
  ref:
    - unsupervised_learning
    - reinforcement_learning
  en:
    term: "supervised learning"
    def: >
      A [machine learning](#machine_learning) algorithm in which a system is taught to
      [classify](#classification) values given [training data](#training_data) containing
      previously-classified values.


- slug: svm
  en:
    term: "support vector machine"
    acronym: "SVM"
    def: >
      A [supervised learning](#supervised_learning) algorithm that seeks to divide
      points in a dataset so that the empty space between the resultant sets is as wide as possible.


- slug: synchronous
  ref:
    - asynchronous
  en:
    term: "synchronous"
    def: >
      To happen at the same time. In programming, synchronous operations are ones that
      have to run simultaneously, or complete at the same time.


- slug: systematic_error
  en:
    term: "systematic error"
    def: >
      See [bias](#bias).


- slug: t_distribution
  ref:
    - students_t_distribution
  en:
    term: "t-distribution"
    def: >
      A variation on the [normal distribution](#normal_distribution) that is adjusted
      to account for estimating [variance](#variance) from the sample instead of
      knowing it in advance.


- slug: tab_completion
  en:
    term: "tab completion"
    def: >
      A technique implemented by most [REPLs](#repl), [shells](#shell), and
      programming editors that completes a command, variable name, filename, or other
      text when the TAB key is pressed.


- slug: table
  en:
    term: "table"
    def: >
      A set of [records](#record) in a [relational database](#relational_database) or
      [observations](#observation) in a [data frame](#data_frame). Tables are usually displayed as
      rows (each of which represents one record or observation and columns (each of which represents a
      [field](#field) or [variable](#variable_data).
  fr:
    term: "table"
    def: >
      Une série d'entrées dans une [base de données
      relationnelle](#relational_database) ou d'observations dans une [trame de
      données](#data_frame). Une table est généralement représentée sous la forme de
      lignes (où chacune représente une [entrée](#record) ou
      [observation](#observation)) et colonnes (où chacune représente un
      [champ](#field) ou une [variable](#variable_data)).


- slug: tag
  en:
    term: "tag (in version control)"
    def: >
      A readable label attached to a specific [commit](#commit) so that it can easily
      be referenced to later.


- slug: tdd
  en:
    term: "test-driven development"
    acronym: "TDD"
    def: >
      A programming practice in which tests are written before a new feature is added
      or a [bug](#bug) is fixed in order to clarify the goal.


- slug: template_method_pattern
  en:
    term: "Template Method pattern"
    def: >
      A [design pattern](#design_pattern) in which a [parent class](#parent_class)
      defines an overall sequence of operations by calling [abstract
      methods](#abstract_method) that [child classes](#child_class) must then
      implement. Each child class then behaves in the same general way, but implements
      the steps differently.


- slug: ternary_expression
  ref:
    - binary_expression
    - nullary_expression
    - unary_expression
  en:
    term: "ternary expression"
    def: >
      An expression that has three parts. [Conditional expressions](#conditional_expression)
      are the only ternary expressions in most languages.


- slug: test_data


- slug: test_runner
  en:
    term: "test runner"
    def: >
      A program that finds and runs software tests and reports their results.


- slug: three_vs
  en:
    term: "three Vs"
    def: >
      The volume, velocity, and variety that distinguish [big data](#big_data).


- slug: throw_exception
  en:
    term: "throw (exception)"
    def: >
      Another term for [raising](#raise_exception) an exception.


- slug: tibble
  en:
    term: "tibble"
    def: >
      A modern replacement for [R](#r_language)'s data frame, which stores tabular data in columns
      and rows, defined and used in the [tidyverse](#tidyverse).
  fr:
    term: "tibble"
    def: >
      Une alternative moderne du "data frame" en [R](#r_language) permettant de matérialiser des
      données tabulaires en colonnes et en lignes, le "tibble" a été défini et est
      utilisé dans le [tidyverse](#tidyverse).
  es:
    term: "tibble"
    def: >
      Un remplazo moderno para los data frames de [R](#r_language) que guarda datos tabulares en
      columnas y filas, definido y usado en el [tidyverse](#tidyverse).


- slug: ticket
  en:
    term: "ticket"
    def: >
      See [issue](#issue).


- slug: ticketing_system
  en:
    term: "ticketing system"
    def: >
      See [issue tracking system](#issue_tracking_system).


- slug: tidy_data
  ref:
    - table
  en:
    term: "tidy data"
    def: >
      Tabular data that satisfies [three
      conditions](https://vita.had.co.nz/papers/tidy-data.pdf) that facilitate initial
      cleaning, and later exploration and analysis—(1) each variable forms a column,
      (2) each observation forms a row, and (3) each type of observation unit forms a table.
  es:
    term: "datos ordenados"
    def: >
      Datos tabulares que satisfacen [tres
      condiciones](https://vita.had.co.nz/papers/tidy-data.pdf) que facilitan su
      limpieza inicial y su posterior exploración y análisis—(1) cada variable
      conforma una columna, (2) cada observación conforma una fila y (3) cada tipo de
      unidad de observación conforma una tabla.


- slug: tidymodels
  en:
    term: "Tidymodels"
    def: >
      A collection of [R](#r_language) [packages](#package) for modeling and statistical analysis designed with a
      [shared philosophy](https://tidymodels.github.io/model-implementation-principles/index.html).
  fr:
    term: "Tidymodels"
    def: >
      Une collection de packages [R](#r_language) pour la modélisation et l'analyse statistique
      élaborés en prenant en considération une [philosophie partagée](https://tidymodels.github.io/model-implementation-principles/index.html)


- slug: tidyverse
  en:
    term: "Tidyverse"
    def: >
      A collection of [R](#r_language) [packages](#package) for operating on tabular data in consistent ways.
  fr:
    term: "Tidyverse"
    def: >
      Une collection de packages [R](#r_language) permettant le traitement des données tabulaire
      d'une manière cohérente.
  es:
    term: "Tidyverse"
    def: >
      Una colección de paquetes de [R](#r_language) para operar de maneras consistentes con datos tabulares.
  pt:
    term: "Tidyverse"
    def: >
      Uma coleção de pacotes de [R](#r_language) para trabalhar de forma consistente com dados tabulares.


- slug: time_series
  ref:
    - moving_average
  en:
    term: "time series"
    def: >
      A set of measurements taken at different times, which may or may not be regular intervals.


- slug: timestamp
  en:
    term: "timestamp"
    def: >
      A digital identifier showing the time at which something was created or
      accessed. Timestamps should use [ISO date format](#iso_date_format) for portability.


- slug: tolerance
  en:
    term: "tolerance"
    def: >
      How closely the [actual result](#actual_result) of a test must agree with the
      [expected result](#expected_result) in order for the test to pass. Tolerances
      are usually expressed in terms of [relative error](#relative_error).


- slug: training_data


- slug: transitive_dependency
  en:
    term: "transitive dependency"
    def: >
      If A depends on B and B depends on C, C is a transitive dependency of A.


- slug: tree
  en:
    term: "tree"
    def: >
      A [graph](#graph) in which every node except the [root](#root_tree) has exactly
      one [parent](#parent_tree).


- slug: triage
  en:
    term: "triage"
    def: >
      To go through the [issues](#issue) associated with a project and decide which
      are currently priorities. Triage is one of the key responsibilities of a
      [project manager](#project_manager).


- slug: "true"
  ref:
    - truthy
    - falsy
  en:
    term: "true"
    def: >
      The logical ([Boolean](#boolean)) state opposite of "[false](#false)". Used in
      logic and programming to represent a [binary](#binary) state of something.


- slug: truthy
  ref:
    - falsy
  en:
    term: "truthy"
    def: >
      Evaluating to [true](#true) in a [Boolean](#boolean) context.


- slug: tuple
  en:
    term: "tuple"
    def: >
      A data type that has a fixed number of parts, such as the three color components of a
      red-green-blue color specification. Tuples are immutable (their values can not be reset.)


- slug: two_hard_problems
  en:
    term: "two hard problems in computer science"
    def: >
      Refers to a quote by Phil Karlton—"There are only two hard problems in computer
      science—cache invalidation and naming things." Many variations add a third
      problem (most often "[off-by-one errors](#off_by_one_error)").


- slug: type_coercion
  en:
    term: "type coercion"
    def: >
      To convert data from one type to another, e.g., from the integer `4` to the
      equivalent floating point number `4.0`.


- slug: unary_expression
  ref:
    - binary_expression
    - nullary_expression
    - ternary_expression
  en:
    term: "unary expression"
    def: >
      An expression with one argument, such as `log 5`.


- slug: unicode
  en:
    term: "Unicode"
    def: >
      A standard that defines numeric codes for many thousands of characters and
      symbols. Unicode does not define how those numbers are stored; that is done by
      standards like [UTF-8](#utf_8).


- slug: unit_test
  ref:
    - integration_test
  en:
    term: "unit test"
    def: >
      A test that exercises one function or feature of a piece of software and
      produces [pass](#pass_test), [fail](#fail_test), or [error](#error_test).


- slug: unsupervised_learning
  ref:
    - supervised_learning
    - reinforcement_learning
  en:
    term: "unsupervised learning"
    def: >
      Algorithms that [cluster](#clustering) data without knowing in advance what the
      groups will be.


- slug: up_vote
  ref:
    - down_vote
  en:
    term: "up-vote"
    def: >
      A vote in favor of something.


- slug: update_operator
  en:
    term: "update operator"
    def: >
      See [in-place operator](#in_place_operator).


- slug: upstream_repository
  en:
    term: "upstream repository"
    def: >
      The [remote repository](#remote_repository) from which this [repository](#repository) was derived.
      Programmers typically save changes in their own repository and then submit
      a [pull request](#pull_request) to the upstream repository where changes from
      other programmers are also collected.


- slug: url
  en:
    term: "Uniform Resource Locator"
    acronym: "URL"
    def: >
      A unique address on the World-Wide Web. URLs originally identified web pages,
      but may also represent datasets or database queries, particularly if they
      include a [query string](#query_string).


- slug: utf_8
  en:
    term: "UTF-8"
    def: >
      A way to store the numeric codes representing [Unicode](#unicode) characters in memory that
      is [backward-compatible](#backward_compatible) with the older [ASCII](#ascii) standard.


- slug: variable_arguments
  ref:
    - keyword_argument
    - named_argument
  en:
    term: "variable arguments"
    def: >
      In a function, the ability to take any number of arguments. [R](#r_language) uses `...` to
      capture the "extra" arguments. [Python](#python) uses `*args` and `**kwargs` to capture
      unnamed, and named, "extra" arguments, respectively.
  fr:
    term: "arguments d'une variable"
    def: >
      La possibilité d'intégrer n'importe quel nombre d'arguments dans une fonction. [R](#r_language)
      utilise `...` afin de capturer les arguments "additionnels".


- slug: variable_data
  ref:
    - continuous_random_variable
    - discrete_random_variable
  en:
    term: "variable (data)"
    def: >
      Some attribute of a population that can be measured or observed.


- slug: variable_program
  ref:
    - constant
  en:
    term: "variable (program)"
    def: >
      A name in a program that has some data associated with it. A variable's value
      can be changed after definition.
  es:
    term: "variable (programa)"
    def: >
      Un nombre en un programa que tiene algunos datos asociados. El valor de una
      variable se puede cambiar después de su definición.
  fr:
    term: "variable (programme)"
    def: >
      Un nom associé à des données au niveau d'un programme. La valeur d'une variable
      peut être modifiée après l'avoir définie.
  ar:
    term: "المتغير"
    def: >
      المُتغير هو موقع يٌخزِن البيانات المؤقتة داخل البرنامج ويمكن تعديله وتخزينه وعرضه
      عند الحاجة.


- slug: variance
  en:
    term: "variance"
    def: >
      How widely values in a dataset differ from the [mean](#mean). It is calculated
      as the average of the squared differences between the values and the mean. The
      [standard deviation](#standard_deviation) is often used instead, since it has
      the same units as the data, while the variance is expressed in units squared.


- slug: vector
  en:
    term: "vector"
    def: >
      A sequence of values, usually of [homogeneous](#homogeneous) type. Vectors are
      the fundamental data structure in [R](#r_language); a [scalar](#scalar) is just a vector with
      exactly one [element](#element).
  es:
    term: "vector"
    def: >
      Una secuencia de valores, normalmente de tipo [homogéneo](#homogeneous). Los
      vectores son la estructura de datos fundamental en [R](#r_language); un [escalar](#scalar) es
      solo un vector con exactamente un elemento.


- slug: vectorize
  en:
    term: "vectorize"
    def: >
      To write code so that operations are performed on entire vectors, rather than
      element-by-element within loops.
  es:
    term: "vectorizar"
    def: >
      Escribir código de modo que las operaciones se ejecuten en vectores completos,
      más que elemento por elemento dentro de un bucle.


- slug: version_control_system
  ref:
    - git
  en:
    term: "version control system"
    def: >
      A system for managing changes made to software during its development.
  es:
    term: "sistema de control de versión"
    def: >
      Un sistema para manejar los cambios hechos durante el desarollo de software.
  fr:
    term: "système de gestion des versions"
    def: >
      Un système qui permet de gérer les modifications effectuées sur un programme
      durant son développement.
  pt:
    term: "sistema de controle de versão"
    def: >
      Um sistema para gerenciar as mudanças feitas em um software durante o seu desenvolvimento.


- slug: vignette
  en:
    term: "vignette"
    def: >
      A long-form guide used to provide details of a [package](#package) beyond the README.md or
      function documentation.


- slug: vim
  en:
    term: "Vim (editor)"
    def: >
      The default text editor on Unix. Vim is a very powerful text editor, with a steeper
      learning curve than [nano](#nano_editor), but that allows the user to execute shell
      commands and use [regular expressions](#regular_expression) to alter files programmatically.


- slug: virtual_environment
  en:
    term: "virtual environment"
    def: >
      In [Python](#python), the `virtualenv` [package](#package) allows you to create virtual,
      disposable, [Python](#python) software environments containing only the packages
      and versions of packages you want to use for a particular project or task, and
      to install new packages into the environment without affecting other virtual
      environments, or the system-wide default environment.


- slug: virtual_machine
  en:
    term: "virtual machine"
    def: >
      A program that pretends to be a computer. This may seem a bit redundant, but VMs
      are quick to create and start up, and changes made inside the virtual machine
      are contained within that VM so we can install new [packages](#package) or run a completely
      different operating system without affecting the underlying computer.
  es:
    term: "máquina virtual"
    def: >
      Un programa que pretende ser una computadora. Aunque puede parecer redundante,
      las máquinas virtuales (MV) se crean y se inician rápidamente, y los cambios
      hechos dentro de la máquina virtual quedan contenidos dentro de esa VM, esto
      permite que podamos instalar nuevos paquetes o ejecutar un sistema operativo
      diferente sin afectar la computadora subyacente.


- slug: visitor_pattern
  ref:
    - iterator_pattern
  en:
    term: "Visitor pattern"
    def: >
      A [design pattern](#design_pattern) in which the operation to be done is taken
      to each element of a data structure in turn. It is usually implemented by having
      a generator "visitor" that knows how to reach the structure's elements,
      which is given a function or method to call for each in turn, and that carries out
      the specific operation.


- slug: walk_tree
  en:
    term: "walk (a tree)"
    def: >
      To visit each [node](#node) in a [tree](#tree) in some order, typically
      [depth-first](#depth_first) or [breadth-first](#breadth_first).


- slug: while_loop
  ref:
    - for_loop
  en:
    term: "while loop"
    def: >
      A statement in a program that repeats one or more other statements (the [loop
      body](#loop_body)) as long as a condition is [true](#true).


- slug: whitespace
  en:
    term: "whitespace"
    def: >
      The space, newline, carriage return, and horizontal and vertical tab characters
      that take up space but do not create a visible mark. The name comes from their
      appearance on a printed page in the era of typewriters.
  pt:
    term: "espaço em branco"
    def: >
      O espaço, nova linha, quebra de linha, ou tabulação horizontal ou vertical que ocupe
      um espaço mas não crie uma marca visível. O nome vem de sua aparência em um papel impresso
      da era das das máquinas de escrever.


- slug: wildcard
  de:
    term: "Wildcard"
    def: >
      Ein Zeichenausdruck, der mit Text übereinstimmen kann, wie z.B. das `*` in `*.csv` (das
      passt auf jeden Dateinamen, dessen Name mit `.csv`) endet.
  en:
    term: "wildcard"
    def: >
      A character expression that can match text, such as the `*` in `*.csv` (which
      matches any filename whose name ends with `.csv`).
  pt:
    ter: "curinga"
    def: >
      Um curinga, ou caracter curinga, é um caracter que corresponde a qualquer texto, 
      como o `*` em `*.csv` (que corresponde a qualquer arquivo cujo nome termina em `*.csv`).


- slug: xml
  de:
    term: "XML"
    def: >
      Eine Reihe von Regeln zur Definition von [HTML](#html)-ähnlichen Tags und deren
      Verwendung zur Formatierung Dokumente (typischerweise Daten). XML war in den
      frühen 2000er Jahren populär, aber seine Komplexität veranlasste
      viele Programmierer, stattdessen [JSON](#json) zu übernehmen.
  en:
    term: "XML"
    def: >
      A set of rules for defining [HTML](#html)-like tags and using them to format
      documents (typically data). XML was popular in the early 2000s, but its
      complexity led many programmers to adopt [JSON](#json), instead.
  es:
    term: "XML"
    def: >
      Un conjunto de reglas para definir etiquetas similares a [HTML](#html) y usarlas
      para darle formato a documentos (normalmente datos). XML alcanzó popularidad a
      principios de la década de 2000, pero su complejidad llevó a muchos
      programadores a adoptar [JSON](#json) en su lugar.
  fr:
    term: "XML"
    def: >
      Un format de représentation de données qui définit des balises similaires à
      celles utilisées en [HTML](#html). XML était populaire au début des années 2000
      mais sa complexité a conduit de nombreux dévelopeurs à utiliser [JSON](#json) à
      la place.
  pt:
    term: "XML"
    def: >
      Um conjunto de regras para se definir etiquetas similares a [HTML](#html) e usá-las
      para formatar documentos (normalmente, dados). XML foi popular no início dos anos 2000, 
      mas sua complexidade fez com que muitas pessoas programadoras adotassem [JSON](#json) em
      seu lugar.


- slug: yaml
  de:
    term: "YAML"
    def: >
      Abkürzung für "YAML Ain't Markup Language", eine Methode zur Darstellung
      verschachtelter Daten mit Einrückung statt der Klammern und Kommas
      von [JSON](#json). YAML ist oft in Konfigurationsdateien und zur Definition
      von Parametern für verschiedene Geschmacksrichtungen verwendet
      von [Markdown](#markdown)-Dokumenten.
  en:
    term: "YAML"
    def: >
      Short for "YAML Ain't Markup Language", a way to represent nested data using
      indentation rather than the parentheses and commas of [JSON](#json). YAML is
      often used in configuration files and to define [parameters](#parameter) for various flavors
      of [Markdown](#markdown) documents.
  fr:
    term: "YAML"
    def: >
      Acronyme récursif de "YAML Ain't Markup Language" ("YAML n'est pas un langage de
      balisage"), YAML est un format de représentation de données hiérarchiques qui
      utilise des indentations au lieu de signes typographiques, comme les parenthèses
      et virgules en [JSON](#json). YAML est souvent utilisé dans les fichiers de
      configuration et pour définir les paramètres de documents [Markdown](#markdown).
  pt:
    term: "YAML"
    def: >
      Acrônimo recursivo de "YAML Ain't Markup Language" (YAML não é uma linguagem de marcação), 
      é uma maneira de representar dados aninhados usando recuos (também chamados de indentações)
      no lugar de parênteses e vírgulas usados em [JSON](#json). YAML é frequentemente usado em 
      arquivos de configuração e na definição de [parâmetros](#parameter) para vários estilos
      de documentos em [Markdown](#markdown).