glossary.yml

- slug: absolute_import
  en:
    term: "absolute import"
    def: >
      In Python, an import that specifies the full location of the file to be imported.

- slug: ally
  en:
    term: "ally"
    def: >
      Someone who actively promotes and supports inclusivity.

- slug: authentic_task
  en:
    term: "authentic task"
    def: >
      A task which contains important elements of things that learners would do
      in real (non-classroom situations).

- slug: checklist
  en:
    term: "checklist"
    def: >
      A list of things to be checked or completed when doing a task.

- slug: command_line_flag
  en:
    term: "command line flag"
    def: >
      See [command-line argument](#command_line_argument)

- slug: command_line_option
  en:
    term: "command line option"
    def: >
      See [command-line argument](#command_line_argument)

- slug: command_line_switch
  en:
    term: "command line switch"
    def: >
      See [command-line argument](#command_line_argument)

- slug: commons
  en:
    term: "commons"
    def: >
      Something managed jointly by a community according to rules they
      themselves have evolved and adopted.

- slug: competent_practitioner
  ref:
    - novice
    - expert
  en:
    term: "competent practitioner"
    def: >
      Someone who can do normal tasks with normal effort under normal
      circumstances.

- slug: confirmation_bias
  en:
    term: "confirmation bias"
    def: >
      The tendency to analyze information or make decisions in ways that
      reinforce existing beliefs.

- slug: entry_point
  en:
    term: "entry point"
    def: >
      Where a program or function starts executing, or the first commands in a
      file that run.

- slug: expert
  ref:
    - competent_practitioner
    - novice
  en:
    term: "expert"
    def: >
      Someone who can diagnose and handle unusual situations, knows when the
      usual rules do not apply, and tends to recognize solutions rather than
      reasoning to them.

- slug: explicit_relative_import
  en:
    term: "explicit relative import"
    def: >
      In Python, an import that specifies a path relative to the current
      location.

- slug: export_variable
  en:
    term: "export a variable"
    def: >
      To make a variable defined inside a [shell script](#shell_script)
      available outside that script.

- slug: external_error
  en:
    term: "external error"
    def: >
      An error caused by something outside a program, such as trying to
      open a file that doesn't exist.

- slug: false_beginner
  en:
    term: "false beginner"
    def: >
      Someone whose previous knowledge allows them to learn (or re-learn)
      something more quickly.  False beginners start at the same point as true
      beginners (i.e., a pre-test will show the same proficiency) but can move
      much more quickly.

- slug: flag_variable
  en:
    term: "flag variable"
    def: >
      A variable that changes state exactly once to show that something has
      happened that needs to be dealt with later.

- slug: forge
  en:
    term: "forge"
    def: >
      A website that integrates [version control](#version_control),
      [issue tracking](#issue_tracking_system), and other tools for software
      development.

- slug: git_stage
  en:
    term: "Git stage"
    def: >
      To put changes in a "holding area" from which they can be [committed](#commit).

- slug: governance
  en:
    term: "governance"
    def: >
      The process by which an organization manages itself, or the rules used to
      do so.

- slug: impact_effort_matrix
  en:
    term: "impact/effort matrix"
    def: >
      A tool for prioritizing work in which every task is placed according
      to its importance and the effort required to complete it.

- slug: implicit_relative_import
  en:
    term: "implicit relative import"
    def: >
      In Python, an import that does not specify a path (and hence may be
      ambiguous).

- slug: inspectability
  en:
    term: "inspectability"
    def: >
      The degree to which a third party can figure out what was done and why.
      Work can be [reproducible](#reproducibility) without being inspectable.

- slug: internal_error
  en:
    term: "internal error"
    def: >
      An error caused by a fault in a program, such as trying to access elements
      beyond the end of an array.

- slug: interruption_bingo
  en:
    term: "interruption bingo"
    def: >
      A technique for managing interruptions in meetings. Everyone's name is
      placed on each row and each column of a grid; each time person A
      interrupts person B, a mark is added to the appropriate grid cell.

- slug: mental_model
  en:
    term: "mental model"
    def: >
      A simplified representation of the key elements and relationships of some
      problem domain that is good enough to support problem solving.

- slug: ngo
  en:
    term: "non-governmental organization"
    acronym: "NGO"
    def: >
      An organization that is not affiliated with the government, but does the
      sorts of public service work that governments often do.

- slug: novice
  ref:
    - competent_practitioner
    - expert
  en:
    term: "novice"
    def: >
      Someone who has not yet built a usable mental model of a domain.

- slug: oppression
  en:
    term: "oppression"
    def: >
      A form of injustice in which one social group is marginalized or deprived
      while another is [privileged](#privilege).

- slug: optional_argument
  en:
    term: "optional argument"
    def: >
      An argument to a function or a command that may be omitted.

- slug: overlay_configuration
  en:
    term: "overlay configuration"
    def: >
      A technique for configuring programs in which several layers of
      configuration are used, each overriding settings in the ones
      before.

- slug: path_coverage
  en:
    term: "path coverage"
    def: >
      The fraction of possible execution paths in a piece of software
      that have been executed by tests. Software can have complete
      [code coverage](#code_coverage) without having complete path
      coverage.

- slug: postcondition
  ref:
    - invariant
    - precondition
  en:
    term: "postcondition"
    def: >
      Something that is guaranteed to be true after a piece of
      software finishes executing.

- slug: power_law
  en:
    term: "power law"
    def: >
      A mathematical relationship in which one quantity changes in proportion to
      a constant raised to the power of another quantity.

- slug: precondition
  ref:
    - invariant
    - postcondition
  en:
    term: "precondition"
    def: >
      Something that must be true before a piece of software runs
      in order for that software to run correctly.

- slug: privilege
  en:
    term: "privilege"
    def: >
      An unearned advantage, typically as a result of belonging to a dominant
      social class or group.

- slug: remote_login_server
  ref:
    - ssh_daemon
  en:
    term: "remote login server"
    def: >
      A process that handles requests to log in to a computer from other
      computers.

- slug: ssh_daemon
  en:
    term: "ssh daemon"
    def: >
      A [remote login server](#remote_login_server) that handles [SSH](#ssh)
      connections.

- slug: ssh_protocol
  en:
    term: "SSH protocol"
    def: >
      A formal standard for exchanging encrypted messages between computers
      and for managing [remote logins](#remote_login_server).

- slug: stop_word
  en:
    term: "stop word"
    def: >
      Common words that are filtered out of text before processing it, such
      as "the" and "an".

- slug: sustainable_software
  en:
    term: "sustainable software"
    def: >
      Software that its users can afford to keep up to date. Sustainability
      depends on the quality of the software, the skills of the potential
      maintainers, and how much the community is willing to invest.

- slug: test_framework
  en:
    term: "test framework"
    def: >
      See [test runner](#test_runner).

- slug: three_stickies
  en:
    term: "three stickies"
    def: >
      A technique for ensuring that everyone in a meeting gets a chance to
      speak. Everyone is given three sticky notes (or other tokens).  Each time
      someone speaks, it costs them a sticky; when they are out of stickies they
      cannot speak until everyone has used at least one, at which point everyone
      gets all of their stickies back.

- slug: validation
  ref:
    - verification
  en:
    term: "validation"
    def: >
      Checking that a piece of software does what its users want, i.e., "are we
      building the right thing"?

- slug: verification
  ref:
    - validation
  en:
    term: "verification"
    def: >
      Checking that a piece of software works as intended, i.e., "did we build
      the thing right?"

- slug: working_memory
  en:
    term: "working memory"
    def: >
      The part of memory that briefly stores information that can be directly
      accessed by consciousness.