glossary.yml

- slug: 68_95_997_rule
  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.
      
  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.
      
- slug: abandonware
  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.
  fr:
    term: "abandonware"
    def: >
      Un logiciel qui n'est plus maintenu.

- slug: absolute_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).
      
- 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.

- slug: absolute_row_number
  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.

- slug: abstract_method
  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.

- 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
  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.

- 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.

- 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.

- 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.
  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
      
- slug: anti_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: >
      A value passed into a function. Some authors use the term as a synonym for
      [parameter](#parameter) and some do not; it is all very confusing.
  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: >
      قيمة يتم تمريرها إلى دالة أو وسيطة ، البعض يُطلِق عليها مصطلح (مُعطى) ، والبعض
      الآخر يُطلِق عليها مصطلح (وسيطة) ، لذلك قد تُسبب الحيرة للبعض

- slug: arithmetic_mean
  en:
    term: "arithmetic mean"
    def: >
      See [mean](#mean).
  pt:
    term: "média aritmética"
    def: >
      Veja [média](#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).

- slug: assertion
  en:
    term: "assertion"
    def: >
      A [Boolean](#boolean) expression that must be 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's `stopifnot`). They are
      often used in testing, but are also put in [production code](#production_code)
      to check that it is behaving correctly.

- slug: associative_array
  en:
    term: "associative array"
    def: >
      See [dictionary](#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.

- 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.

- 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 that the user can select from.
  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.

- 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).

- 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).

- 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é.

- slug: base_r
  ref:
    - tidyverse
  en:
    term: "base R"
    def: >
      The basic functions making up the R 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.

- 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 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 consistency different from the
      parameter it is supposed to estimate.

- 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).

- slug: binary_expression
  ref:
    - nullary_expression
    - ternary_expression
    - unary_expression
  en:
    term: "binary expression"
    def: >
      An expression with two arguments or parameters, such as `1 + 2`.

- 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).

- 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.

- 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 a value of [false](#false). Named for George Boole, a 19th
      Century mathemetician. 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 or false)
        تُتستخدم التعبيرات المنطقية مع العبارات الشرطية في محركات البحث والخوارزميات
        وتُسمى التعبيرات المنطقية أيضا تعبيرات المقارنة والتعبيرات الشرطية والتعبيرات العلائقية

- 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 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
      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, 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 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.

- 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 result 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 [ascynrhonously](#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 (`-`), 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
      prefers "handling a condition" to "catching an exception".
  ar:
    term: "إستثناء"
    def: >
      الإستثناء هو الشرط الخاص الذي يُعالج به الشذوذ أو الشيء الغير متوقع الذي حدث
      أثناء تنفيذ البرنامج

- slug: causation
  en:
    term: "causation"
    def: >

- 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.

- 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.

- 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.

- slug: centroid
  en:
    term: "centroid"
    def: >
      The center or anchor of a group created by a [clustering](#clustering) algorithm.

- 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).

- slug: chi_square_test
  en:
    term: "chi-square test"
    def: >
      A statistical method for estimating whether two variables in a cross tabulation
      are correlated. A chi-square distribution varies from a [normal
      distribution](#normal_distribution) based on the [degrees of
      freedom](#degrees_of_freedom) used to calculate it.

- slug: child_class
  en:
    term: "child class"
    def: >
      In [object-oriented programming](#oop), a class derived from another class
      (called the [parent class](#child_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).

- 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.

- slug: code_coverage
  en:
    term: "code coverage (in testing)"
    def: >
      How much of a 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
      [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
      [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 languages 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: >
      هو برنامج يقوم بترجمة النصوص المصدرية إلى أوامر ومعلومات يفهمها الحاسب لذلك
      يُمكن للكمبيوتر فهم البرنامج وتشغيله دون استخدام برنامج البرمجة المستخدم لإنشائه

- slug: computational_linguistics
  ref:
    - nlp
  en:
    term: "computational linguistics"
    def: >
      The study or application of computational methods for parsing 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 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.

- slug: console
  en:
    term: "console"
    def: >

- slug: constant
  en:
    term: "constant"
    def: >

- 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.

- 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 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: >
      How well two variables agree with each other. Correlation is usually measured by
      calculating a [correlation coefficient](#correlation_coefficient), and does not
      imply 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.

- 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
      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.

- 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 packages.

- slug: cross_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, 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 is one row and fields are
      separated by commas. There are many minor variations, particularly around
      quoting of strings.

- slug: current_working_directory
  en:
    term: "current working directory"
    def: >
      The folder or directory location that the program is operating in. 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.

- 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 are questions and whose branches eventually lead to a
      decision or 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 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
      report or correct them, such as inserting [assertions](#assertion) to report
      situations that are not ever supposed to occur.

- slug: degrees_of_freedom
  en:
    term: "degrees of freedom"
    def: >

- slug: delegate_pattern
  en:
    term: "Delegate pattern"
    def: >
      A [design pattern](#design_pattern) in which an 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
  en:
    term: "directory"
    def: >

- slug: discrete_random_variable
  ref:
    - continuous_random_variable
  en:
    term: "discrete random variable"
    def: >
      A variable whose value can take on only one of a fixed set of values, such as
      true or 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, 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 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: 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 used to represent some other character that would
      otherwise have a special meaning. 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) or
      retrying the operation that failed.

- slug: expected_result
  ref:
    - actual_result
  en:
    term: "expected result (of test)"
    def: >
      The value that a piece of software is suposed to produced 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 order to manage [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 [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 within a Git repository containing commits dedicated to a specific
      feature, e.g., a 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 usually no guarantee that this is correct.

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

- slug: filesystem
  en:
    term: "filesystem"
    def: >
      The part of the operating system that manages how files are stored and
      retrieved. Also used to refer to all of those files and directories 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 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 statement 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 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
      [repository](#repository), usually written as a 20-character
      [hexadecimal](#hexadecimal) character string.

- slug: full_join
  ref:
    - left_join
    - right_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).

- slug: fully_qualified_name
  en:
    term: "fully-qualified name"
    def: >
      An unambiguous name of the form `package::thing`.

- 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.

- 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. Generator functions are typically used 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.

- slug: geometric_mean
  en:
    term: "geometric mean"
    def: >

- slug: git
  en:
    term: "Git"
    def: >
      A version control tool 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.
  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 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) a Git [remote repository](#remote_repository)
      onto the 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 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 [repository](#repository) on a server, or the copy
      that is made.

- slug: git_merge
  en:
    term: "Git merge"
    def: >
      Merging branches in Git incorporates development histories of two branches in
      one. If changes are made to similar parts of the branches on both branches a
      commit 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 R, 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 R, 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, 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 that is free software. GNU is a recursive acronym
      for "GNU is Not Unix!". The GNU operating system consists of GNU packages 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 that direction, 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 some 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
      prefers "handling a condition" to "catching an exception".

- slug: harmonic_mean
  en:
    term: "harmonic mean"
    def: >

- slug: hash_function
  en:
    term: "hash function"
    def: >
      A function that turns arbitrary data into a bit array 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 for each value and stores
      the value in that location. Hash tables enable fast lookup for arbitrary data at
      the cost of extra memory.

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

- slug: heterogeneous
  ref:
    - homogeneous
  en:
    term: "heterogeneous"
    def: >
      Having mixed type. For example, an 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 exactly
      fit one byte.

- 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 an [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
  en:
    term: "homogeneous"
    def: >
      Having a single 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).

- 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 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 belief that one's successes are a result of accident or fraud 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
  en:
    term: "independent variable"
    def: >

- slug: inner_join
  en:
    term: "inner join"
    def: >
      A [join](#join) that returns combinations of rows from two tables A and B whose
      [keys](#key) match.

- slug: instance
  en:
    term: "instance"
    def: >

- 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: interpeter
  en:
    term: "interpeter"
    def: >
      A program that runs other programs interactively.

- 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).

- slug: invariant
  en:
    term: "invariant"
    def: >
      Something that is guaranteed to be true at some point in a program. Invariants
      are often expressed using [assertions](#assertion).

- 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` and `feature request`.

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

- slug: iterator_pattern
  ref:
    - visitor_pattern
  en:
    term: "Iterator pattern"
    def: >
      A [design pattern](#design_pattern) in which a temporary 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 and name/value 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 nearby neighbors.

- 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: >
      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 record and in [joins](#join).

- slug: keyword_arguments
  ref:
    - named_argument
    - variable_arguments
  en:
    term: "keyword arguments"
    def: >
      Extra 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: >
      The FORTRAN of scientific publishing.

- slug: lazy_evaluation
  en:
    term: "lazy evaluation"
    def: >
      Delaying evaluation of an expression until the value is actually needed (or at
      least until after the point where it is first encountered).

- slug: left_join
  ref:
    - full_join
    - right_join
  en:
    term: "left join"
    def: >
      A [join](#join) that combines data from two tables A and B. Where keys 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).

- 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, 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 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 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 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:
    - r_markdown
  en:
    term: "literate programming"
    def: >
      A programming paradigm that mixes prose and code.

- slug: local_installation
  ref:
    - global_installation
  en:
    term: "local installation"
    def: >
      Placing a 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 that managing 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 or other structure with a vector of Booleans, keeping only the
      values that correspond to 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
  en:
    term: "long identifier (of commit)"
    def: >
      See [full identifier](#full_identifier_git).

- slug: long_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 with a simple syntax intended as a replacement for HTML.
      Markdown is often used for README files, and is the basis for [R markdown](r_markdown).

- slug: markov_chain
  ref:
    - bayesian_network
    - monte_carlo
  en:
    term: "Markov Chain"
    def: >
      Any [model](#model) describing a series of unfortunate 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.

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

- slug: masking
  en:
    term: "masking"
    def: >

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

- slug: maximum_likelihood_estimation
  en:
    term: "maximum likelihood estimation"
    def: >
      To choose the parameters for a [probability
      distribution](#probability_distribution) in order to maximize the likelihood of
      obtaining observed data.

- 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.
  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, 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.

- 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.

- 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 that occurs most frequently in a dataset.

- 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, 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 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_arguments
    - variable_arguments
  en:
    term: "named argument"
    def: >
      A function parameter that is given a value by explicitly naming it in a function call.

- slug: namespace
  ref:
    - name_collision
  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.

- 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 of a 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, 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
  ref:
    - relational_database
  en:
    term: "NoSQL database"
    def: >
      Any database that does not use the relational model. The awkward name comes from
      the fact that such databases do not use [SQL](#sql) as a query language.

- 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 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).

- 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: >

- 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
      that only interact with each other through well-defined interfaces.

- 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.

- 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 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 (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 bits and bobs of 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 whose value is passed into a function when the function is called.
      Some writers distinguish parameters (the variables) from [arguments](#argument)
      (the values passed in), but others use the terms in the opposite sense.
      It is all very confusing.

- slug: parent_class
  en:
    term: "parent class"
    def: >
      In [object-oriented programming](#oop), the class from which another class
      (called the [child class](#child_class)) is derived.

- slug: parent_directory
  ref:
    - subdirectory
  en:
    term: "parent directory"
    def: >
      The 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 containin 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 that specifies a location in a [filesystem](#filesystem). In Unix, the
      directories 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 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
  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
  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](#named_argument) that is
      explicitly matched by name.

- slug: posterior_distribution
  en:
    term: "posterior distribution"
    def: >

- 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 [object-oriented programming](#oop).

- slug: process
  en:
    term: "process"
    def: >
      An [operating system](#operating_system)'s representation of a running program.
      A process typically has some memory, the identify 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 a [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 `>>>`.

- 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 resemble the true randomness of the
      universe well enough to fool merely mortal 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
      specifies which 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
  ref:
    - fork
  en:
    term: "pull request"
    def: >
      The request to merge a new feature or correction created on a user's fork of a
      [Git](#git) repository into the [upstream repository](#upstream_repository). The
      developer will be notified of the change, review it, make or suggest changes,
      and potentially 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
      specifies an 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. It
      is a member of the [R Consortium](#r_consortium).

- slug: r_hub
  en:
    term: "R Hub"
    def: >
      A free platform available to check a `R` 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.

- slug: r_markdown
  en:
    term: "R Markdown"
    def: >
      A dialect of [Markdown](#markdown) that allows authors to mix prose and code
      (usually written in R) in a single document. Cf. [literate programming](#literate_programming).
  es:
    term: "R Markdown"
    def: >
      Un dialecto de [Markdown](#markdown) que permite a sus autores mezclar prosa y
      código (usualmente escrito en R) en un mismo documento. Cf. [literate programming](#literate_programming).

- 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 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: >
      A [classification](#classification) algorithm An algorithm used for regression
      or classification that uses [decision trees](#decision_tree). 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: 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 in order to generate a sequence of the
      same length as a longer one.
  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 as powerful as they are cryptic.
  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 tan poderosas como crípticas.

- 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 meeting, but instead is given feedback on whether or not it is making progress.

- slug: relational_database
  ref:
    - sql
    - table
  en:
    term: "relational database"
    def: >
      A database that organizes information into tables, each of which has a fixed set
      of named fields (shown as columns) and a variable number of records (shown as rows).
  es:
    term: "base de datos relacional"
    def: >
      Una base de datos que organiza la información en tablas, cada una de las cuales
      tiene un set fijo de campos con nombre (que se muestran como columnas) y un
      número variable de registros (que se muestran como filas).

- slug: relative_error
  en:
    term: "relative error"
    def: >
      The absolute value of the difference between the actual and correct value
      divided by the desired 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 desejado. 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).


- 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".

- 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 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.

- slug: reprex
  en:
    term: "reprex"
    def: >
      A reproducible example. When asking questions about coding problems online or
      filing issues on 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 escribing and documenting research results in such a way that
      another researcher or person can re-run the analysis code on the exact 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 format used primarily in [Python](#python) documentation.

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

- slug: right_join
  ref:
    - full_join
    - left_join
  en:
    term: "right join"
    def: >
      A [join](#join) that combines data from two tables A and B. Where keys 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 A are filled with
      [null](#null), [NA](#na), or some other [missing value](#missing_value).

- slug: root_directory
  en:
    term: "root directory"
    def: >
      The directory that contains everything else, 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 in a 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 in R.

- slug: s4
  en:
    term: "S4"
    def: >
      A framework for object-oriented programming in R.

- 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 do not really
      exist in R; values that appear to be scalars are actually vectors 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; 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
  en:
    term: "scope"
    def: >
      The portion of a program within which a definition can be seen and used. Cf.
      [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 usable 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 given its name.

- 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 from a table by name or location.

- slug: 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 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 `#!python` in the first line of a runnable
      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, such as Bash (for Unix) 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
  en:
    term: "Shiny"
    def: >

- slug: short_circuit_test
  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, 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 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 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 prefers "signalling a condition" to
      "raising an exception".

- slug: single_square_brackets
  ref:
    - double_square_brackets
  en:
    term: "single square brackets"
    def: >
      An index enclosed in `[...]`, used to select a structure from another structure.

- 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 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 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
  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 was originally 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 era originalmente un acrónimo del
      inglés Structured Query Language (Lenguage Estructurado de Consulta).

- 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.

- 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).

- 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 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 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 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,
      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.

- 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 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 two 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 in a [relational database](#relational_database) or
      observations in a [data frame](#data_frame). Tables are usually displayed as
      rows (each of which represents one [record](#record) or
      [observation](#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 referred 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 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 in different ways.

- 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
  en:
    term: "test data"
    def: >

- 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'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 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 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 packages 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 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 packages for operating on tabular data in consistent ways.
  fr:
    term: "Tidyverse"
    def: >
      Une collection de packages R permettant le traitement des données tabulaire
      d'une manière cohérente.
  es:
    term: "Tidyverse"
    def: >
      Una colección de paquetes de R para operar de maneras consistentes con datos tabulares.
  pt:
    term: "Tidyverse"
    def: >
      Uma coleção de pacotes de R 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
  en:
    term: "training data"
    def: >

- 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 [binary](#binary) state of something.

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

- slug: tuple
  en:
    term: "tuple"
    def: >
      A value that has multiple parts, such as the three color components of a
      red-green-blue color specification.

- 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) that this repository was derived
      from. 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 characters in memory that
      is [backward-compatible](#backward_compatible) with the older [ASCII](#ascii) standard.

- slug: variable_arguments
  ref:
    - keyword_arguments
    - named_argument
  en:
    term: "variable arguments"
    def: >
      In a function, the ability to take any number of arguments. R uses `...` to
      capture the "extra" arguments.
  fr:
    term: "arguments d'une variable"
    def: >
      La possibilité d'intégrer n'importe quel nombre d'arguments dans une fonction. R
      utilise `...` afin de capturer les arguments "additionnels".

- slug: variable_data
  en:
    term: "variable (data)"
    def: >

- 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; a [scalar](#scalar) is just a vector with
      exactly one element.
  es:
    term: "vector"
    def: >
      Una secuencia de valores, normalmente de tipo [homogéneo](#homogéneo). Los
      vectores son la estructura de datos fundamental en R; un [escalar](#escalar) 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 beyond the README.md or
      function documentation.

- slug: vim
  en:
    term: "Vim (editor)"
    def: >
      The default text editor on Unix. "How do I exit the Vim editor?" is one of the
      most popular questions on [Stack Overflow](#stack_overflow).

- slug: virtual_environment
  en:
    term: "virtual environment"
    def: >
      In [Python](#python), the `virtualenv` 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 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, and
      which is given a function or method to call for each in turn 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.

- 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.

- slug: wildcard
  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`).

- slug: xml
  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.

- slug: yaml
  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 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).