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.

- slug: abandonware
  en:
    term: "abandonware"
    def: >
      Software that is no longer being maintained.

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

- slug: absolute_path
  ref:
    - relative_path
  en:
    term: "absolute path"
    def: >
      A path that points to the same location in the filesystem regardless of where
      it's evaluated. An absolute path is the equivalent of latitude and longitude
      in geography.
  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.

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

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

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

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

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

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

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

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

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

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

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

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

- slug: arithmetic_mean
  en:
    term: "arithmetic mean"
    def: >
      See [mean](#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'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: 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 hitting 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: 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.

- 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: 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_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: call_stack
  en:
    term: "call stack"
    def: >
      A data structure that stores information about the active subroutines
      executed.

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

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

- slug: cc_0
  en:
    term: "CC-0"
    def: >
      A [Creative Commons license](#cc_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 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 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: class
  en:
    term: "class"
    def: >
      FIXME

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

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

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

- 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: constant
  en:
    term: "constant"
    def: >
      FIXME

- slug: constructor
  en:
    term: "constructor"
    def: >
      A function that creates an object of a particular 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 won't 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.

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

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

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

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

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

- slug: data_scientist
  en:
    term: "data scientist"
    def: >
      Someone who uses programming skills to solve statistical problems.

- 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: 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 aren't ever supposed to occur.

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

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

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

- 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 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: 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: emacs
  en:
    term: "Emacs (editor)"
    def: >
      FIXME

- 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 can't be found.

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

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

- 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 doesn't include the [stem](#filename_stem).
      For example, the stem of `glossary.yml` is `glossary`.

- slug: filesystem
  en:
    term: "filesystem"
    def: >
      Controls how files are stored and retrieved on disk by an operating system.
      Also used to refer to the disk that is used to store the files or the type of the filesystem.

- slug: filter
  en:
    term: "filter"
    def: >
      To choose a set of [records](#record) (i.e., rows of a table) based
      on the values they contain.
  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: 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: 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.

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

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

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

- 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: gpl
  en:
    term: "GNU Public License"
    acronym: "GPL"
    def: >
      A 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: 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.

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

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

- 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 doesn't 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: 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: >
      FIXME

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

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

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

- 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: library
  en:
    term: "library"
    def: >
      FIXME

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

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

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

- 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: 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 didn't exist in the first place (e.g., the middle name of
      someone who doesn't have one).

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

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

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

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

- 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
  en:
    term: "namespace"
    def: >
      FIXME

- 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 aren't
      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: 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 doesn't use the relational model.  The awkward name comes
      from the fact that such databases don't 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.

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

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

- 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's all very confusing.

- 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: 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 doesn't 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: >
      FIXME

- 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 it is `>>>`.

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

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

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

- 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 haven't 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).

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

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

- 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 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: 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 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 es un dialecto de S.

- slug: scalar
  en:
    term: "scalar"
    def: >
      A single value of a particular type, such as 1 or "a".  Scalars don't 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).

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

- 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: 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: singleton
  en:
    term: "singleton"
    def: >
      A set with only one element, or a [class](#class) with only one [instance](#instance).

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

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

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

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

- 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: 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: type_coercion
  en:
    term: "type coercion"
    def: >
      FIXME

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

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

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

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

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

- slug: virtual_environment
  en:
    term: "virtual environment"
    def: >
      In Python, the `virtualenv` package allows you to create
      virtual, disposable, 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: whitespace
  en:
    term: "whitespace"
    def: >
      The space, newline, carriage return, and horizontal and vertical tab
      characters that take up space but don't 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-like tags and using them to format documents
      (typically data). XML achieved license plate popularity 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 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.

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