# Glossary

Definitions for the vocabulary used across Eugo's platform, docs, and courses.

Source: https://university.eugo.io/glossary

---

- **[High-performance computing (HPC)](https://university.eugo.io/glossary/high-performance-computing)** — Running work across many machines at once so it finishes far sooner. The technique behind weather models, genomics, and large-scale simulation.
- **[HPC as a service (HPCaaS)](https://university.eugo.io/glossary/hpc-as-a-service)** — High-performance computing consumed on demand rather than owned: request compute for one run, stop paying when it ends. No hardware, no scheduler to run.
- **[Distributed computing](https://university.eugo.io/glossary/distributed-computing)** — Splitting one job across several machines that work on it simultaneously. The core technique of HPC, and what the distribute decorator gives you in Python.
- **[Job scheduler](https://university.eugo.io/glossary/job-scheduler)** — The queueing system on a traditional HPC cluster that decides when a submitted job runs. Eugo has no queue: you launch a cluster and dispatch work to it.
- **[Parallel computing](https://university.eugo.io/glossary/parallel-computing)** — Many calculations at once rather than one after another. Two scales on Eugo: across machines in a cluster, and inside a CPU core through vectorization.
- **[Actor](https://university.eugo.io/glossary/actor)** — A distributed object that holds state across many calls. Created by applying the distribute decorator to a class rather than a function.
- **[ARM Neoverse](https://university.eugo.io/glossary/arm-neoverse)** — The ARM server processor architecture Eugo’s compute nodes are built on, chosen for performance per watt on numeric workloads.
- **[Activity log](https://university.eugo.io/glossary/activity-log)** — The record of actions taken inside an organization: who created a workspace, changed a role, or launched a cluster.
- **[Batching](https://university.eugo.io/glossary/batching)** — Grouping several small units of work into one task so that scheduling overhead does not dominate the time spent doing useful work.
- **[Billing period](https://university.eugo.io/glossary/billing-period)** — The interval over which an organization’s compute usage is accumulated and charged.
- **[Cluster](https://university.eugo.io/glossary/cluster)** — A set of machines, one head node and one or more compute nodes, launched together to run distributed work.
- **[Columnar format](https://university.eugo.io/glossary/columnar-format)** — A file format that stores values grouped by column rather than by row, so a reader can fetch only the fields it needs.
- **[Compute node](https://university.eugo.io/glossary/compute-node)** — A machine in a cluster that executes tasks. Compute nodes do the work; the head node coordinates it.
- **[Compute-bound](https://university.eugo.io/glossary/compute-bound)** — A workload whose runtime is limited by how fast calculations can be performed. Adding workers to a compute-bound job generally makes it finish sooner.
- **[distribute decorator](https://university.eugo.io/glossary/distribute-decorator)** — The eugo.hpc decorator that turns a function into a distributed task, or a class into an actor. A decorated call returns a future instead of a value.
- **[eugo.hpc](https://university.eugo.io/glossary/eugo-hpc)** — The Python module holding Eugo’s distributed-compute API. The top-level eugo namespace is deliberately empty; everything lives under eugo.hpc.
- **[EugoHPC Manager](https://university.eugo.io/glossary/eugohpc-manager)** — The panel inside EugoIDE used to launch, monitor, and shut down clusters.
- **[EugoIDE](https://university.eugo.io/glossary/eugoide)** — The browser-based notebook environment where you write and run Python on Eugo. Built on JupyterLab, connected to compute in your workspace.
- **[Fan-out](https://university.eugo.io/glossary/fan-out)** — Launching many independent tasks at once, then waiting on all of their results together.
- **[Future](https://university.eugo.io/glossary/future)** — A handle to a result that does not exist yet. Calling a distributed function returns a future immediately, while the work happens elsewhere.
- **[get()](https://university.eugo.io/glossary/get)** — The eugo.hpc call that resolves one or more futures into actual values, blocking until they are ready.
- **[Blocking](https://university.eugo.io/glossary/blocking)** — Waiting for a result before continuing. In distributed code, blocking too early is the most common cause of a run that gains no speedup.
- **[GPU offloading](https://university.eugo.io/glossary/gpu-offloading)** — Moving computationally intensive operations onto a GPU. Eugo applies this automatically when a GPU is available and the data transfer is worth its cost.
- **[GPU](https://university.eugo.io/glossary/gpu)** — A graphics processing unit. Hardware with many parallel cores, well suited to large array and matrix operations.
- **[Head node](https://university.eugo.io/glossary/head-node)** — The machine in a cluster that coordinates work: it schedules tasks onto compute nodes and tracks their results.
- **[Interactive session](https://university.eugo.io/glossary/interactive-session)** — A running EugoIDE instance attached to your workspace. It is where you write code; a cluster is what runs it at scale.
- **[I/O-bound](https://university.eugo.io/glossary/io-bound)** — A workload whose runtime is limited by reading and writing data rather than by calculation. Adding workers to an I/O-bound job adds waiting, not throughput.
- **[Long tail](https://university.eugo.io/glossary/long-tail)** — The situation where most tasks finish quickly but one or two run much longer, so the whole run waits on them while workers sit idle.
- **[Member](https://university.eugo.io/glossary/member)** — A user who belongs to an organization. What a member can do is governed by their assigned role.
- **[Object storage](https://university.eugo.io/glossary/object-storage)** — Storage reachable by every node in a cluster. Inputs must live here, or in workspace storage, rather than on one machine’s local disk.
- **[options()](https://university.eugo.io/glossary/options)** — The method that sets per-call resource requirements on a distributed function, such as num_cpus or num_gpus.
- **[Organization](https://university.eugo.io/glossary/organization)** — The top-level account that owns one or more workspaces and is the unit of billing. Members belong to an organization and hold roles within it.
- **[Automatic optimization](https://university.eugo.io/glossary/automatic-optimization)** — Transformations Eugo applies to your code as it runs: vectorization, GPU offloading, and low-level tuning, with no annotation from you.
- **[Partition](https://university.eugo.io/glossary/partition)** — One independently processable chunk of a dataset. Partition size is the main lever on how well a workload parallelizes.
- **[Persistent storage](https://university.eugo.io/glossary/persistent-storage)** — Workspace storage that survives between interactive sessions. Files saved elsewhere in a session are lost when it ends.
- **[Pricing plan](https://university.eugo.io/glossary/pricing-plan)** — The tier assigned to a workspace, which governs its resource limits and concurrency: how much can run, and how much can run at once.
- **[Profiling](https://university.eugo.io/glossary/profiling)** — Measuring where a program actually spends its time, before deciding what to optimize.
- **[Role](https://university.eugo.io/glossary/role)** — The permission level a member holds in an organization, determining what they can change rather than only what they can see.
- **[Administration](https://university.eugo.io/glossary/administration-term)** — The operational side of Eugo: managing members and roles, monitoring usage, and reviewing activity logs.
- **[Scheduler](https://university.eugo.io/glossary/scheduler)** — The component on the head node that decides which compute node runs each task, honoring the resources that task requested.
- **[Scheduling overhead](https://university.eugo.io/glossary/scheduling-overhead)** — The fixed cost of dispatching a task and returning its result. When it approaches the cost of the task body, adding parallelism stops helping.
- **[Serialization](https://university.eugo.io/glossary/serialization)** — Converting Python objects into bytes so they can be sent to another machine. Large task arguments are serialized and copied to every worker that needs them.
- **[Speedup](https://university.eugo.io/glossary/speedup)** — How many times faster a distributed run is than the same work on one worker. Ideal speedup equals worker count; real speedup falls short of it.
- **[Straggler](https://university.eugo.io/glossary/straggler)** — A single task that runs far longer than its peers and holds up completion of the whole run.
- **[Task](https://university.eugo.io/glossary/task)** — One unit of distributed work: a single call to a function decorated with the distribute decorator. Tasks are stateless, so each call starts fresh.
- **[Transfer cost](https://university.eugo.io/glossary/transfer-cost)** — The time spent moving data between machines, or between host and GPU memory. Often the reason an operation is not worth accelerating.
- **[Usage](https://university.eugo.io/glossary/usage)** — Accumulated compute consumed by an organization in a billing period, shown against plan limits on the dashboard.
- **[Vectorization](https://university.eugo.io/glossary/vectorization)** — Rewriting operations so a single instruction processes several data elements at once, using the processor’s wide registers.
- **[Worker](https://university.eugo.io/glossary/worker)** — A process on a compute node that executes tasks. Worker count, not node count, is what determines how many tasks run at once.
- **[Workspace](https://university.eugo.io/glossary/workspace)** — An isolated compute environment with its own persistent storage, preinstalled libraries, and resource allocation. Where your sessions and clusters run.
- **[Notebook](https://university.eugo.io/glossary/notebook)** — A document interleaving code, output, and prose. The primary interface for writing Python in EugoIDE.
- **[Dashboard](https://university.eugo.io/glossary/dashboard)** — The first page you see when opening an organization. Aggregates workspace status, plan usage, and recent activity.
- **[Shared state](https://university.eugo.io/glossary/shared-state)** — Data that more than one task reads or writes. Shared mutable state is what turns a parallel run into a race condition.
- **[Idle cluster](https://university.eugo.io/glossary/idle-cluster)** — A cluster still running after its work finished. It bills at the full rate, and is the largest avoidable cost for most organizations.
- **[Independent work](https://university.eugo.io/glossary/independent-work)** — Units of work that can each produce their result without needing another unit’s output. A precondition for distributing anything.