Coding Dictionary

Free coding dictionary: 883+ programming, web, data, AI and tech-business terms defined in plain English, each with real code examples and the lessons that…

+ programming, web, data & business terms — each explained in plain English with real code examples.

Understand the word — then write the code

Every term links to the lessons that teach it.

All terms (A–Z)

• __dirname & __filename (Node.js) — __dirname is the absolute path of the directory containing the current module, and __filename is the full path of the current file. They let you reference files relative to the module's own location.
• __init__ (Python) — __init__ is the special method that runs automatically when you create a new object from a class. It is used to set up the object's initial attributes — like a constructor.
• ? Operator (Rust) — The ? operator propagates errors concisely: applied to a Result or Option, it unwraps the success value or returns the error/None early from the enclosing function. It replaces verbose match boilerplate.
• .env & dotenv (Node.js) — A .env file stores environment variables as KEY=value lines for local development. The dotenv package loads them into process.env at startup, so your code reads config the same way it would in production.
• .filter() (JavaScript) — .filter() creates a new array containing only the elements that pass a test you provide. The original array is left unchanged.
• .forEach() (JavaScript) — .forEach() runs a function once for every element in an array. It is used to perform an action for each item, not to build a new array.
• .gitignore — .gitignore is a text file that tells Git which files and folders to ignore, so they are never tracked or committed. It is used for things like build output, secrets, and dependency folders.
• .iloc[] (Pandas) — .iloc[] selects rows and columns by their integer position, ignoring the labels entirely. It is position-based indexing and, like normal Python slicing, excludes the stop index.
• .loc[] (Pandas) — .loc[] selects rows and columns from a DataFrame by their labels (index and column names). It is label-based indexing, and unlike Python slicing it includes the end label of a range.
• .map() (JavaScript) — .map() creates a new array by running a function on every element of an existing array, without changing the original.
• .NET — .NET is the free, cross-platform development platform that runs C# programs. It provides the runtime, a huge standard library, and tools for building apps on Windows, macOS, and Linux.
• .reduce() (JavaScript) — .reduce() boils an array down to a single value by running a function that accumulates a result as it walks through each element.
• *args and **kwargs (Python) — *args lets a function accept any number of positional arguments as a tuple, and **kwargs accepts any number of keyword arguments as a dictionary.
• #include (C++) — #include is a preprocessor directive that pastes the contents of a header file into your source code before compilation. It is how you gain access to standard library features and other code.
• A/B Test — An A/B test compares two versions of something — a page, button, or email — by showing each to a random half of users and measuring which performs better.
• Abstract Class (Java) — An abstract class is a class that can't be instantiated on its own and is meant to be extended. It can mix fully written methods with abstract methods that subclasses must complete.
• Abstract Class (TypeScript) — An abstract class is a base class that can't be instantiated on its own and may contain abstract methods that subclasses must implement. It defines a shared template for related classes.
• Abstraction — Abstraction means hiding complex details behind a simple interface, so you can use something without knowing how it works internally — like driving a car without understanding the engine.
• Access Modifier (TypeScript) — Access modifiers — `public`, `private`, and `protected` — control where a class member can be used. They keep some fields and methods internal to a class instead of exposing everything.
• Accuracy — Accuracy is the most basic way to measure a classification model: the fraction of predictions it got right out of all predictions made.
• Activation Function — An activation function is a small math function applied to a neuron's output in a neural network. It introduces non-linearity, allowing the network to learn complex patterns rather than just straight lines.
• addEventListener() (JavaScript) — addEventListener() tells an element to run a function whenever a specific event happens, such as a click or keypress. It is the standard way to make pages interactive.
• Admin Site (Django) — The Django admin is an automatically generated web interface for managing your models' data. By registering a model, you get ready-made pages to create, edit, search, and delete its rows — no extra code required.
• Advanced QuerySets (Django) — Advanced QuerySet techniques in Django include field lookups (__gte, __icontains, __in), spanning relationships in filters, values()/values_list() for dicts, and combining queries — going beyond simple equality filters.
• agg() (Pandas) — agg() (aggregate) applies one or more reducing functions to a DataFrame, Series, or GroupBy and collapses each column or group to a single summary value. It lets you compute several statistics in a single call.
• Aggregate Function — An aggregate function takes many rows and returns a single summary value. The common ones are COUNT, SUM, AVG, MIN, and MAX.
• aggregate() & annotate() (Django) — aggregate() computes a single summary value over a QuerySet (like a total or average), while annotate() adds a computed value to each object (like each author's post count). Both push the math into the database.
• Algorithm — An algorithm is a step-by-step set of instructions for solving a problem — like a recipe that always produces the same result for the same input.
• Alias (AS) — An alias is a temporary name you give a column or table in a query using the AS keyword. It makes results more readable and shortens table names in joins.
• Anchor Tag (Link) — The <a> (anchor) element creates a hyperlink that users click to navigate to another page, file, or location. The destination is set with the href attribute.
• annotate() (Matplotlib) — ax.annotate() places text on a plot at a specific data point, optionally with an arrow pointing to it. Use it to call out peaks, label specific markers, or add explanatory notes.
• any (TypeScript) — `any` is a special type that turns off type checking for a value, letting it be anything and do anything. It is an escape hatch — convenient, but it removes the safety TypeScript provides.
• API (Application Programming Interface) — An API is a set of rules that lets two pieces of software talk to each other. It defines how to request data and what you get back.
• AppConfig / ready() (Django) — AppConfig is the class that configures a Django app, set in the app's apps.py. Its ready() method runs once at startup, making it the standard place to connect signal handlers and do app initialization.
• Application Context (Flask) — The application context in Flask makes the current app and the current_app and g proxies available during a request or task. It is pushed automatically per request, but you must push it manually in scripts and background jobs.
• Application Factory (Flask) — An application factory is a function (commonly named create_app) that builds and returns a configured Flask app. It avoids module-level globals, makes testing easier, and lets you create app instances with different configs.
• apply Family (apply, lapply, sapply) (R) — The apply family applies a function repeatedly over a data structure without an explicit loop. apply works over matrix margins, lapply returns a list, and sapply simplifies to a vector or matrix.
• apply() (Pandas) — apply() runs a function along an axis of a DataFrame or over every element of a Series. It is the flexible escape hatch for transformations that don't have a built-in vectorized method.
• applymap() / DataFrame.map() (Pandas) — DataFrame.map() applies a function to every individual element of an entire DataFrame, cell by cell. It replaces the old applymap() name, which was deprecated and removed in recent pandas.
• arange() (NumPy) — np.arange() creates a 1-D array of evenly spaced values within a range, like Python's range() but returning a NumPy array and supporting a float step. It is the standard way to generate a sequence of numbers.
• Arc<T> (Rust) — Arc<T> is an atomically reference-counted smart pointer for sharing ownership across threads. It is the thread-safe sibling of Rc, using atomic operations so the count is safe under concurrency.
• argmax() and argmin() (NumPy) — np.argmax() returns the index of the largest element in an array and np.argmin() returns the index of the smallest. They give you the position of the extreme value rather than the value itself.
• ARPU (Average Revenue Per User) — ARPU is the average amount of revenue a business earns from each user or customer over a period, usually per month. It shows how much each user is worth on average.
• ARR (Annual Recurring Revenue) — ARR is the predictable revenue a subscription business earns over a full year. It is the yearly version of MRR and is the headline number SaaS companies report to investors.
• Array — An array is a data structure that stores multiple values in a single variable, accessed by their position (index). Most arrays count from index 0.
• Array (C#) — An array in C# is a fixed-size collection of items that all share the same type, stored in order and accessed by a zero-based index. Its length can't change once it's created.
• Array (C++) — A C++ array is a fixed-size, contiguous block of elements that all share the same type. You access elements by a zero-based index in square brackets.
• Array (Java) — An array in Java is a fixed-size, ordered collection of values that all share the same type. Once you set an array's length, it can't grow or shrink.
• Array (JavaScript) — An array is an ordered list of values stored in a single variable. You access items by their numeric index, starting at 0.
• ArrayList (Java) — An ArrayList is a resizable, list-like collection in Java that can grow and shrink as you add or remove items. Unlike a plain array, it has no fixed size.
• Arrow Function (JavaScript) — An arrow function is a short syntax for writing JavaScript functions using =>. Single-expression arrows return their value automatically.
• Artificial Intelligence (AI) — Artificial intelligence is the field of building computer systems that perform tasks normally requiring human intelligence, such as recognizing images, understanding language, or making decisions.
• ASCII & Unicode — ASCII and Unicode are standards that assign a number to each character so computers can store text. ASCII covers basic English; Unicode covers virtually every language and emoji.
• Assignment Operator (<-) (R) — R's primary assignment operator is <-, which binds a value to a name (x <- 5). The = sign also assigns, but <- is the idiomatic R style and avoids ambiguity inside function calls.
• astype() (Pandas) — s.astype() converts a Series or DataFrame column to a different dtype — for example text to numbers, floats to ints, or a string column to the memory-saving 'category' type. It is pandas' explicit type-cast.
• async / await (C#) — async and await let C# run long operations — like web requests or file reads — without blocking the program, keeping apps responsive. await pauses a method until an awaited task finishes, then continues.
• async / await (JavaScript) — async and await let you write asynchronous code that reads like normal step-by-step code. await pauses inside an async function until a promise settles.
• async / await (Node.js) — async/await is syntax that makes Promise-based code read like ordinary synchronous code. An async function returns a Promise, and await pauses it until a Promise settles, returning the value or throwing the rejection.
• attr_accessor (Ruby) — attr_accessor is a Ruby shortcut that auto-generates getter and setter methods for instance variables. attr_reader makes read-only accessors and attr_writer makes write-only ones.
• Authentication (Django) — Django's authentication system, in django.contrib.auth, handles users, passwords, login, and logout. It provides a User model, secure password hashing, login_required protection, and request.user for the current user.
• AVG() — AVG() is an aggregate function that returns the average (mean) of the values in a numeric column. Like other aggregates, it skips NULL values.
• Axes (Matplotlib) — An Axes is a single plot within a Figure — one set of x and y axes with its own data, ticks, labels, and title. Most plotting methods like plot, scatter, and bar are called on an Axes object.
• axis (NumPy) — An axis is a single dimension of a NumPy array; axis=0 runs down the rows and axis=1 runs across the columns in a 2-D array. The axis argument tells aggregations and operations which direction to act along.
• B2B (Business-to-Business) — B2B describes companies that sell products or services to other businesses rather than to individual consumers. Slack, Salesforce, and AWS are B2B companies.
• B2C (Business-to-Consumer) — B2C describes companies that sell directly to individual consumers rather than to other businesses. Netflix, Spotify, and most mobile apps are B2C.
• Backpropagation — Backpropagation is the algorithm neural networks use to learn. It calculates how much each weight contributed to the error and sends that information backward through the network so every weight can be adjusted.
• bar() (Matplotlib) — ax.bar() draws a vertical bar chart, with one rectangular bar per category whose height encodes its value. ax.barh() draws the horizontal version. Bar charts compare values across discrete categories.
• Base Case — A base case is the condition in a recursive function that stops the recursion. Without it, the function would call itself forever and crash.
• Batch Size — Batch size is the number of training examples a model processes at once before updating its parameters. It controls the chunk size used during each step of training.
• bcrypt (Password Hashing) (Node.js) — bcrypt is a library for securely hashing passwords in Node.js. It turns a password into a salted, slow-to-compute hash you store instead of the plaintext, and compares a login attempt against that hash.
• before_request / Request Hooks (Flask) — before_request is a Flask hook that runs a function before every request is dispatched to a view. With siblings after_request and teardown_request, these hooks let you run setup and cleanup code around all of your views.
• Bias-Variance Tradeoff — The bias-variance tradeoff describes the balance between a model being too simple (high bias, underfitting) and too sensitive to the training data (high variance, overfitting).
• Big O Notation — Big O notation describes how an algorithm's running time or memory use grows as the input gets larger, ignoring constant details. For example, O(n) grows in direct proportion to the input.
• Binary — Binary is the base-2 number system computers use, made of only two digits: 0 and 1. Each digit is a bit, and all data is ultimately stored as binary.
• Bit vs Byte — A bit is the smallest unit of data, holding a single 0 or 1. A byte is a group of 8 bits, enough to store one character or a number from 0 to 255.
• Block (Ruby) — A block is a chunk of code passed to a method, written with do...end or curly braces { }. Blocks are central to Ruby — they power iteration, resource handling, and most of the Enumerable methods.
• Blueprint (Flask) — A Flask Blueprint is a way to group related routes, templates, and static files into a reusable component. You register the Blueprint on the app, which keeps large projects organized into modules like auth, blog, and admin.
• Blueprint Registration (Flask) — Blueprint registration is the step where you attach a Blueprint to your Flask app with app.register_blueprint(bp). Until you register it, its routes are not active. Registration can add a url_prefix or subdomain to every route in the blueprint.
• bool (C#) — bool is the C# type for a value that is either true or false. Booleans come from comparisons and conditions, and they drive if-statements and loops.
• bool (C++) — bool is the C++ type that holds one of two values: true or false. Booleans are produced by comparisons and drive if-statements and loops.
• Boolean — A Boolean is a data type with only two possible values: true or false. It is the basis of every decision a program makes.
• Boolean (bool) (Python) — A boolean in Python is a value that is either True or False. Booleans are produced by comparisons and conditions and drive if-statements and loops.
• boolean (Java) — boolean is the Java primitive type that holds one of two values: true or false. Booleans come from comparisons and conditions and control if-statements and loops.
• Boolean Indexing (NumPy) — Boolean indexing filters a NumPy array by passing it a boolean mask of the same shape, keeping only the elements where the mask is True. It is the standard way to select array elements that meet a condition.
• Boolean Indexing / Mask (Pandas) — Boolean indexing filters a DataFrame or Series by passing it an array of True/False values, keeping only the rows where the condition is True. The boolean array is called a mask.
• Border (CSS) — The border is the line drawn around an element, sitting between its padding and its margin in the box model. You control its width, style, and color.
• Borrow Checker (Rust) — The borrow checker is the part of the Rust compiler that enforces the ownership and borrowing rules at compile time, guaranteeing memory safety and freedom from data races without a garbage collector.
• Borrowing (Rust) — Borrowing lets you access a value through a reference (&) without taking ownership of it. The borrow checker enforces that borrows never outlive the data and never alias mutably.
• Bounce Rate — Bounce rate is the percentage of visitors who land on a page and leave without taking any further action or visiting another page. A lower bounce rate is usually better.
• Box Model — The CSS box model describes how every element is a rectangular box made of four layers: content, padding, border, and margin. Understanding it is key to controlling spacing and size.
• Box<T> (Rust) — Box<T> is the simplest smart pointer: it stores a value on the heap instead of the stack, with single ownership. It's used for large values, recursive types, and trait objects.
• Branch — A branch is a separate line of development in a Git repository. It lets you work on a new feature or fix in isolation without affecting the main code, then merge it back when ready.
• Broadcasting (NumPy) — Broadcasting is NumPy's set of rules for combining arrays of different shapes in an operation by automatically stretching the smaller one across the larger, without actually copying data. It is what lets you add a scalar or a row to a whole matrix.
• Buffer (Node.js) — A Buffer is a Node.js object for handling raw binary data — bytes — outside the V8 heap. It is used for file contents, network packets, and any binary I/O, and can convert to and from strings using an encoding.
• Bug — A bug is an error or flaw in code that makes a program behave incorrectly or crash. Finding and fixing bugs is called debugging.
• Bundler (Ruby) — Bundler is Ruby's dependency manager. It reads a Gemfile listing the gems your project needs, resolves compatible versions, and locks them in Gemfile.lock so every machine installs exactly the same set.
• Burn Rate — Burn rate is how much cash a startup spends each month beyond what it earns. It is the speed at which a company is 'burning' through its funding.
• Button Element — The <button> element creates a clickable button. Inside a form it can submit or reset the form, and anywhere on a page it can trigger JavaScript actions.
• c() (Combine) (R) — c() is R's fundamental function for combining values into a vector. It concatenates its arguments into a single vector, coercing them to a common type if they differ.
• C# — C# is a modern, object-oriented programming language created by Microsoft. It runs on the .NET platform and is widely used for desktop apps, web services, games (Unity), and mobile development.
• C++ — C++ is a general-purpose programming language that extends C with object-oriented features, templates, and a large standard library. It is widely used for systems software, game engines, and high-performance applications.
• CAC (Customer Acquisition Cost) — CAC is the total cost of gaining one new customer — all marketing and sales spend divided by the number of customers acquired.
• Caching (Django) — Caching in Django stores expensive results so repeated requests are served fast. It offers per-view caching, template-fragment caching, and a low-level cache API, backed by memory, the database, files, or Redis/Memcached.
• Callback (Node.js) — A callback is a function passed into another function to be called later, typically when an async operation finishes. Node's classic style is the error-first callback: (err, result) => {...}, with the error as the first argument.
• Callback Function (JavaScript) — A callback is a function passed as an argument to another function, to be called ("called back") later. Callbacks power events, timers, and array methods.
• Cargo (Rust) — Cargo is Rust's official build tool and package manager. It compiles your code, downloads and tracks dependencies, runs tests, and builds release binaries — all from simple commands.
• case / when (Ruby) — case/when is Ruby's classic multi-branch conditional, like a switch. Each when uses the === operator, so it can match values, ranges, classes, and regexes, returning the value of the matching branch.
• Categorical dtype (Pandas) — The category dtype stores a column as a fixed set of distinct values plus integer codes pointing into them, instead of repeating the full strings. It saves memory and can model ordered categories.
• char (C++) — char is the C++ type that stores a single character, such as 'A' or '?'. It is written with single quotes and actually holds a small integer (the character's code).
• child_process Module (Node.js) — child_process is Node.js's built-in module for spawning external programs and shell commands from your app. spawn, exec, execFile, and fork let you run other processes and communicate with them.
• Churn Rate — Churn rate is the percentage of customers who stop using a product or cancel their subscription during a given period. A lower churn rate is better.
• CI/CD — CI/CD stands for Continuous Integration and Continuous Delivery/Deployment — an automated pipeline that builds, tests, and ships code whenever changes are pushed, catching bugs early and releasing faster.
• Class — A class is a blueprint for creating objects. It defines the properties (data) and methods (actions) that objects of that type will have.
• Class (C#) — A class is a blueprint for creating objects that bundle together data (fields and properties) and behavior (methods). You define one with the class keyword.
• Class (C++) — A class is a blueprint for creating objects that bundle data (member variables) and behavior (member functions) together. It is the foundation of object-oriented programming in C++.
• Class (Java) — A class in Java is a blueprint for creating objects that groups together data (fields) and behavior (methods). Almost all Java code lives inside a class.
• Class (JavaScript) — A class is a template for creating objects with shared properties and methods. The class keyword gives JavaScript a clean syntax for object-oriented programming.
• Class (Kotlin) — A class is a blueprint for objects, bundling properties (data) and functions (behavior). Kotlin classes are concise — final and public by default — with constructors and properties declared in the header.
• Class (Python) — A class is a blueprint for creating objects that bundle together data (attributes) and behavior (methods). You define one with the class keyword.
• Class (TypeScript) — A TypeScript class is a JavaScript class with added type features — typed fields, typed methods, access modifiers, and the ability to implement interfaces. It is a blueprint for creating typed objects.
• Class-Based View (Django) — A class-based view (CBV) implements a Django view as a class instead of a function. Methods like get() and post() handle each HTTP method, and inheritance/mixins let views share behavior, reducing repetitive code.
• Classification — Classification is a supervised learning task where a model predicts which category an input belongs to, such as labeling an email 'spam' or 'not spam.'
• clip() and round() (NumPy) — np.clip() limits array values to a range, replacing anything below the minimum or above the maximum with the boundary value. np.round() rounds elements to a given number of decimal places. Both are vectorized.
• Clone — Cloning makes a full local copy of a remote repository, including all its files and complete history. git clone is usually the first command you run to start working on an existing project.
• Closure (JavaScript) — A closure is a function that remembers the variables from the scope where it was created, even after that outer function has finished running.
• Closure (Rust) — A closure is an anonymous function that can capture variables from the surrounding scope. Written with |params| body, closures are Rust's lightweight inline functions, used heavily with iterators.
• Clustering — Clustering is an unsupervised learning task that groups similar data points together into clusters, without any predefined labels, based purely on how alike the points are.
• Cohort Analysis — Cohort analysis groups users by a shared trait — usually the month they signed up — and tracks each group over time to see how behavior like retention changes.
• Collection Operations (map, filter, fold) (Kotlin) — Kotlin provides functional operations on collections — map, filter, fold, groupBy, and more — that transform data declaratively with lambdas instead of manual loops.
• Collections (List, Set, Map) (Kotlin) — Kotlin's standard collections are List (ordered), Set (unique), and Map (key–value). Each comes in a read-only interface and a Mutable variant, making immutability the default.
• colorbar() (Matplotlib) — fig.colorbar() adds a color-scale legend beside a plot, showing which colors of a colormap correspond to which data values. It is the key that makes a colored scatter, heatmap, or image readable.
• Colormap (Matplotlib) — A colormap maps numeric values to colors, so you can encode a continuous variable as color in scatter plots, heatmaps, and images. 'viridis' is the perceptually uniform default; 'plasma', 'coolwarm', and 'gray' are common alternatives.
• Column (Field) — A column is a single attribute in a database table, such as 'name' or 'age'. Every column has a fixed data type, and every row stores one value for each column.
• Comment — A comment is a note in the source code that the computer ignores. Comments explain what the code does for the humans reading it.
• Comment (Python) — A comment is a note in your code that Python ignores when running the program. In Python, anything after a # on a line is a comment.
• Commit — A commit is a saved snapshot of your project at a point in time, along with a message describing the change. Commits form the history of a Git repository and each has a unique ID (hash).
• CommonJS vs ES Modules (Node.js) — Node.js supports two module systems: CommonJS (require/module.exports), its original synchronous system, and ES Modules (import/export), the modern JavaScript standard. They differ in syntax, loading, and a few behaviors.
• Companion Object (Kotlin) — A companion object is a single object declared inside a class with the companion keyword. Its members are accessed through the class name, serving the role of static members and factory methods.
• Comparable (Ruby) — Comparable is a Ruby mixin that gives a class the comparison operators <, <=, ==, >, >=, plus between? and clamp — all derived from a single <=> method you define.
• Compiler — A compiler is a program that translates source code written by a human into machine code (or another lower-level form) that a computer can run directly.
• Component — A component is a reusable, self-contained piece of a React user interface, such as a button, form, or page. Components return JSX describing what to render and can be combined to build a whole app.
• Component Lifecycle — The component lifecycle is the sequence of phases a React component goes through: mounting (appearing on screen), updating (re-rendering when data changes), and unmounting (being removed). The useEffect Hook lets you run code at these moments.
• Computer Vision — Computer vision is the field of AI that enables computers to interpret and understand visual information from images and videos, such as recognizing objects, faces, or text.
• concat() (Pandas) — pd.concat() stacks DataFrames or Series together along an axis — vertically to add rows (axis=0) or horizontally to add columns (axis=1). Use it to glue pieces of data into one object.
• concatenate() (NumPy) — np.concatenate() joins a sequence of arrays end to end along an existing axis. It is the general-purpose tool for combining arrays, with hstack, vstack, and stack as convenient specializations.
• Concatenation — Concatenation is the joining of two or more strings end to end to form a single string, usually with the + operator or string formatting.
• Conditional — A conditional is a statement that runs code only if a condition is true. It lets a program make decisions, most often using if, else if, and else.
• Conditional Rendering — Conditional rendering is showing different JSX depending on a condition, such as displaying a 'Log out' button only when a user is signed in. React uses ordinary JavaScript logic to decide what to render.
• Configuration (Node.js) — Configuration in Node.js means managing settings that vary by environment — ports, database URLs, secrets, feature flags. The common approach reads from environment variables, often centralized into a single config module.
• Configuration / app.config (Flask) — app.config is the dictionary that holds a Flask application's settings, such as SECRET_KEY, DEBUG, and database URIs. You populate it from objects, files, or environment variables so the same code can run in different environments.
• Confusion Matrix — A confusion matrix is a table that summarizes a classification model's performance by showing how many predictions were correct and incorrect for each class.
• console.log() (JavaScript) — console.log() prints a message to the browser's (or Node's) developer console. It is the main tool for inspecting values and debugging JavaScript.
• Console.WriteLine() — Console.WriteLine() is C#'s method for printing a line of text to the console (terminal). It writes whatever you pass it and then moves to a new line.
• Constant — A constant is a named value that cannot be changed once it is set. It is used for values that should stay fixed, such as PI or a maximum limit.
• Constraint (SQL) — A constraint is a rule that limits what data a table column can hold, keeping data valid and consistent. Common constraints include PRIMARY KEY, FOREIGN KEY, NOT NULL, UNIQUE, and CHECK.
• Constructor (C#) — A constructor is a special method that runs automatically when you create an object with new. It sets up the object's starting state, usually by assigning its fields and properties.
• Constructor (C++) — A constructor is a special member function that runs automatically when an object is created. It has the same name as the class and is used to initialize the object's data.
• Constructor (Java) — A constructor is a special method that runs automatically when you create an object with new. Its job is to set up the object's initial state, such as assigning starting values to its fields.
• Container — A container is a lightweight, isolated package that bundles an application with all its dependencies so it runs consistently anywhere. Containers are created from images by tools like Docker.
• Context API — The Context API is React's built-in way to share data across many components without passing props through every level. You create a Context, provide a value at the top, and read it anywhere below with useContext.
• Context Processor (Django) — A context processor is a function that injects variables into every template's context automatically. Django uses them to make values like the current user available in all templates without passing them from each view.
• Continuous Integration (CI) — Continuous Integration is the practice of frequently merging code changes into a shared branch, where an automated system builds and tests them. It catches integration bugs early, while they are easy to fix.
• Controlled Component — A controlled component is a form input whose value is driven by React state rather than the DOM. The input shows the state value, and an onChange handler updates that state on every keystroke.
• Conversion Rate — Conversion rate is the percentage of people who take a desired action — such as signing up, buying, or clicking — out of everyone who had the chance to.
• Cookies (Flask) — A cookie is a small piece of data the server asks the browser to store and send back on later requests. In Flask you read cookies from request.cookies and set them with response.set_cookie().
• Copy and Clone (Rust) — Copy and Clone are traits that let a type be duplicated. Copy gives implicit, cheap bit-for-bit copies on assignment (for stack types like integers); Clone gives an explicit, possibly expensive .clone() for heap types.
• Coroutine (Kotlin) — A coroutine is a lightweight, suspendable computation for writing asynchronous and concurrent code in a sequential style. Thousands can run on a few threads because suspending frees the thread instead of blocking it.
• CORS (Flask) — CORS (Cross-Origin Resource Sharing) controls whether browsers allow a web page from one origin to call your Flask API on another origin. Flask-CORS adds the response headers that grant that permission.
• COUNT() — COUNT() is an aggregate function that returns how many rows match a query. COUNT(*) counts all rows, while COUNT(column) counts only rows where that column is not NULL.
• CRAN (R) — CRAN (the Comprehensive R Archive Network) is the official repository for R packages and the R software itself. install.packages() downloads from CRAN by default.
• Crate (Rust) — A crate is the unit of compilation and distribution in Rust — either a binary crate (an executable with a main function) or a library crate (reusable code other crates depend on).
• Creating Arrays (NumPy) — NumPy offers many constructors for building arrays: np.array from existing data, np.zeros / np.ones / np.full for constant fills, np.arange / np.linspace for sequences, and np.random for random data.
• CRUD — CRUD stands for Create, Read, Update, and Delete — the four basic operations for managing stored data. Most apps that handle data support all four.
• crypto Module (Node.js) — crypto is Node.js's built-in module for cryptography: hashing, HMAC, encryption, and generating secure random values. It is used for checksums, signing, and creating tokens or random ids.
• CSRF Protection (Django) — Django protects against Cross-Site Request Forgery by requiring a secret token on every POST form. You add {% csrf_token %} inside the form, and CsrfViewMiddleware rejects POST requests that lack a valid token.
• CSRF Protection (Flask) — CSRF (Cross-Site Request Forgery) is an attack where a malicious site tricks a logged-in user's browser into submitting an unwanted request. Flask-WTF defends against it by embedding a secret token in each form that the server verifies.
• CSS — CSS (Cascading Style Sheets) is the language used to style and lay out HTML content — controlling colors, fonts, spacing, and positioning. It separates how a page looks from what the page contains.
• CSS Animation — CSS animations let elements change appearance over time without JavaScript, using @keyframes to define the steps and the animation property to apply them. They power effects like fades, spins, and slides.
• CSS Class — A CSS class is a reusable label you add to HTML elements with the class attribute, then target in CSS with a dot, like .button. The same class can be applied to many elements.
• CSS Grid — CSS Grid is a two-dimensional CSS layout system for arranging content into rows and columns at the same time. You enable it with display: grid on a container.
• CSS ID — An id is a unique identifier you add to a single HTML element with the id attribute, then target in CSS with a hash, like #header. Each id should appear only once per page.
• CSS Property — A CSS property is a single styling setting you change, such as color, font-size, or margin. Each property is paired with a value to form a declaration like color: red;.
• CSS Selector — A CSS selector is the pattern that tells CSS which HTML elements a rule should apply to. Selectors can target elements by tag name, class, id, attribute, or relationship.
• CSS Specificity — Specificity is the scoring system browsers use to decide which CSS rule wins when several rules target the same element. More specific selectors override less specific ones.
• CSS Transform — The CSS transform property visually changes an element by moving, rotating, scaling, or skewing it, without affecting the layout of surrounding elements. It is widely used for animations and effects.
• CSS Variable (Custom Property) — A CSS variable, officially called a custom property, is a reusable value you define once and reference throughout your stylesheet. They are written with two dashes and read with var().
• cumsum() and cumprod() (NumPy) — np.cumsum() returns the running (cumulative) sum of an array — each element is the total of all elements up to that point — and np.cumprod() returns the running product. They keep the same length as the input.
• current_user (Flask-Login) — current_user is a Flask-Login proxy that always refers to the user handling the current request. If someone is logged in it is their User object; otherwise it is an anonymous user where current_user.is_authenticated is False.
• Custom Hook — A custom Hook is your own reusable function that bundles together React Hooks to share stateful logic between components. By convention its name starts with 'use', like useToggle or useFetch.
• cut() and qcut() (Pandas) — pd.cut() bins continuous numbers into discrete intervals you define by edges, while pd.qcut() bins them into groups of roughly equal size based on quantiles. Both turn a numeric column into categories.
• Data Class (Kotlin) — A data class is a class meant to hold data. Adding the data keyword makes Kotlin auto-generate equals(), hashCode(), toString(), copy(), and componentN() from the primary constructor properties.
• Data Frame (R) — A data frame is R's table structure: a list of equal-length columns where each column is a vector and can hold a different type. It is the standard format for rectangular, spreadsheet-like data.
• Data Structure — A data structure is a way of organising and storing data so it can be used efficiently. Arrays, lists, stacks, queues, and hash maps are common examples.
• Data Type — A data type tells the computer what kind of value a piece of data is — such as a number, text (string), or true/false (boolean) — and what you can do with it.
• Database — A database is an organized collection of data stored so it can be easily searched, updated, and managed. A relational database arranges that data into tables made of rows and columns.
• DataFrame — A DataFrame is a 2D table of data with labeled rows and columns, provided by the pandas library. It is the most common way to load, clean, and explore datasets in Python.
• DataFrame (Pandas) — A DataFrame is pandas' 2-D, size-mutable table of rows and columns, like a spreadsheet or SQL table in memory. Each column can hold a different data type and every row shares a common index.
• DataFrame.plot() (Matplotlib + Pandas) — df.plot() is pandas' built-in plotting method that draws charts directly from a DataFrame or Series using Matplotlib underneath. It is the fastest way to visualize tabular data without writing Matplotlib calls by hand.
• Dataset — A dataset is a structured collection of data used to train and evaluate machine learning models. It is typically organized as rows of examples and columns of features.
• Debug Mode (Flask) — Flask's debug mode enables the interactive in-browser debugger and the auto-reloader during development. When an exception occurs you get a detailed traceback and a console, and code changes restart the server automatically.
• Debugging — Debugging is the process of finding and fixing errors (bugs) in code. It involves locating the cause of a problem and correcting it.
• Decision Tree — A decision tree is a machine learning model that makes predictions by asking a sequence of yes/no questions about the features, following branches until it reaches an answer at a leaf.
• Decorator (Python) — A decorator is a function that wraps another function to add behavior before or after it, without changing the original code. You apply one with the @ symbol above a function.
• Decorator (TypeScript) — A decorator is a special declaration prefixed with `@` that attaches extra behavior or metadata to a class, method, or property. It is widely used by frameworks like Angular and NestJS.
• Deep Learning — Deep learning is a type of machine learning that uses neural networks with many layers (hence 'deep') to learn complex patterns directly from raw data like images, audio, and text.
• Delegate (C#) — A delegate is a type that holds a reference to a method, letting you store and pass methods around like variables. It is the foundation of callbacks, events, and LINQ in C#.
• DELETE Statement — DELETE removes rows from a table. A WHERE clause decides which rows go; without one, DELETE empties the entire table.
• Dependency — A dependency is an external library or package that a project needs in order to work. Dependencies are usually installed and tracked by a package manager.
• Deployment — Deployment is the process of releasing your application to a server or environment where users can access it — moving code from development into production. Modern teams automate it as part of CI/CD.
• Deployment (Django) — Deploying Django means running it under a production server (Gunicorn/Uvicorn behind nginx), with DEBUG off, proper ALLOWED_HOSTS, collected static files, applied migrations, and secrets loaded from the environment.
• describe() (Pandas) — df.describe() generates summary statistics for a DataFrame's numeric columns — count, mean, standard deviation, min, the quartiles, and max. It gives a fast statistical snapshot of your data's distribution.
• Destructor (C++) — A destructor is a special member function that runs automatically when an object is destroyed. It shares the class name prefixed with a tilde (~) and is used to release resources the object owns.
• Destructuring (JavaScript) — Destructuring is a syntax for pulling values out of arrays or properties out of objects into separate variables in one line.
• Destructuring Declaration (Kotlin) — Destructuring unpacks an object's components into several variables in one statement, like val (name, age) = user. It works with data classes, pairs, maps, and any type defining componentN() operators.
• Dictionary (Python) — A Python dictionary stores data as key–value pairs in curly braces. You look values up by their key instead of by position.
• Dictionary<TKey, TValue> (C#) — A Dictionary<TKey, TValue> stores data as key–value pairs, letting you look up a value by its unique key instead of by position. It is C#'s version of a hash map.
• Display Property — The CSS display property controls how an element is laid out — for example as a block, inline, none (hidden), flex, or grid. It is one of the most important layout properties.
• DISTINCT — DISTINCT removes duplicate rows from a query's results, so each unique value or combination appears only once. It goes right after SELECT.
• div Element — The <div> is a generic block-level container with no meaning of its own, used to group other elements together for styling or layout. It is one of the most-used HTML elements.
• Django REST Framework (DRF) — Django REST Framework (DRF) is the standard toolkit for building Web APIs on top of Django. It adds serializers, class-based API views and viewsets, authentication, permissions, and a browsable API for testing endpoints.
• Django Template Language (DTL) — The Django Template Language is the syntax used inside Django templates: {{ }} for variables, {% %} for tags (logic), and | for filters that transform values. It is intentionally restricted to keep logic out of templates.
• Docker — Docker is a tool that packages an application and everything it needs to run into a portable unit called a container. This makes software run the same way on any machine, removing 'it works on my machine' problems.
• DOM (Document Object Model) — The DOM is the browser's live, tree-shaped representation of an HTML page. Each element, attribute, and piece of text becomes a node that JavaScript can read and change.
• DOM (JavaScript) — The DOM (Document Object Model) is a live, tree-shaped representation of an HTML page that JavaScript can read and change. Editing the DOM updates what the user sees.
• dot() and matmul() (NumPy) — np.dot() and np.matmul() (the @ operator) perform matrix multiplication and dot products. For 1-D arrays they compute the dot product; for 2-D arrays they do true matrix multiplication, not element-wise multiplication.
• double (C++) — double is the C++ type for numbers with a decimal point, such as 3.14 or -0.5. It stores double-precision floating-point values and is the standard type for real numbers.
• double (Java) — double is the Java primitive type for numbers with a decimal point, such as 3.14 or -0.5. It stores a 64-bit floating-point value and is the default choice for decimal numbers in Java.
• dplyr (R) — dplyr is the tidyverse package for data manipulation. It provides a small set of verb functions — filter, select, mutate, arrange, summarise, group_by — that read like a grammar for transforming data frames.
• DRF Authentication & Permissions — DRF authentication identifies the API caller (via token, session, or JWT), and permission classes decide whether that caller may perform the request. You set them per view or globally in REST_FRAMEWORK settings.
• drop() (Pandas) — df.drop() removes specified rows or columns from a DataFrame by their labels. Use columns=... to delete columns and index=... (or labels with axis) to delete rows.
• dropna() (Pandas) — df.dropna() removes rows (or columns) that contain missing values. It is the quickest way to discard incomplete records before analysis.
• dtype (NumPy) — A dtype describes the type and size of every element in a NumPy array — for example int64, float32, bool, or complex128. Because all elements share one dtype, NumPy can store and process them efficiently.
• dtype (Pandas) — A dtype is the data type pandas assigns to each column or Series, such as int64, float64, bool, datetime64, or str. It determines what operations are valid and how much memory the data uses.
• Duck Typing (Ruby) — Duck typing is Ruby's approach to types: what matters is whether an object responds to the methods you call, not its class. 'If it walks like a duck and quacks like a duck, it's a duck.'
• Dynamic Route / URL Converter (Flask) — A dynamic route in Flask captures part of the URL as a variable using angle brackets, like /post/<int:id>. The captured value is passed into the view function as an argument.
• each, map, and select (Ruby) — each iterates a collection running a block per element (returning the original); map transforms each element into a new array; select filters, keeping elements for which the block is true.
• einsum() (NumPy) — np.einsum() (Einstein summation) expresses sums of products over array indices using a compact subscript string. It can do dot products, matrix multiplication, transposes, traces, and custom contractions in one call.
• Elvis Operator (?:) (Kotlin) — The Elvis operator ?: returns its left side if it's not null, otherwise the right side. It's Kotlin's concise way to supply a default value for a nullable expression.
• Embedding — An embedding is a way of representing words, images, or other items as lists of numbers (vectors) so that similar items end up close together in that numeric space.
• Encapsulation — Encapsulation is the practice of bundling data and the methods that act on it inside one unit (like a class) and restricting direct outside access to the data.
• Encapsulation (Java) — Encapsulation is the practice of hiding an object's internal data and exposing it only through controlled methods. In Java, you do this by making fields private and providing public getters and setters.
• Enum (Rust) — An enum defines a type by enumerating its possible variants, where each variant can carry its own data. Rust enums are full algebraic data types — far more powerful than C-style enums.
• Enum (TypeScript) — An enum is a named set of related constants, defined with the `enum` keyword. It gives friendly names to a fixed group of values, such as directions or statuses.
• Enum Class (Kotlin) — An enum class defines a fixed set of named constants. Kotlin enums can carry properties, implement interfaces, and have methods, while still working seamlessly in exhaustive when expressions.
• Enumerable (Ruby) — Enumerable is a Ruby module that provides dozens of collection methods — map, select, reduce, sort, find, and more — to any class that defines an each method. Array and Hash include it.
• enumerate() (Python) — enumerate() lets you loop over a sequence while also getting the index of each item. It pairs each element with a counter, so you don't have to track the position yourself.
• Environment (R) — An environment is R's structure for binding names to values — essentially a lookup table of variables. Every function call creates one, and they form the chain R searches to resolve a variable.
• Environment Variables (Node.js) — Environment variables are external configuration values your Node.js app reads from process.env. They keep secrets and per-environment settings (database URLs, API keys, ports) out of your code.
• Epoch — An epoch is one complete pass of the entire training dataset through a learning algorithm. Models are usually trained for many epochs so they can gradually improve.
• Error Handling (Flask) — Error handling in Flask lets you customize what happens when something goes wrong, replacing the default error pages with your own. You register handlers with @app.errorhandler(code) and raise HTTP errors with abort().
• Error Handling (Node.js) — Error handling in Node.js spans several styles: error-first callbacks, try/catch around await, .catch() on Promises, and 'error' events on emitters. Unhandled errors can crash the process, so each async path needs coverage.
• Error Handling (Rust) — Rust handles errors without exceptions. Recoverable failures use the Result<T, E> type and the ? operator; unrecoverable bugs use panic!. The compiler forces you to deal with the possibility of failure.
• errorbar() (Matplotlib) — ax.errorbar() draws a line or scatter plot with error bars showing the uncertainty around each point. It is the standard chart for plotting measured data with its standard deviation or confidence interval.
• ES Module (import/export) (Node.js) — An ES Module (ESM) uses the standard JavaScript import and export syntax instead of require/module.exports. Node enables ESM for .mjs files or when package.json sets "type": "module".
• Event (C#) — An event is a notification a class sends out when something happens, so other code can react to it. It is built on delegates and is central to the publish–subscribe pattern.
• Event Handling (React) — Event handling in React is responding to user actions like clicks, typing, or form submissions. You attach a function to an element using camelCase props such as onClick and onChange.
• Event Loop (JavaScript) — The event loop is the mechanism that lets single-threaded JavaScript handle asynchronous tasks. It runs queued callbacks once the main code has finished.
• Event Loop (Node.js) — The event loop is the mechanism that lets single-threaded Node.js handle many operations concurrently. It runs your code, offloads I/O, and then processes completed callbacks in phases, never blocking on slow operations.
• EventEmitter (Node.js) — EventEmitter is a core Node.js class for the observer pattern: an object emits named events, and listeners registered with .on() run when those events fire. Many Node APIs (streams, servers) are built on it.
• Everything Is an Object (Ruby) — In Ruby, every value is an object — including numbers, strings, true, false, nil, and even classes themselves. Every operation is a method call on some object.
• Exception — An exception is an error that occurs while a program is running. If it is not handled, it stops the program; code can 'catch' exceptions to recover gracefully.
• Exception (C#) — An exception is an error that occurs while a C# program is running, such as dividing by zero or accessing a missing key. If not handled, it stops the program and prints an error.
• Exception (Java) — An exception is an error that occurs while a program is running, such as dividing by zero or accessing an invalid array index. If not handled, it stops the program and prints a stack trace.
• Exception (Python) — An exception is an error that occurs while a program is running, such as dividing by zero or accessing a missing key. If not handled, it stops the program and prints a traceback.
• Exception Handling (Ruby) — Ruby handles errors with begin/rescue/ensure blocks. You raise exceptions with raise and catch them with rescue, optionally cleaning up in ensure regardless of success or failure.
• Express (Node.js) — Express is the most popular web framework for Node.js. It adds simple routing, middleware, and request/response helpers on top of the built-in http module, making it fast to build APIs and web servers.
• Extension Function (Kotlin) — An extension function adds a new method to an existing class without inheriting from it or editing its source. You declare it by prefixing the function name with the receiver type.
• F Expression (Django) — An F expression references a model field's value inside a query so the database does the computation. It lets you compare or update fields using their current column values without first loading them into Python.
• f-string (Python) — An f-string is Python's way of inserting variables directly inside text. You prefix the string with f and put expressions inside curly braces.
• Factor (R) — A factor is R's type for categorical data. It stores values as a set of discrete levels (categories) rather than plain text, which is essential for grouping, modeling, and ordered categories.
• Factor Levels (R) — The levels of a factor are its set of distinct categories. They define which values are valid, their order, and how the factor appears in tables, plots, and statistical models.
• Fancy Indexing (NumPy) — Fancy indexing selects elements from a NumPy array by passing an array or list of integer positions, letting you pick arbitrary, non-contiguous elements in any order. Unlike a slice, it returns a copy, not a view.
• Feature — A feature is an individual measurable input variable used by a machine learning model — one column of data describing each example, such as a house's size or a customer's age.
• fetch() (JavaScript) — fetch() is the built-in browser function for making HTTP requests to a server. It returns a promise that resolves to the response.
• Figure (Matplotlib) — A Figure is the top-level container for an entire Matplotlib drawing — the whole window or page that holds one or more Axes (plots), plus any titles, legends, and colorbars. Everything you draw lives inside a Figure.
• File Uploads (Django) — File uploads in Django use FileField or ImageField on a model to store user-submitted files. The file is saved under MEDIA_ROOT, and the field stores its path; forms must use enctype multipart and pass request.FILES.
• File Uploads (Flask) — File uploads in Flask are accessed through request.files, which holds files submitted by a multipart form. You read a file, validate it, sanitize its name with secure_filename(), and save it with file.save(path).
• fill_between() (Matplotlib) — ax.fill_between() shades the area between two curves (or between a curve and a horizontal baseline). It is used for confidence bands, highlighting regions, and emphasizing the area under a line.
• fillna() (Pandas) — df.fillna() replaces missing values (NaN) with a value you supply — a constant, a per-column dict, or values carried forward/backward from neighbors. It is the main tool for filling gaps in data.
• filter() (Python) — filter() keeps only the items from a sequence for which a function returns True. It is used to select a subset of values based on a condition.
• final (Java) — final marks something as unchangeable. A final variable can't be reassigned after it's set, a final method can't be overridden, and a final class can't be extended.
• Flash Messages (Flask) — Flash messages in Flask are one-time notifications, like 'Saved successfully', shown to the user on the next page they see. You queue one with flash() and display queued messages in templates with get_flashed_messages().
• Flask App Object — The Flask app object is the central instance you create with Flask(__name__). It holds your configuration, URL routes, and request-handling logic, and it is the WSGI application that the server runs.
• Flask-Login — Flask-Login is the extension that manages user authentication sessions in Flask. It tracks who is logged in, remembers them across requests, and provides helpers like login_user(), logout_user(), and the login_required decorator.
• Flask-Migrate / Migrations — Flask-Migrate is the extension that adds database migrations to Flask using Alembic. Migrations are versioned scripts that evolve your database schema (adding columns, tables, indexes) in step with your models.
• Flask-SQLAlchemy — Flask-SQLAlchemy is the extension that integrates the SQLAlchemy ORM into Flask. It manages the database connection and session for you and lets you define tables as Python classes (models) with db.Model.
• Flask-WTF / WTForms — Flask-WTF integrates the WTForms library into Flask to build and validate HTML forms in Python. You define a form as a class with fields and validators, and it handles rendering, validation, and CSRF protection.
• Flexbox — Flexbox is a CSS layout system for arranging items in a single row or column, with powerful control over alignment and spacing. You enable it by setting display: flex on a container.
• Float — A float (floating-point number) is a data type for numbers that have a decimal point, such as 3.14 or -0.5. It is used when fractional values are needed.
• Float (Python) — A float in Python is a number with a decimal point, such as 3.14 or -0.5. It represents real numbers and is stored as a 64-bit floating-point value.
• Flow (Kotlin) — Flow is Kotlin's coroutine-based type for an asynchronous stream of values emitted over time. It is cold and reactive: the producer runs only when a terminal collector subscribes.
• for Loop (C#) — A for loop in C# repeats a block of code a set number of times using a counter. It packs the start value, the continue condition, and the step into one line.
• for Loop (C++) — A C++ for loop repeats a block of code a controlled number of times. Its header has three parts: an initializer, a condition to keep looping, and an update that runs after each pass.
• for Loop (Java) — A for loop repeats a block of code a set number of times. It has three parts in its header: initialization, a condition, and an update, all separated by semicolons.
• for Loop (Python) — A Python for loop repeats a block of code once for each item in a sequence such as a list, string, or range. It is the main way to iterate in Python.
• foreach Loop (C#) — A foreach loop walks through every item in a collection such as an array or List<T>, giving you each element one at a time. It is the simplest way to iterate in C#.
• Foreign Key — A foreign key is a column that links one table to another by pointing to the primary key of a different table. It is how relationships between tables are enforced.
• ForeignKey (Django) — A ForeignKey creates a many-to-one relationship between two Django models, like many posts belonging to one author. It stores the related object's id and lets you access the related object as an attribute.
• Fork — A fork is your own personal copy of someone else's repository on a hosting service like GitHub. It lets you freely experiment and propose changes back via a pull request without affecting the original.
• Form (Django) — A Django Form is a class that defines, renders, and validates an HTML form in Python. You declare fields with validation rules, render the form in a template, and call is_valid() to check submitted data before using it.
• Form Validation (Flask) — Form validation in Flask checks that submitted data meets your rules before you act on it. With Flask-WTF you attach validators to fields and call validate_on_submit(); errors collect in form.errors for display.
• Formula (~) (R) — A formula in R uses the tilde ~ to describe a relationship between variables, typically 'response ~ predictors'. Formulas are the standard interface for statistical models and many plotting functions.
• Fragment (React) — A Fragment lets a component return multiple elements without wrapping them in an extra DOM node like a div. You write it as <React.Fragment> or, more commonly, the shorthand empty tags <> </>.
• Framework — A framework is a structured foundation for building applications that provides ready-made architecture and calls your code at the right times. Examples include React, Django, and Spring.
• Freemium — Freemium is a pricing model where the basic product is free forever and advanced features are paid. The goal is to attract many users, then convert a slice of them to paying customers.
• FROM Clause — The FROM clause tells a SQL query which table (or tables) to read data from. It almost always follows the list of columns in a SELECT statement.
• frozen / freeze (Ruby) — Calling freeze on an object makes it immutable — any attempt to modify it raises a FrozenError. Frozen objects are safer to share and let Ruby optimize, especially for string literals.
• fs Module (Node.js) — fs is Node.js's built-in File System module for reading, writing, and managing files and directories. It offers async (callback), Promise (fs/promises), and synchronous (Sync) versions of each operation.
• Function — A function is a reusable, named block of code that performs a specific task. It can take inputs (parameters) and return an output.
• Function (C++) — A function is a named, reusable block of code. In C++ you declare its return type, name, and parameters, then call it to run its body and optionally get a value back.
• Function (R) — A function in R is a reusable block of code created with the function keyword and assigned to a name. Functions are first-class objects: you can pass them as arguments and return them from other functions.
• Function / def (Python) — A function is a reusable, named block of code defined with the def keyword. You call it by name to run its code, optionally passing in values called arguments.
• Function Type (TypeScript) — A function type describes the parameters a function takes and the value it returns, written like `(a: number) => string`. It lets you type variables, parameters, and callbacks that hold functions.
• Functional Component — A functional component is a React component written as a plain JavaScript function that returns JSX. It is the modern, standard way to write components and can use Hooks for state and side effects.
• Funnel (Conversion Funnel) — A funnel is the step-by-step path a user takes toward a goal — like visit, sign up, then purchase — where fewer people remain at each stage, forming a funnel shape.
• g Object (Flask) — g is Flask's 'global' namespace object for stashing data during a single request, such as the current user or a database connection. Despite the name it is request-scoped — it resets at the start of every request.
• Gem (Ruby) — A gem is a packaged Ruby library or application distributed through RubyGems. Gems bundle reusable code, metadata, and dependencies so you can install and share functionality with a single command.
• Generator (Python) — A generator is a function that produces a sequence of values one at a time using yield, instead of building a whole list in memory at once. It is memory-efficient for large or infinite sequences.
• Generic (TypeScript) — A generic is a type that takes another type as a parameter, written in angle brackets like `Array<string>`. Generics let you write reusable code that works with many types while staying type-safe.
• Generic Views (Django) — Generic views are Django's prebuilt class-based views for common tasks: listing objects, showing detail, and creating, updating, or deleting via forms. They handle the boilerplate so you only declare the model and a few options.
• Generics (C#) — Generics let you write classes and methods that work with any type, using a type placeholder in angle brackets like <T>. They give you reusable, type-safe code without sacrificing type checking.
• Generics (Java) — Generics let you write classes and methods that work with any type while keeping type safety. You specify the type in angle brackets, like ArrayList<String>, so the compiler can catch type mistakes early.
• Generics (Kotlin) — Generics let you write classes and functions that work with any type using type parameters like <T>. Kotlin adds declaration-site variance (in/out) to control how generic types relate as subtypes.
• Generics (Rust) — Generics let you write functions, structs, and enums that work over many types using type parameters like <T>. Rust monomorphizes them at compile time, so generic code is as fast as hand-written specialized code.
• get_dummies() (Pandas) — pd.get_dummies() turns a categorical column into one-hot encoded columns — a separate 0/1 (or True/False) indicator column for each distinct category. It is the standard way to prepare categories for machine learning.
• ggplot2 (R) — ggplot2 is R's most popular plotting package, built on the 'grammar of graphics'. You build plots in layers — data, aesthetic mappings, and geometric shapes — combined with the + operator.
• Git — Git is a free, distributed version-control system that tracks changes to files over time, letting many people collaborate on the same project without overwriting each other's work.
• git checkout — git checkout switches between branches or restores files to an earlier state. It moves HEAD to a different branch or commit so your working directory reflects that version.
• git fetch — git fetch downloads new commits and branches from a remote without changing your working files. It updates your local view of the remote so you can inspect changes before merging them.
• git pull — git pull downloads commits from a remote repository and merges them into your current branch in one step. It keeps your local copy up to date with changes others have pushed.
• git push — git push uploads your local commits to a remote repository like GitHub, sharing your work with others. It sends the commits on your current branch to the matching branch on the remote.
• git rebase — Rebasing moves your branch's commits so they start from the tip of another branch, producing a cleaner, linear history. It is an alternative to merging that avoids extra merge commits.
• git stash — git stash temporarily shelves your uncommitted changes so you can switch tasks with a clean working directory, then bring them back later with git stash pop.
• GitHub — GitHub is the most popular website for hosting Git repositories online. It adds collaboration tools on top of Git, such as pull requests, issues, code review, and automated workflows.
• Globals (Node.js) — Node.js globals are objects available everywhere without importing, such as process, console, Buffer, __dirname, setTimeout, and globalThis. They differ from browser globals like window and document.
• Gradient Descent — Gradient descent is the optimization algorithm that trains most machine learning models. It repeatedly adjusts the model's parameters in the direction that reduces the loss (error), step by step.
• grid() (Matplotlib) — ax.grid() draws reference grid lines across a plot at the tick positions, making it easier to read values off the chart. You can toggle it on or off and style the lines.
• Gross Margin — Gross margin is the percentage of revenue left after subtracting the direct cost of delivering a product or service. High gross margins are a hallmark of software businesses.
• GROUP BY — GROUP BY collapses rows that share the same value into a single group, so you can run an aggregate (like COUNT or SUM) on each group separately.
• group_by and summarise (dplyr) (R) — group_by splits a data frame into groups by one or more columns, and summarise collapses each group to summary statistics. Together they perform grouped aggregation — the split-apply-combine pattern.
• groupby() (Pandas) — df.groupby() splits a DataFrame into groups based on the values in one or more columns, so you can apply an aggregation (sum, mean, count) to each group independently. It is pandas' split-apply-combine engine.
• Gunicorn (Flask Deployment) — Gunicorn is a production WSGI server commonly used to run Flask apps. It spawns multiple worker processes to handle requests concurrently, replacing Flask's single-threaded development server, which is not safe for production.
• Hash (Ruby) — A Hash is Ruby's key–value collection (a dictionary or map). You store and look up values by their keys, which are commonly symbols or strings, using curly-brace literals.
• Hash Map — A hash map (also called a dictionary or hash table) stores data as key-value pairs and lets you look up a value by its key almost instantly.
• HashMap (Java) — A HashMap stores data as key–value pairs, letting you look up a value quickly by its key instead of by position. It is Java's equivalent of a Python dictionary or a JavaScript object/Map.
• HashMap<K, V> (Rust) — HashMap<K, V> stores key–value pairs with fast average O(1) lookup by key. It is Rust's standard hash table, equivalent to a dictionary or map in other languages.
• HAVING Clause — HAVING filters the groups created by GROUP BY, keeping only those that meet a condition on an aggregate value. It is like WHERE, but for grouped results.
• HEAD — HEAD is a pointer to the commit you are currently working on — usually the latest commit of your current branch. It tells Git where you are in the project's history.
• head() and tail() (Pandas) — df.head(n) returns the first n rows of a DataFrame or Series and df.tail(n) returns the last n; both default to 5. They are the quickest way to peek at data without printing the whole object.
• Heading Tags (h1–h6) — Heading tags, from <h1> to <h6>, define section titles in order of importance, with <h1> being the most important and <h6> the least. They give a page a clear, hierarchical structure.
• Hex Color — A hex color is a way of specifying a color in CSS using a hash followed by six hexadecimal digits, like #ff0000 for red. The digits encode the red, green, and blue components.
• Higher-Order Function (Kotlin) — A higher-order function is one that takes another function as a parameter or returns a function. Kotlin treats functions as first-class values, which powers its expressive collection and DSL APIs.
• hist() (Matplotlib) — ax.hist() draws a histogram, grouping continuous data into bins and drawing a bar for each bin whose height is the count of values that fell into it. It reveals the distribution of a single variable.
• Hoisting (JavaScript) — Hoisting is JavaScript's behavior of moving function and variable declarations to the top of their scope before the code runs. It lets you call a function declared further down in the file.
• Hook (React) — A Hook is a special React function that lets you 'hook into' React features like state and lifecycle from inside a functional component. Hook names always start with 'use', such as useState and useEffect.
• HTML — HTML (HyperText Markup Language) is the standard language used to structure content on the web. It uses tags to describe elements like headings, paragraphs, links, and images that a browser then renders into a page.
• HTML Attribute — An attribute is extra information added to an HTML tag to configure an element, written as name="value" inside the opening tag. Examples include href on a link and src on an image.
• HTML Element — An HTML element is a single building block of a web page, usually made of an opening tag, content, and a closing tag — for example <p>Hello</p>. Elements describe the meaning and structure of content.
• HTML Form — The <form> element groups input controls so users can submit data, such as a login or contact form. Its action attribute sets where the data is sent and method sets how (GET or POST).
• HTML Lists (ul, ol, li) — HTML lists group related items together. An unordered list <ul> shows bulleted items, an ordered list <ol> shows numbered items, and each item goes inside an <li> element.
• HTML Table — The <table> element displays data in rows and columns. Rows are made with <tr>, header cells with <th>, and data cells with <td>.
• HTML Tag — An HTML tag is the keyword inside angle brackets that marks the start or end of an element, like <p> or </p>. Tags tell the browser where an element begins and ends.
• HTTP Methods (Flask) — In Flask, the methods argument on a route declares which HTTP verbs (GET, POST, PUT, DELETE, etc.) the view accepts. By default a route handles only GET, so you must opt in to POST and others.
• http Module (Node.js) — http is Node.js's built-in module for creating web servers and making HTTP requests, with no dependencies. http.createServer() starts a server that handles incoming requests with (req, res) callbacks.
• if / elif / else (Python) — if, elif, and else let a Python program choose between different blocks of code based on whether conditions are True. elif checks another condition only if the earlier ones were False.
• if / else (C#) — if and else let a C# program choose between blocks of code based on whether a condition is true. else if checks another condition only when the earlier ones were false.
• if Statement (C++) — An if statement runs a block of code only when its condition is true. You can add else if to test more conditions and else to handle everything else.
• if Statement (Java) — An if statement runs a block of code only when a condition is true. With else and else if, a Java program can choose between several different paths.
• Image Tag — The <img> element embeds an image in a page. It is a void (self-closing) element whose src attribute points to the image file and whose alt attribute describes it in text.
• Immutability (Kotlin) — Immutability means data can't change after creation. Kotlin encourages it through read-only val bindings and read-only collection interfaces, making code safer and easier to reason about.
• impl Block (Rust) — An impl block attaches methods and associated functions to a struct, enum, or trait. It is where the behavior of a type lives, separate from the data definition.
• import (Python) — The import statement brings code from another module or library into your file so you can use it. You can import a whole module or specific names from it.
• import / export (JavaScript) — import and export are the keywords that let JavaScript files share code as modules. export makes a value available, and import brings it into another file.
• imshow() (Matplotlib) — ax.imshow() displays a 2-D array (or an image) as a grid of colored pixels, mapping each value to a color via a colormap. It is the standard way to show matrices, heatmaps, and raster images.
• include() (Django URLs) — include() lets a Django URLconf delegate a set of URLs to another app's urls.py. The project's root urls.py uses it to attach each app's routes under a path prefix, keeping URL configuration modular.
• Indentation (Python) — In Python, indentation (the spaces at the start of a line) defines which lines belong to a block of code. Unlike most languages, the whitespace is part of the syntax, not just style.
• Index — An index is the position number used to access a specific item in an array, list, or string. In most languages indexing starts at 0, so the first item is index 0.
• Index (Pandas) — A pandas Index is the immutable array of row or column labels attached to a Series or DataFrame. It powers fast lookups, automatic data alignment, and meaningful row identifiers beyond simple integer positions.
• Index (SQL) — An index is a data structure that speeds up searches on a table, much like the index at the back of a book. It lets the database find rows quickly instead of scanning every row.
• info() (Pandas) — df.info() prints a concise technical summary of a DataFrame: the row count, each column's name, its non-null count, its dtype, and the total memory usage. It is the go-to first look at an unfamiliar dataset.
• Inheritance — Inheritance lets one class (the child) reuse and extend the properties and methods of another class (the parent), avoiding repeated code.
• Inheritance (C#) — Inheritance lets one class (the child) reuse and extend the members of another class (the parent) using a colon. The child gets the parent's fields, properties, and methods automatically.
• Inheritance (C++) — Inheritance lets one class (the derived class) reuse and extend the members of another class (the base class). It models 'is-a' relationships and avoids duplicating code.
• Inheritance (Java) — Inheritance lets one class (the subclass) reuse and extend the fields and methods of another class (the superclass). You set it up with the extends keyword.
• Inheritance (Python) — Inheritance lets one class (the child) reuse and extend the attributes and methods of another class (the parent). You write it by putting the parent class in parentheses after the child's name.
• init Block (Kotlin) — An init block contains initialization code that runs when an instance is created, as part of the primary constructor. It's where you put validation or setup that the primary constructor's parameter list can't express.
• Inline Function (Kotlin) — An inline function has its body (and any lambda arguments) copied directly into the call site by the compiler, eliminating the overhead of creating function objects for the lambdas.
• INNER JOIN — An INNER JOIN returns only the rows that have a match in both tables. Rows with no matching partner in the other table are left out of the result.
• Input Element — The <input> element is a versatile form control for collecting user data. Its type attribute changes what it does — text, email, password, checkbox, radio, number, date, and more.
• Input Validation (Node.js) — Input validation in Node.js checks that request data is present and correctly shaped before you use it. Libraries like Zod, Joi, and express-validator define schemas and reject bad input with clear errors.
• input() (Python) — input() pauses the program and waits for the user to type something, then returns what they typed as a string. You can pass a prompt message to display first.
• INSERT Statement — INSERT adds new rows of data into a table. You name the table and columns, then supply the values for each new row.
• INSTALLED_APPS (Django) — INSTALLED_APPS is the list in settings.py of every app Django should activate, including your own apps and built-in ones like the admin and auth. Django reads it to find models, templates, static files, and management commands.
• int (C#) — int is the C# type for a whole number, such as 5, 0, or -42. It is a 32-bit signed integer, holding values from about -2.1 billion to 2.1 billion.
• int (C++) — int is the C++ type for whole numbers, such as 5, 0, or -42. It is the default choice for counting and integer arithmetic and is typically 32 bits wide.
• int (Java) — int is the most common Java primitive type for whole numbers, such as 5, 0, or -42. It holds a 32-bit signed integer, with a range of about -2.1 billion to 2.1 billion.
• Integer — An integer is a whole number with no fractional part — positive, negative, or zero — such as -3, 0, or 42. It is one of the most common numeric data types.
• Integer (int) (Python) — An integer in Python is a whole number with no decimal point, such as 5, 0, or -42. The type is called int and can hold arbitrarily large values.
• Interface — An interface is a contract that lists the methods a class must provide, without saying how they work. Any class that fulfils it can be used interchangeably.
• Interface (C#) — An interface is a contract that lists method and property signatures a class must implement, without providing the code. It defines what a type can do, not how it does it.
• Interface (Java) — An interface is a contract that lists methods a class must provide, without saying how they work. A class that 'implements' an interface promises to supply a body for each of those methods.
• Interface (TypeScript) — An interface describes the shape of an object — which properties it has and what types they are. It is a contract the compiler checks against, with no effect at runtime.
• Interpreter — An interpreter is a program that reads and executes source code directly, line by line, without compiling it into a separate machine-code file first.
• Intersection Type (TypeScript) — An intersection type combines several types into one using the `&` symbol. The result must satisfy all of the combined types at once, getting every property from each.
• is vs == (Python) — == checks whether two values are equal, while is checks whether two variables point to the exact same object in memory. They are not interchangeable.
• isna() / isnull() (Pandas) — df.isna() returns a boolean DataFrame the same shape as the original, marking True wherever a value is missing (NaN, NaT, or None). isnull() is an exact alias. Use it to detect and count missing data.
• Iteration — Iteration is the process of repeating a set of steps, typically going through each item in a collection one at a time. Each pass through a loop is one iteration.
• Iterator (C++) — An iterator is an object that points to an element in a container and lets you move through the container one element at a time. It works like a generalized pointer.
• Iterator (Rust) — An iterator produces a sequence of values one at a time via its next() method. Rust iterators are lazy and zero-cost — chains of map/filter/etc. compile to code as fast as a hand-written loop.
• Java — Java is a popular, general-purpose programming language known for being object-oriented, statically typed, and 'write once, run anywhere.' Code is compiled to bytecode that runs on the Java Virtual Machine (JVM), so the same program works on any device that has a JVM.
• JDK (Java Development Kit) — The JDK is the full toolkit you install to write and build Java programs. It includes the compiler (javac), the runtime (JRE), and developer tools, so it's everything you need to develop Java software.
• Jinja2 (Flask) — Jinja2 is the templating engine bundled with Flask. It renders HTML files that mix static markup with placeholders like {{ variable }} and logic blocks like {% for %}, filling them with data you pass from your views.
• JOIN (SQL) — A JOIN combines rows from two or more tables based on a related column, usually a foreign key matching a primary key. It lets you pull together data that is spread across tables.
• join() (Pandas) — df.join() combines DataFrames primarily on their index, acting as a convenient shorthand around merge for index-aligned joins. By default it does a left join.
• JRE (Java Runtime Environment) — The JRE is the part of Java needed to run (but not build) Java programs. It bundles the JVM together with the core libraries that compiled Java code depends on.
• JSON (JavaScript Object Notation) — JSON is a lightweight, text-based format for storing and exchanging data using key-value pairs and lists. It is the most common format for sending data between web apps and APIs.
• JSON (JavaScript) — JSON (JavaScript Object Notation) is a lightweight text format for storing and exchanging data. It looks like JavaScript objects and is the standard way APIs send data.
• JSON Body Parsing (Express) — JSON body parsing reads a request's JSON payload into req.body. In Express you enable it with the express.json() middleware; without it, req.body is undefined for JSON requests.
• JSON.parse() & JSON.stringify() (JavaScript) — JSON.parse() turns a JSON string into a JavaScript object, and JSON.stringify() turns a JavaScript value into a JSON string. Together they convert data to and from text.
• jsonify() (Flask) — jsonify() is the Flask helper that turns Python data (dicts, lists) into a JSON HTTP response. It serializes the data and sets the Content-Type header to application/json, which is the right way to return JSON from a view.
• JSX — JSX is a syntax extension for JavaScript that lets you write HTML-like markup directly inside your code. React uses JSX to describe what the UI should look like.
• JVM (Java Virtual Machine) — The JVM is the engine that runs Java programs. It reads the compiled bytecode and executes it on your specific operating system, which is what lets the same Java program run on Windows, macOS, and Linux without changes.
• JWT Authentication (Flask) — JWT (JSON Web Token) authentication in Flask issues a signed token after login that the client sends on each API request (usually in an Authorization: Bearer header). The server verifies the token's signature instead of using cookie sessions.
• JWT Authentication (Node.js) — JWT (JSON Web Token) authentication issues a signed token at login that the client sends on each request (usually in an Authorization: Bearer header). The server verifies the signature instead of keeping session state.
• key Prop — The key prop is a special attribute you give to elements in a list so React can identify which items changed, were added, or were removed. Keys must be unique among siblings and help React update lists efficiently.
• keyof (TypeScript) — The `keyof` operator produces a union of the property names (keys) of a type. For an object type, `keyof T` is a literal union of all its key strings.
• KPI (Key Performance Indicator) — A KPI is a single, measurable number a team tracks to know whether it is hitting its most important goals. Good KPIs are specific, time-bound, and tied to real outcomes.
• Kubernetes (K8s) — Kubernetes is an open-source platform that automates deploying, scaling, and managing containers across many machines. It keeps applications running by restarting failed containers and balancing load.
• Label (Target) — A label is the correct answer attached to a training example — the thing a supervised model is trying to predict, such as 'spam' or a house's actual price.
• Lambda (Kotlin) — A lambda is an anonymous function written in braces, like { x -> x + 1 }. Lambdas are the values you pass to higher-order functions and are the backbone of Kotlin's collection operations.
• Lambda (Python) — A lambda is a small, anonymous function written in a single line. It is handy for short throwaway functions, often passed to sorted(), map(), or filter().
• Lambda (Ruby) — A lambda is a Proc-like object that checks its argument count strictly and returns only from itself. Written with ->(x) { ... } or lambda { ... }, it behaves more like a normal method than a plain Proc.
• Lambda Expression (C#) — A lambda is a short, anonymous function written inline with the => arrow. It is widely used to pass small bits of behavior to LINQ methods, delegates, and event handlers.
• Lambda Expression (Java) — A lambda expression is a short, anonymous block of code you can pass around like a value, written with the -> arrow. It is a concise way to provide the single method of a functional interface.
• Large Language Model (LLM) — A large language model is a neural network trained on huge amounts of text to understand and generate human language. It predicts the next word (token) in a sequence, which lets it answer questions, write, and converse.
• Learning Rate — The learning rate is a setting that controls how big a step a model takes when updating its parameters during training. It is one of the most important hyperparameters to tune.
• LEFT JOIN — A LEFT JOIN returns every row from the left (first) table, plus matching rows from the right table. Where there is no match, the right table's columns come back as NULL.
• legend() (Matplotlib) — ax.legend() adds a key to a plot that maps each line, marker, or bar to its label, so readers can tell multiple series apart. It uses the label you assigned to each plotted element.
• len() (Python) — len() is a built-in function that returns the number of items in an object — the number of characters in a string, or the number of elements in a list, tuple, set, or dictionary.
• let & const (JavaScript) — let and const are the modern ways to declare variables in JavaScript. Use const for values that never change and let for values that do.
• Library — A library is a collection of pre-written code you can import and use in your own program, so you do not have to build common features from scratch.
• library() and Packages (R) — A package is a bundle of R functions, data, and documentation. You install one once with install.packages() and load it into a session with library() to use its functions.
• Lifetime (Rust) — A lifetime is the scope for which a reference is valid. Lifetime annotations like 'a tell the compiler how the lifetimes of multiple references relate so it can guarantee no reference outlives its data.
• Lifting State Up — Lifting state up is moving shared state to the closest common parent of the components that need it, then passing it down as props. It lets sibling components stay in sync through a single source of truth.
• linalg (Linear Algebra) (NumPy) — np.linalg is NumPy's linear algebra module, providing functions to invert matrices, compute determinants, solve systems of equations, and find eigenvalues, norms, and decompositions. It wraps the battle-tested LAPACK library.
• Linear Regression — Linear regression is a simple machine learning model that predicts a number by fitting a straight line through the data, assuming the output changes proportionally with the inputs.
• Linked List — A linked list is a data structure made of nodes, where each node holds a value and a reference (pointer) to the next node, forming a chain.
• LINQ (C#) — LINQ (Language Integrated Query) is a C# feature for querying and transforming collections using readable operations such as Where, Select, and OrderBy. It works on arrays, lists, databases, and more.
• linspace() (NumPy) — np.linspace() returns a 1-D array of evenly spaced numbers over a closed interval, where you specify how many points you want rather than the step size. By default it includes both endpoints.
• List (Python) — A Python list is an ordered, changeable collection of items written in square brackets. It is Python's version of an array and can hold mixed types.
• List (R) — A list is R's flexible container that can hold elements of different types and lengths — including other lists, vectors, data frames, and functions. Unlike a vector, its elements need not share a type.
• List Comprehension (Python) — A list comprehension is a concise, one-line way to build a new list by transforming or filtering an existing iterable.
• List Rendering — List rendering is displaying an array of data as repeated elements in React, typically by calling .map() to turn each item into a piece of JSX. Each rendered item should get a unique key prop.
• List<T> (C#) — A List<T> is C#'s resizable array — an ordered collection of items of type T that can grow and shrink. You add items with .Add() and access them by zero-based index.
• ListView & DetailView (Django) — ListView and DetailView are Django's most-used generic views. ListView renders a list of objects (with built-in pagination), and DetailView renders a single object looked up by primary key or slug from the URL.
• Literal Type (TypeScript) — A literal type is a type that allows only one exact value, such as the string `"left"` or the number `42`. Combined with unions, literal types restrict a value to a small set of allowed options.
• lm() (Linear Model) (R) — lm() fits a linear regression model in R using a formula and a data frame. It is the foundational function for modeling a numeric response as a linear combination of predictors.
• localStorage (JavaScript) — localStorage lets a website save key/value data in the browser that persists even after the page is closed. Values are always stored as strings.
• Logging (Node.js) — Logging in Node.js records what your app does for debugging and monitoring. console works for development, while structured loggers like Winston and Pino add log levels, timestamps, and JSON output for production.
• login_required (Flask-Login) — login_required is a Flask-Login decorator that protects a view so only authenticated users can reach it. Anonymous visitors are redirected to the configured login page instead of seeing the protected content.
• Logistic Regression — Logistic regression is a classification model that predicts the probability an input belongs to a class, outputting a value between 0 and 1 that is then turned into a yes/no decision.
• Loop — A loop is a control structure that repeats a block of code multiple times, usually until a condition is met. Common types are for loops and while loops.
• Loss Function — A loss function measures how wrong a model's predictions are compared to the correct answers. Training works by adjusting the model to make this loss as small as possible.
• LTV (Lifetime Value) — LTV is the total revenue a business expects from a single customer over the whole time they stay a customer.
• LTV:CAC Ratio — The LTV:CAC ratio compares how much a customer is worth (LTV) to how much it costs to acquire them (CAC). A ratio of 3:1 or higher is generally considered healthy.
• Machine Learning (ML) — Machine learning is a branch of AI where a computer learns patterns from data and makes predictions, instead of being given explicit step-by-step instructions for every case.
• main Method (Java) — The main method is the entry point of a Java program — the first method the JVM runs when you start an application. It always has the signature public static void main(String[] args).
• makemigrations vs migrate (Django) — makemigrations and migrate are the two Django commands that manage schema changes. makemigrations generates migration files from your model changes; migrate applies those files to the actual database. You almost always run them in that order.
• Management Commands (Django) — Management commands are the subcommands you run with python manage.py, such as runserver, migrate, and createsuperuser. You can also write your own custom commands for tasks like data imports or scheduled jobs.
• Manager (Django) — A Manager is the interface through which Django models run database queries; the default one is named objects. You can write custom managers to add table-level query methods like Post.objects.published().
• ManyToManyField (Django) — A ManyToManyField models a many-to-many relationship, where each row on both sides can relate to many on the other — for example posts and tags. Django creates a hidden join table to store the links.
• map() (Pandas) — Series.map() substitutes or transforms each value in a Series, using a function, a dict, or another Series as the lookup. It is the simplest way to recode categories or apply a per-element transform.
• map() (Python) — map() applies a function to every item in a sequence and returns the results. It transforms a whole iterable without writing an explicit loop.
• Mapped Type (TypeScript) — A mapped type builds a new type by transforming each property of an existing one, using a `[K in keyof T]` loop in the type system. It is how you generate types programmatically.
• Margin (CSS) — Margin is the transparent space outside an element's border that pushes it away from neighboring elements. It is the outermost layer of the CSS box model.
• Marshmallow (Flask) — Marshmallow is a serialization and validation library used with Flask to convert between complex objects (like database models) and simple types (dicts/JSON). Schemas declare which fields to expose and how to validate incoming data.
• match Expression (Rust) — match compares a value against a series of patterns and runs the arm of the first one that fits. It is an expression (returns a value) and must be exhaustive — every possible case has to be covered.
• Matrix (R) — A matrix is a two-dimensional, rectangular array in R where every element is the same type. It is a vector with a dim (dimension) attribute giving it rows and columns.
• Matrix Operations (NumPy) — Matrix operations in NumPy include multiplication with @, transposition with .T, inversion and solving via np.linalg, and the crucial distinction between element-wise (*) and matrix (@) products.
• Media Query — A media query is a CSS feature that applies styles only when certain conditions are met, most often the width of the screen. It is the main tool for making pages responsive.
• melt() (Pandas) — pd.melt() reshapes a wide DataFrame into a long, tidy one by collapsing several columns into two: a 'variable' column holding the old column names and a 'value' column holding their values.
• Memory Management (C++) — Memory management in C++ is how a program allocates and releases memory. Unlike garbage-collected languages, C++ gives you direct control, dividing memory between the stack and the heap.
• Merge — Merging combines the changes from one branch into another, typically bringing a finished feature branch back into main. Git joins the two histories into a single line of work.
• Merge Conflict — A merge conflict happens when Git can't automatically combine two branches because the same lines of a file were changed differently in each. You must edit the file to choose the correct result.
• merge() (Pandas) — pd.merge() combines two DataFrames by matching values in one or more key columns, exactly like a SQL JOIN. It is how you bring related tables together on shared keys.
• meshgrid() (NumPy) — np.meshgrid() takes 1-D coordinate arrays and returns 2-D coordinate matrices covering every combination, so you can evaluate functions or plot surfaces over a 2-D grid of points.
• Metaprogramming (Ruby) — Metaprogramming is writing code that writes or modifies code at runtime — defining methods, opening classes, and responding to messages dynamically. Ruby's openness makes it a metaprogramming powerhouse.
• Method (C#) — A method is a named, reusable block of code inside a class that performs a task. You define its return type and parameters, then call it by name to run its code.
• Method (Java) — A method is a reusable, named block of code that performs a task. It belongs to a class, can take inputs called parameters, and can return a value.
• method_missing (Ruby) — method_missing is a hook Ruby calls when an object receives a message it has no method for. Overriding it lets you handle arbitrary, undefined method calls dynamically — a key metaprogramming tool.
• Middleware (Django) — Middleware in Django is a layer of hooks that process every request and response as they pass through the framework. Listed in the MIDDLEWARE setting, each one can inspect, modify, or short-circuit the request/response flow.
• Middleware (Express) — Middleware in Express is a function that runs during request handling, receiving (req, res, next). It can inspect or modify the request and response, end the response, or call next() to pass control to the next middleware.
• Middleware (WSGI) (Flask) — Middleware in Flask is WSGI middleware: a wrapper around the entire application that processes every request and response at the server level, below Flask's routing. It is used for concerns like proxy handling, compression, or request profiling.
• Migration (Django) — A Django migration is a versioned file that records a change to your database schema, derived from changes to your models. Migrations let you evolve the database over time in a controlled, repeatable, reversible way.
• Mixin (Ruby) — A mixin is a module of methods included into a class to share behavior without inheritance. Ruby uses mixins via include and extend to compose functionality across unrelated classes.
• Model — A model is the output of a machine learning algorithm after it has been trained on data. It captures the learned patterns and is what you use to make predictions on new inputs.
• Model (Django) — A Django model is a Python class that subclasses django.db.models.Model and represents a database table. Each class attribute is a field (a column), and Django generates the SQL schema and an ORM API from it.
• Model (Flask-SQLAlchemy) — A model in Flask-SQLAlchemy is a Python class that subclasses db.Model and maps to a database table. Each class attribute defined as a db.Column becomes a column, and each instance becomes a row.
• Model Evaluation — Model evaluation is the process of measuring how well a trained machine learning model performs, using held-out test data and metrics like accuracy, precision, recall, or error.
• Model Fields (Django) — Model fields are the typed attributes on a Django model that map to database columns, like CharField, IntegerField, BooleanField, and DateTimeField. Each field type sets the column's data type, validation, and form widget.
• Model Methods & __str__ (Django) — Model methods add behavior to a Django model alongside its data. Common ones are __str__ (the object's readable name), get_absolute_url (its canonical URL), and custom methods that compute or act on the instance's data.
• Model Relationships (Django) — Django models relate to each other in three ways: ForeignKey (many-to-one), ManyToManyField (many-to-many), and OneToOneField (one-to-one). These fields let you navigate between related objects in Python without writing JOINs.
• ModelForm (Django) — A ModelForm is a Django form generated automatically from a model. It builds form fields from the model's fields and adds a save() method that creates or updates a database row, eliminating duplicate field declarations.
• Module (mod) (Rust) — A module organizes code within a crate into named, nestable namespaces. Modules control visibility — items are private by default and exposed with the pub keyword.
• Module (Python) — A module is simply a Python file (ending in .py) that contains code you can reuse in other files. Importing a module gives you access to its functions, classes, and variables.
• Module (Ruby) — A module is a container for methods and constants that can't be instantiated. Modules serve two roles in Ruby: as namespaces to group related code, and as mixins to share behavior across classes.
• Module & require() (Node.js) — A module in Node.js is a file of JavaScript whose variables are private unless explicitly exported. require() loads another module and returns what it exports, letting you split a program across files.
• Module Caching (Node.js) — Node.js caches each module the first time it is required, so subsequent require() calls return the same exported object without re-running the file. This makes modules effectively singletons within a process.
• Monetization — Monetization is the way a product turns its users or audience into revenue — through subscriptions, ads, one-time purchases, transaction fees, or upsells.
• Mongoose (Node.js) — Mongoose is an Object Data Modeling (ODM) library for MongoDB in Node.js. It defines schemas for your documents, gives models a clean query API, and adds validation and middleware on top of the MongoDB driver.
• Monkey Patching (Ruby) — Monkey patching is reopening an existing class — even a built-in one like String or Integer — to add or change methods at runtime. It's powerful Ruby flexibility that must be used with care.
• Move Semantics (C++) — Move semantics let C++ transfer a resource from one object to another instead of copying it, which is faster for large objects. It was introduced in C++11 with rvalue references.
• Move Semantics (Rust) — A move transfers ownership of a value from one variable to another. After a move the original variable is invalidated, so using it is a compile-time error. Moves are how Rust avoids copying heap data.
• MRR (Monthly Recurring Revenue) — MRR is the predictable revenue a subscription business earns each month. It is a core health metric for SaaS companies.
• MTV Architecture (Django) — MTV (Model-Template-View) is Django's take on the MVC pattern. The Model handles data, the Template handles presentation, and the View holds the logic that ties them together — what other frameworks call the controller.
• MultiIndex (Pandas) — A MultiIndex is a hierarchical, multi-level index that lets a single axis carry two or more label levels at once, so you can represent higher-dimensional data inside a flat 2-D DataFrame.
• Mutability (mut) (Rust) — In Rust variables are immutable by default. The mut keyword makes a variable (or a reference) mutable so you can change its value after binding it.
• Mutable vs Immutable — A mutable value can be changed after it is created; an immutable value cannot. For example, lists are mutable in Python, while strings and tuples are immutable.
• mutate, filter, and select (dplyr) (R) — mutate adds or changes columns, filter keeps rows matching a condition, and select chooses columns. These three dplyr verbs handle the most common data-frame transformations.
• Mutex<T> (Rust) — Mutex<T> guards data behind a lock so only one thread can access it at a time. In Rust the data lives inside the mutex, so the type system makes it impossible to touch the data without locking first.
• MVP (Minimum Viable Product) — An MVP is the simplest version of a product that still delivers value, built quickly to test an idea before investing heavily.
• NA (Missing Values) (R) — NA is R's marker for a missing or unavailable value. It is contagious: most operations involving an NA return NA, so missing data is never silently ignored.
• Named Arguments (R) — Named arguments let you pass values to a function by name (arg = value) instead of by position. R matches named arguments first, then fills the rest by position, and supports partial name matching.
• Namespace — A namespace is a container that groups names (like variables and functions) so identical names in different namespaces do not collide.
• Namespace (C#) — A namespace is a named container that groups related classes and other types to keep code organized and avoid name clashes. The .NET library itself is organized into namespaces like System and System.Collections.
• Namespace (C++) — A namespace groups related names (functions, classes, variables) under a label to prevent naming collisions. The standard library lives in the std namespace, which is why you write std::cout.
• NaN (JavaScript) — NaN stands for "Not a Number" and is the value JavaScript returns when a math operation fails to produce a valid number. It is itself of type number.
• NaN (Pandas) — NaN ('Not a Number') is pandas' marker for a missing or undefined value. It is a special floating-point value that is not equal to anything, even itself, so missing data must be detected with isna(), not ==.
• NaN and inf (NumPy) — np.nan represents a missing or undefined floating-point value ('Not a Number'), and np.inf represents infinity. Both arise from floating-point math and need special functions like np.isnan and np.isinf to detect.
• Natural Language Processing (NLP) — Natural language processing is the field of AI focused on enabling computers to understand, interpret, and generate human language — text and speech.
• ndarray (NumPy) — The ndarray is NumPy's core object: an N-dimensional, fixed-size array of elements that all share one data type, stored in a contiguous block of memory. It is the foundation that the entire scientific Python stack is built on.
• Neural Network — A neural network is a machine learning model loosely inspired by the brain. It is made of layers of connected 'neurons' that pass numbers forward, multiplying them by adjustable weights to produce a prediction.
• never (TypeScript) — `never` is the type of values that never occur. It is the return type of functions that never finish normally — those that always throw or loop forever — and the type of impossible cases.
• new and delete (C++) — new allocates memory on the heap at runtime and returns a pointer to it, while delete frees that memory. Every new must be matched by exactly one delete, or you get a memory leak.
• nil (Ruby) — nil is Ruby's representation of 'nothing' or 'no value' — the sole instance of NilClass. It is one of only two falsy values in Ruby (the other is false).
• node_modules (Node.js) — node_modules is the folder where npm installs a project's dependencies. Node looks here to resolve package imports, and the folder is generated from package.json rather than committed to source control.
• Node.js Runtime — Node.js is a runtime that runs JavaScript outside the browser, on the server and in tools. Built on Chrome's V8 engine, it adds APIs for files, networking, and processes so JavaScript can build backends and CLI programs.
• nodemon (Node.js) — nodemon is a development tool that watches your project files and automatically restarts your Node.js app whenever you save a change. It removes the need to manually stop and restart the server during development.
• Non-Blocking I/O (Node.js) — Non-blocking I/O means Node.js starts an I/O operation (file read, network request) and continues running other code instead of waiting for it to finish. The result arrives later via a callback, Promise, or await.
• None (Python) — None is Python's special value that represents the absence of a value or 'nothing.' It is the object returned by functions that don't explicitly return anything.
• Normalization — Normalization is the process of organizing a database into multiple related tables to reduce duplicate data and avoid inconsistencies. It splits data so each fact is stored in just one place.
• Not-Null Assertion (!!) (Kotlin) — The !! operator forcibly converts a nullable value to its non-null type, throwing a NullPointerException at runtime if the value actually is null. Use it only when you're certain it isn't null.
• npm (JavaScript) — npm (Node Package Manager) is the tool and registry for installing and managing reusable JavaScript packages. It comes bundled with Node.js.
• npm (Node Package Manager) — npm is the default package manager for Node.js. It installs third-party packages from the npm registry into node_modules, tracks them in package.json, and runs project scripts like build and test.
• NPS (Net Promoter Score) — NPS measures customer loyalty by asking one question: 'How likely are you to recommend us?' on a 0–10 scale. The score ranges from −100 to +100.
• npx (Node.js) — npx is a tool bundled with npm that runs a package's command without installing it globally. It downloads the package on demand (or uses a local copy), executes it, and is ideal for one-off CLI tools and scaffolders.
• NULL (SQL) — NULL represents missing or unknown data in a database — it means 'no value here.' It is not zero and not an empty string; it is the absence of any value.
• Null Safety (Kotlin) — Null safety is Kotlin's type-system feature that distinguishes nullable types (String?) from non-nullable ones (String), eliminating most NullPointerExceptions at compile time.
• null vs undefined (JavaScript) — undefined means a variable has been declared but no value assigned, while null is a value you deliberately set to mean "empty" or "no value". Both represent absence.
• Nullable Type (?) (Kotlin) — A nullable type is a type marked with a trailing ? (like Int? or String?) that is allowed to hold null. Without the ?, a Kotlin type can never be null.
• Nullish Coalescing (JavaScript) — The nullish coalescing operator (??) returns its right-hand value only when the left-hand value is null or undefined. It is a safer default than ||.
• NumPy — NumPy is the core Python library for numerical computing. It provides fast, multi-dimensional arrays and math operations that power nearly all data science and machine learning tools.
• Object — An object groups related data (properties) and actions (methods) together into a single value, often modelling a real-world thing.
• Object (C#) — An object is a concrete instance of a class, created at runtime with the new keyword. While a class is the blueprint, an object is an actual thing built from it that holds its own data.
• Object (C++) — An object is a concrete instance of a class — a specific thing created from the class blueprint, with its own copy of the data. You call its member functions to make it do work.
• Object (Java) — An object is a specific instance created from a class. The class is the blueprint; the object is the actual thing built from it, with its own copy of the class's fields.
• Object (JavaScript) — An object is a collection of related data stored as key/value pairs. Objects are the main way JavaScript groups properties and behavior together.
• object & companion object (Kotlin) — The object keyword declares a singleton — a class with exactly one instance. A companion object is a singleton tied to a class, holding factory methods and constants like static members in Java.
• Object-Oriented vs pyplot Interface (Matplotlib) — Matplotlib offers two ways to plot: the object-oriented (OO) interface, where you call methods on explicit Figure and Axes objects, and the pyplot interface, where stateful plt functions act on a 'current' figure for you.
• open() / Files (Python) — open() is the built-in function for reading from and writing to files. You give it a filename and a mode ('r' to read, 'w' to write, 'a' to append).
• Operator — An operator is a symbol that performs an action on values, such as + for addition, == for comparison, or && for logical AND.
• Operator Overloading (C++) — Operator overloading lets you define how built-in operators like +, ==, or << behave for your own types. This makes custom classes feel as natural to use as built-in types.
• Option<T> (Rust) — Option<T> is Rust's replacement for null. It is an enum with two variants: Some(value) when a value is present, and None when it is absent. The compiler forces you to handle the missing case.
• Optional Chaining (JavaScript) — Optional chaining (?.) safely reads deeply nested properties. If a value in the chain is null or undefined, it returns undefined instead of throwing an error.
• Optional Property (TypeScript) — An optional property is one that may or may not be present on an object, marked with a `?` after its name. If you leave it out, its value is `undefined` rather than an error.
• ORDER BY — ORDER BY sorts the rows a query returns by one or more columns. By default it sorts ascending (smallest first); add DESC to sort descending.
• Origin — Origin is the default name Git gives to the remote repository you cloned from. It is just a convenient label for that remote's URL, used in commands like git push origin main.
• ORM (Django) — Django's ORM (Object-Relational Mapper) lets you work with the database using Python objects instead of SQL. You query, create, update, and delete rows through model classes, and Django translates it into SQL for your database.
• ORM Relationships (Flask-SQLAlchemy) — Relationships in Flask-SQLAlchemy connect models together — one-to-many, one-to-one, and many-to-many — so you can navigate from one object to its related objects in Python, like user.posts, without writing JOIN SQL.
• Overfitting — Overfitting happens when a model learns the training data too well — including its noise and quirks — so it performs great on training data but poorly on new, unseen data.
• Ownership (Rust) — Ownership is Rust's core memory-management rule: every value has exactly one owner variable, and when that owner goes out of scope the value is automatically freed. No garbage collector, no manual free().
• package.json (Node.js) — package.json is the manifest file at the root of a Node.js project. It records the project's name, version, dependencies, scripts, and metadata, and it is what npm reads to install packages and run commands.
• Padding (CSS) — Padding is the space between an element's content and its border, inside the box. It pushes the content inward, away from the edges.
• Pagination (Django) — Pagination splits a long list of results into pages in Django. The Paginator class powers function-based and template paging, ListView offers paginate_by, and DRF provides pagination classes for APIs.
• Pagination (Flask-SQLAlchemy) — Pagination splits a large result set into pages so you fetch and display only a slice at a time. Flask-SQLAlchemy provides a paginate() method that returns a page of items plus navigation info like total pages and next/prev.
• pandas — pandas is a popular Python library for working with structured, table-like data. It provides the DataFrame, making it easy to load, clean, transform, and analyze datasets.
• panic! (Rust) — panic! aborts the current thread with an error message when the program reaches an unrecoverable state. It unwinds the stack (running destructors) and, by default, prints a message and backtrace.
• Paragraph Tag — The <p> element defines a paragraph of text. Browsers automatically add space above and below each paragraph to separate it from surrounding content.
• Parameter vs Argument — A parameter is the named placeholder listed in a function's definition; an argument is the actual value you pass in when you call that function.
• path Module (Node.js) — path is Node.js's built-in module for working with file and directory paths in a cross-platform way. It joins, resolves, and parses paths using the correct separator for the operating system.
• Pattern Matching (case/in) (Ruby) — Pattern matching, added in Ruby 3.0, uses case/in to destructure and match data structures by shape. It can deconstruct arrays and hashes, bind variables, and add guards in one expression.
• Pattern Matching (Rust) — Pattern matching destructures values to test their shape and bind their parts to variables. It powers match, if let, while let, and even let and function parameters in Rust.
• PEP 8 (Python) — PEP 8 is the official style guide for writing Python code. It sets conventions for things like indentation, naming, spacing, and line length to keep code consistent and readable.
• Permissions (Django) — Permissions in Django control what an authenticated user is allowed to do. The framework auto-creates add/change/delete/view permissions per model, and you check them with user.has_perm() or the permission_required decorator.
• pie() (Matplotlib) — ax.pie() draws a pie chart, dividing a circle into wedges whose angles are proportional to each value's share of the total. It shows how parts make up a whole.
• pip (Python) — pip is Python's package installer, the command-line tool used to download and install third-party libraries from the Python Package Index (PyPI). You run it from your terminal, not inside Python code.
• Pipe Operator (%>% and |>) (R) — The pipe operator passes the result on its left into the next function on its right, letting you chain operations left-to-right. R has the magrittr pipe %>% and the native base-R pipe |>.
• Pipeline — A pipeline is an automated sequence of steps that takes code from commit to production — typically building, testing, and deploying it. Pipelines are the backbone of CI/CD.
• pivot_table() (Pandas) — df.pivot_table() reshapes long data into a wide summary grid, spreading unique values of one column across the columns and aggregating the values in between. It is the spreadsheet PivotTable, in code.
• plot() (Matplotlib) — ax.plot() draws a line plot, connecting (x, y) data points with line segments. It is the most fundamental Matplotlib chart, used for trends, time series, and any data where order along x matters.
• PM2 (Node.js) — PM2 is a production process manager for Node.js. It keeps your app running by restarting it if it crashes, runs multiple instances across CPU cores for load balancing, manages logs, and survives server reboots.
• Pointer — A pointer is a variable that stores the memory address of another value, rather than the value itself. It 'points to' where the data lives in memory.
• Pointer (C++) — A pointer is a variable that stores the memory address of another value rather than the value itself. You use * to declare a pointer and to read the value it points to, and & to get an address.
• Polymorphism — Polymorphism lets different classes respond to the same method call in their own way, so one piece of code can work with many object types.
• Polymorphism (Java) — Polymorphism means 'many forms' — the ability to treat objects of different classes through a shared parent type, where each object responds in its own way. The right method runs based on the object's actual type at runtime.
• Position (CSS) — The CSS position property controls how an element is placed in the document and whether it responds to the top, right, bottom, and left offsets. Its values are static, relative, absolute, fixed, and sticky.
• Precision and Recall — Precision and recall are two metrics for evaluating classification, especially on imbalanced data. Precision asks 'of the items we flagged, how many were right?' and recall asks 'of all the real positives, how many did we catch?'
• Primary Constructor (Kotlin) — The primary constructor is the concise constructor declared in a class's header, right after its name. Prefixing its parameters with val or var turns them into properties in one line.
• Primary Key — A primary key is a column (or set of columns) that uniquely identifies each row in a table. No two rows can share the same primary key, and it can never be NULL.
• Primitive Type (Java) — Primitive types are Java's eight built-in basic data types that store simple values directly, not as objects. They are byte, short, int, long, float, double, char, and boolean.
• print() (Python) — print() is Python's built-in function for displaying output to the console (terminal). It shows whatever you pass it as text and adds a new line at the end.
• private (Java) — private is an access modifier that restricts a field or method so it can only be used inside its own class. It is the foundation of encapsulation, hiding internal details from the rest of the program.
• Proc (Ruby) — A Proc is a block turned into an object you can store in a variable, pass around, and call later with .call. Unlike a block, a Proc is a first-class value.
• process Object (Node.js) — process is a global object in Node.js that gives information about and control over the current Node process. It exposes environment variables, command-line arguments, the standard streams, and lifecycle events like exit.
• Product-Market Fit — Product-market fit (PMF) is the point where a product satisfies a strong market demand so well that customers adopt it eagerly and growth feels easy.
• Project vs App (Django) — In Django, a project is the whole website and its settings, while an app is a self-contained module providing one feature (like a blog or auth). A project contains many apps, and a good app can be reused across projects.
• Promise (JavaScript) — A Promise represents a value that will be ready in the future, such as the result of a network request. It can be pending, fulfilled, or rejected.
• Promise (Node.js) — A Promise represents the eventual result of an asynchronous operation. It starts pending and later settles as fulfilled (with a value) or rejected (with an error), and you react with .then(), .catch(), and .finally().
• Properties (Kotlin) — A property is a class member that holds state, declared with val or var. Kotlin properties come with auto-generated getters/setters and support custom accessors and lazy initialization.
• Property (C#) — A property is a class member that looks like a field but uses get and set accessors to control reading and writing its value. Properties are the standard way to expose data in C#.
• Props — Props (short for properties) are the inputs you pass into a React component, like attributes on an HTML tag. They let a parent component send data down to a child, and they are read-only inside the child.
• Prototype (JavaScript) — A prototype is the object that another object inherits properties and methods from. JavaScript uses prototype-based inheritance instead of classical classes under the hood.
• Pseudo-class — A CSS pseudo-class targets elements in a particular state, written with a single colon, like :hover or :focus. It lets you style how elements look when users interact with them.
• Pseudo-element — A CSS pseudo-element styles a specific part of an element, written with two colons, like ::before or ::first-line. It can also insert generated content that isn't in the HTML.
• Pseudocode — Pseudocode is a plain-language, informal description of an algorithm's steps. It is not real code and cannot run, but it helps plan logic before writing it.
• public (Java) — public is an access modifier that makes a class, method, or field visible and usable from any other class in the program. It is the least restrictive level of access.
• Pull Request (PR) — A pull request is a proposal on a hosting service like GitHub to merge changes from one branch into another. It lets teammates review, discuss, and approve code before it is merged.
• pyplot (Matplotlib) — pyplot is Matplotlib's MATLAB-style interface, imported as plt, that provides simple functions like plt.plot() and plt.show(). It keeps track of a 'current' figure and axes so you can plot with minimal setup.
• Q Object (Django) — A Q object lets you build complex database queries with OR, AND, and NOT logic in the Django ORM. Plain filter() arguments are always ANDed together, so you use Q to express conditions like 'A or B'.
• Query API (Flask-SQLAlchemy) — The Flask-SQLAlchemy Query API is the chainable interface for retrieving and filtering rows. Methods like filter(), filter_by(), order_by(), join(), limit(), and offset() build a query lazily; terminal methods like all() and first() run it.
• Query Performance / N+1 (Django) — Query performance in Django is mostly about reducing the number of database queries. The classic pitfall is the N+1 problem, where iterating objects fires one extra query per related access; fixes include select_related and only().
• query() (Pandas) — df.query() filters a DataFrame using a string expression, letting you write the condition in a compact, SQL-like form such as "age > 30 and city == 'NYC'" instead of repeating the DataFrame name.
• Querying the Database (Flask-SQLAlchemy) — Querying in Flask-SQLAlchemy retrieves rows as Python objects. The classic style uses Model.query with filters like filter_by() and methods like all(), first(), and get(); newer code uses db.session.execute(select(...)).
• querySelector() (JavaScript) — document.querySelector() finds the first element on the page that matches a CSS selector. It is the standard way to grab an element so JavaScript can work with it.
• QuerySet (Django) — A QuerySet is Django's representation of a database query as a collection of model objects. It is lazy — no SQL runs until you iterate, slice, or evaluate it — and chainable, so filters build up a single query.
• Queue — A queue is a data structure where items are added at one end and removed from the other, following First-In-First-Out (FIFO) order — like a line at a shop.
• RAII (C++) — RAII (Resource Acquisition Is Initialization) is a C++ idiom where a resource's lifetime is tied to an object's lifetime. The object acquires the resource in its constructor and releases it in its destructor.
• raise (Python) — The raise statement deliberately triggers an exception, signaling that something has gone wrong. It is used to enforce rules or report invalid input in your own code.
• Random Forest — A random forest is a machine learning model that combines many decision trees and averages their predictions, producing results that are usually more accurate and less prone to overfitting than a single tree.
• random Generator (NumPy) — The modern NumPy random API is built around a Generator object, created with np.random.default_rng(). You call methods on it — integers, random, normal, choice, shuffle — to produce random numbers reproducibly.
• Random Seed (NumPy) — A seed is the starting value that initializes NumPy's random number generator. Setting the same seed makes the 'random' sequence reproducible, so your results can be repeated exactly on every run.
• range() (Python) — range() generates a sequence of numbers, most often used to control how many times a for loop runs. It produces numbers on demand rather than storing them all in memory.
• Ranges (Kotlin) — A range is a sequence of values between a start and end, created with operators like 1..10 (inclusive). Ranges support iteration, membership tests with in, and stepping or counting down.
• ravel() and flatten() (NumPy) — Both ravel() and flatten() collapse a multi-dimensional array into a 1-D array. The key difference is that ravel() returns a view of the original data when possible, while flatten() always returns an independent copy.
• Rc<T> (Rust) — Rc<T> is a reference-counted smart pointer for shared ownership in a single thread. Multiple Rc handles can own the same value; the data is dropped when the last one goes away.
• rcParams (Matplotlib) — rcParams is Matplotlib's global dictionary of default settings, controlling things like default figure size, font size, line width, and color cycle. Changing it alters the defaults for every plot you make afterward.
• React — React is a popular JavaScript library for building user interfaces out of reusable components. It lets you describe what the screen should look like for any given data, and updates the page efficiently when that data changes.
• React Router — React Router is the most popular library for adding client-side routing to a React app, letting you map URLs to different components so users can navigate between 'pages' without full page reloads.
• read_csv() (Pandas) — pd.read_csv() reads a comma-separated values file (or any delimited text) into a DataFrame. It is the most common way to load tabular data into pandas from disk or a URL.
• read.csv() (R) — read.csv() loads a comma-separated values file into a data frame. It is the standard base-R way to import tabular data, with options for headers, separators, and type handling.
• readonly (TypeScript) — `readonly` marks a property so it can be set once but never changed afterward. Trying to reassign it is a compile error, which protects values that shouldn't be mutated.
• Recursion — Recursion is when a function calls itself to solve a problem by breaking it into smaller sub-problems. It needs a base case to stop.
• Recycling (R) — Recycling is R's rule for combining vectors of different lengths: the shorter vector is repeated (recycled) to match the longer one's length during element-wise operations.
• redirect() (Flask) — redirect() returns an HTTP redirect response that tells the browser to go to a different URL. In Flask it is almost always paired with url_for() so you redirect to a view by name rather than a literal path.
• reduce / inject (Ruby) — reduce (alias inject) combines all elements of a collection into a single value by repeatedly applying a block, carrying an accumulator. It's used for sums, products, and other aggregations.
• Refactoring — Refactoring is improving the internal structure of existing code without changing what it does — making it cleaner, simpler, and easier to maintain.
• RefCell<T> (Rust) — RefCell<T> provides interior mutability: it lets you mutate data through a shared reference by moving Rust's borrow checking from compile time to runtime. Borrow rules are still enforced — violations panic.
• Reference — A reference is a value that points to an object stored elsewhere in memory, rather than holding a copy of it. Two variables can reference the same object.
• Reference (C++) — A reference is an alias — another name for an existing variable. Once bound, it always refers to the same variable, so changing the reference changes the original.
• References (& and &mut) (Rust) — A reference is a pointer to a value that you can read (&T) or modify (&mut T) without owning it. References are guaranteed by the compiler to always point to valid data.
• Regression — Regression is a supervised learning task where a model predicts a continuous number, such as a house price, a temperature, or someone's age.
• Regular Expression (JavaScript) — A regular expression (regex) is a pattern used to search, match, and replace text. In JavaScript you write them between slashes, like /pattern/.
• Reinforcement Learning (RL) — Reinforcement learning is a type of machine learning where an agent learns by trial and error, taking actions in an environment and receiving rewards or penalties, then adjusting to maximize total reward.
• Remote — A remote is a version of your repository hosted somewhere else, such as on GitHub. Remotes let you share commits with others by pushing your changes up and pulling theirs down.
• rename() (Pandas) — df.rename() changes column or index labels by mapping old names to new ones with a dict or a function. It is the clean, non-destructive way to relabel without rebuilding the frame.
• render_template() (Flask) — render_template() is the Flask function that loads a Jinja2 template file, fills it with the data you pass as keyword arguments, and returns the finished HTML string ready to send to the browser.
• Rendering (React) — Rendering is the process by which React calls your components to produce the UI and then updates the screen to match. React re-renders a component whenever its state or props change.
• REPL (Node.js) — The Node.js REPL (Read-Eval-Print Loop) is the interactive shell you get by running node with no file. You type JavaScript, it evaluates each line immediately and prints the result, making it ideal for quick experiments.
• Repository (Repo) — A repository, or repo, is the folder Git tracks — it holds your project's files plus a hidden .git directory containing the full history of every change. You create one with git init or get one with git clone.
• req & res Objects (Express) — In Express, req (request) holds the incoming data — URL params, query string, headers, and body — while res (response) is how you reply, with helpers like res.json(), res.status(), and res.send().
• Request Context (Flask) — The request context in Flask holds data tied to a single incoming request and powers the request and session proxies. Flask pushes it automatically while handling each request and pops it when the response is sent.
• request Object (Flask) — Flask's request object holds all data from the incoming HTTP request — form fields, query-string args, JSON body, headers, cookies, and uploaded files. It is a thread-local global you import from flask.
• reshape() (NumPy) — a.reshape() returns a new view of an array with a different shape but the same data and the same total number of elements. It rearranges how the existing values are organized into rows, columns, or higher dimensions.
• Response Object (Flask) — A Flask Response represents the HTTP reply sent back to the client, carrying the body, status code, headers, and cookies. Flask builds one automatically from your view's return value, or you can construct it explicitly with make_response().
• Responsive Design — Responsive design is the practice of building web pages that adapt their layout to look good on any screen size, from phones to desktops. It relies on flexible layouts, images, and media queries.
• REST API — A REST API is a web API that follows REST principles, using standard HTTP methods (GET, POST, PUT, DELETE) and URLs to let clients read and change data, usually as JSON.
• REST API (Flask) — A REST API in Flask exposes resources over HTTP using JSON and standard verbs: GET to read, POST to create, PUT/PATCH to update, DELETE to remove. Routes return jsonify() data and appropriate status codes instead of HTML.
• REST API (Node.js) — A REST API in Node.js exposes resources over HTTP using JSON and standard verbs — GET to read, POST to create, PUT/PATCH to update, DELETE to remove. It is commonly built with Express routes that return res.json().
• Result<T, E> (Rust) — Result<T, E> is Rust's type for operations that can fail. It is an enum with Ok(value) for success and Err(error) for failure. Rust uses it instead of exceptions for recoverable errors.
• Retention Rate — Retention rate is the percentage of customers who stay with a product over a given period. It is the mirror image of churn rate — higher is better.
• return (Python) — The return statement sends a value back from a function to the code that called it and immediately ends the function. A function with no return gives back None.
• Return Statement — A return statement sends a value back from a function to the code that called it, and immediately ends the function's execution.
• ROI (Return on Investment) — ROI measures how much profit an investment returns relative to its cost, expressed as a percentage. A positive ROI means you made money; a negative ROI means you lost it.
• rolling() (Pandas) — s.rolling(window) creates a sliding window over a Series or DataFrame so you can compute moving statistics like rolling means and sums. It is the core tool for smoothing and trend analysis on ordered data.
• Route / @app.route (Flask) — A Flask route maps a URL path to a Python function using the @app.route decorator. When a request matches the path, Flask calls that function and sends back whatever it returns.
• Router (Express) — An Express Router is a mini, modular set of routes you can mount on a path. It lets you split a large app's endpoints into separate files (users, posts, auth) and attach them to the main app with app.use().
• Row (Record) — A row is a single record in a database table — one complete entry, such as one user or one order. Each row holds a value for every column in the table.
• RPM (Revenue Per Mille) — RPM is the revenue earned per 1,000 page views or ad impressions — a key metric for ad-supported websites and creators.
• Ruby on Rails (Ruby) — Ruby on Rails is a full-stack web framework written in Ruby. It follows convention over configuration and the MVC pattern to let developers build database-backed web apps quickly.
• Runtime — Runtime is the period when a program is actually running. It also refers to the environment that executes the program, such as the Node.js or Java runtime.
• Runway — Runway is how many months a startup can keep operating before it runs out of cash, based on its current bank balance and how fast it spends money.
• S3 and S4 Classes (R) — S3 and S4 are R's two main object-oriented systems. S3 is informal and uses a class attribute plus generic functions; S4 is formal with declared slots, types, and stricter method dispatch.
• SaaS (Software as a Service) — SaaS is software hosted in the cloud and accessed by subscription rather than bought outright. Netflix, Slack and Notion are SaaS products.
• Safe Call Operator (?.) (Kotlin) — The safe-call operator ?. calls a method or accesses a property only if the receiver is non-null; if it's null, the whole expression evaluates to null instead of throwing a NullPointerException.
• Safe Navigation Operator (&.) (Ruby) — The safe navigation operator &. calls a method only if the receiver is not nil; if it is nil, the expression returns nil instead of raising a NoMethodError. It avoids manual nil checks.
• savefig() (Matplotlib) — fig.savefig() (or plt.savefig()) writes a Matplotlib figure to an image file such as PNG, PDF, or SVG. It is how you export a plot for a report, slide, or webpage instead of showing it on screen.
• scatter() (Matplotlib) — ax.scatter() plots individual (x, y) points as separate markers without connecting them. It is the chart for showing the relationship or correlation between two variables.
• Schema (Mongoose) — A Mongoose schema defines the shape of documents in a MongoDB collection: each field's name, type, default, and validation rules. It is compiled into a model that enforces that structure on the otherwise schemaless database.
• Scope — Scope defines where a variable can be seen and used in a program. A variable created inside a function (local scope) usually cannot be accessed from outside it.
• Scope (JavaScript) — Scope is the part of a program where a variable is visible and can be used. JavaScript has global scope, function scope, and block scope.
• Scope Functions (let, run, with, apply, also) (Kotlin) — Scope functions run a block of code in the context of an object. let, run, with, apply, and also differ in how they refer to the object (it vs this) and what they return (the result vs the object).
• Sealed Class (Kotlin) — A sealed class defines a restricted hierarchy where all direct subclasses are known at compile time. This lets when expressions over it be exhaustive without an else branch.
• Sealed Interface (Kotlin) — A sealed interface restricts which types can implement it to those declared in the same module, giving exhaustive when checks like a sealed class but with interface flexibility.
• secret_key (Flask) — The secret_key is a Flask config value used to cryptographically sign data like session cookies and CSRF tokens. Without it, sessions and flash messages raise an error; it must be a long, random, secret string in production.
• Seed Round — A seed round is the first significant funding a startup raises, used to build a product and find product-market fit. Investors give cash in exchange for an early ownership stake.
• SELECT Statement — SELECT is the SQL command for reading data from a database. You list the columns you want and the table to read them from, and the database returns the matching rows.
• select_related & prefetch_related (Django) — select_related and prefetch_related are Django ORM optimizations that fetch related objects efficiently to avoid the N+1 query problem. Use select_related for foreign keys/one-to-one and prefetch_related for many-to-many and reverse relations.
• self (Python) — self is the first parameter of a method in a Python class, and it refers to the specific object the method is being called on. It lets methods read and change that object's own data.
• Semantic HTML — Semantic HTML means using tags that describe the meaning of content — like <header>, <nav>, <article>, and <footer> — instead of generic <div>s. It makes pages clearer for browsers, search engines, and screen readers.
• Semantic Versioning (semver) (Node.js) — Semantic Versioning (semver) is the MAJOR.MINOR.PATCH version scheme npm uses for packages. MAJOR breaks compatibility, MINOR adds features compatibly, and PATCH fixes bugs. Range symbols ^ and ~ control which updates npm accepts.
• Sending Email (Django) — Django's email framework sends mail through send_mail() and EmailMessage, configured by EMAIL_BACKEND and SMTP settings. It is used for password resets, notifications, and contact-form delivery.
• seq() and the : Operator (R) — seq() generates regular sequences of numbers, and the colon operator a:b creates a sequence of consecutive integers from a to b. Both are core tools for building index and value vectors.
• Serializer (DRF) — A serializer in Django REST Framework converts model instances and querysets into JSON for responses, and validates and parses incoming JSON into Python for requests. It is DRF's equivalent of a Django Form for APIs.
• Series (Pandas) — A Series is pandas' one-dimensional labeled array — a single column of values paired with an index. It is the building block that DataFrame columns are made of.
• session (Flask) — Flask's session is a dictionary-like object that stores per-user data across requests, such as a logged-in user id. By default it is signed and stored in a cookie on the client, so it requires a secret_key.
• Sessions (Django) — Django sessions store per-visitor data on the server across requests, keyed by a session id kept in a cookie. They power login state and let you stash data like a shopping cart in request.session, a dict-like object.
• Set (Python) — A set is an unordered collection of unique items written in curly braces. Sets automatically remove duplicates and are great for membership tests.
• Set (Ruby) — A Set is a collection of unique, unordered elements from the standard library. It offers fast membership tests and set operations like union, intersection, and difference.
• Set Operations (NumPy) — NumPy's set routines — intersect1d, union1d, setdiff1d, and in1d/isin — treat arrays as mathematical sets so you can compute intersections, unions, differences, and membership tests element-wise.
• set_index() and reset_index() (Pandas) — set_index() promotes one or more columns to become the DataFrame's row index, while reset_index() does the reverse, turning the index back into ordinary columns and restoring a default integer index.
• setTimeout() (JavaScript) — setTimeout() schedules a function to run once after a given number of milliseconds. It is the standard way to delay code in JavaScript.
• Settings & Environment Variables (Django) — Managing Django settings across environments means keeping secrets and per-environment values out of settings.py and loading them from environment variables instead. This keeps DEBUG, SECRET_KEY, and database credentials safe and flexible.
• settings.py (Django) — settings.py is the configuration file for a Django project. It defines the database, installed apps, middleware, templates, static files, secret key, and many other options that control how the whole site behaves.
• Shadowing (Rust) — Shadowing is re-declaring a variable with the same name using let. The new binding replaces the old one within the scope, and it may even have a different type.
• shape (NumPy) — The shape attribute is a tuple giving the size of a NumPy array along each axis. A shape of (2, 3) means a 2-D array with 2 rows and 3 columns; the length of the tuple is the number of dimensions.
• show() (Matplotlib) — plt.show() displays all open Matplotlib figures in a window. In a script it opens an interactive viewer and blocks until you close it; it is the final command that makes your plot actually appear.
• Signals (Django) — Signals let parts of a Django app react to events elsewhere without tight coupling. A sender emits a signal (like post_save after a model is saved) and registered receiver functions run in response.
• Slice (Rust) — A slice is a borrowed view into a contiguous part of a collection, written &[T] for arrays/vectors or &str for strings. It references existing data without owning or copying it.
• Slicing (NumPy) — Slicing extracts a sub-section of a NumPy array using start:stop:step notation, per axis, separated by commas. Unlike list slices, a NumPy slice returns a view that shares memory with the original array.
• Slicing (Python) — Slicing extracts a portion of a sequence (string, list, or tuple) using the [start:stop:step] notation. The start is included and the stop is excluded.
• Smart Cast (Kotlin) — A smart cast is when the Kotlin compiler automatically casts a value to a more specific type after you've checked it, so you don't have to cast manually inside that scope.
• Smart Pointer (C++) — A smart pointer is an object that manages a dynamically allocated resource and frees it automatically when no longer needed. It prevents memory leaks by handling delete for you.
• Smart Pointer (Rust) — A smart pointer is a type that acts like a pointer but adds extra capabilities — heap allocation, reference counting, or interior mutability — and automatically cleans up its data when dropped.
• sort_values() (Pandas) — df.sort_values() reorders the rows of a DataFrame or the elements of a Series by the values in one or more columns. It is how you rank, order, and find the largest or smallest records.
• sort() and argsort() (NumPy) — np.sort() returns a sorted copy of an array, and np.argsort() returns the indices that would sort it. Sorting works along an axis, and argsort is the key to ordering one array by the values of another.
• sorted() (Python) — sorted() returns a new sorted list from any iterable, leaving the original unchanged. You can sort in reverse or by a custom key.
• Spaceship Operator (<=>) (Ruby) — The spaceship operator <=> compares two values and returns -1, 0, or 1 (or nil if not comparable). It's the basis for sorting and for the Comparable mixin.
• span Element — The <span> is a generic inline container with no meaning of its own, used to wrap a small piece of text or other inline content for styling. Unlike <div>, it does not start on a new line.
• Splat Operator (* and **) (Ruby) — The splat operator * gathers extra arguments into an array (or spreads an array into arguments); the double splat ** does the same for keyword arguments into a hash. They make methods accept variable arguments.
• split() (NumPy) — np.split() divides an array into multiple sub-arrays along an axis, returning a list of pieces. It is the inverse of concatenate, with hsplit and vsplit for the horizontal and vertical cases.
• Spread Operator (JavaScript) — The spread operator (...) expands an array or object into its individual elements. It is used to copy, merge, or pass collections of values cleanly.
• SQL — SQL (Structured Query Language) is the standard language for storing, retrieving, and managing data in a relational database. You use it to ask questions of your data and to add, change, or delete records.
• SQL Injection — SQL injection is a security attack where malicious input is inserted into a SQL query, tricking the database into running unintended commands. It can expose or destroy data.
• Stack — A stack is a data structure where items are added and removed from the same end, following Last-In-First-Out (LIFO) order — like a stack of plates.
• stack() and unstack() (Pandas) — stack() moves a DataFrame's columns down into the row index, making the data taller and narrower; unstack() does the reverse, pivoting an index level up into columns. They reshape between wide and long forms.
• stack(), hstack(), vstack() (NumPy) — These functions combine arrays: np.stack joins them along a brand-new axis, while np.hstack stacks horizontally (column-wise) and np.vstack stacks vertically (row-wise) along existing axes.
• Staging Area — The staging area (also called the index) is where Git holds the changes you've selected for your next commit. You move changes into it with git add before committing.
• State (React) — State is data that a React component owns and can change over time, such as the current value of an input or whether a menu is open. When state changes, React automatically re-renders the component to reflect the new value.
• static (Java) — static means a field or method belongs to the class itself rather than to any individual object. You can use a static member without creating an object first.
• Static Files (Flask) — Static files in Flask are unchanging assets like CSS, JavaScript, and images, served from the static/ folder. You link to them in templates with url_for('static', filename='...') so the correct URL is generated automatically.
• Static vs Media Files (Django) — In Django, static files are assets you ship with your code (CSS, JS, images), served under STATIC_URL; media files are user-uploaded content (avatars, documents) stored under MEDIA_ROOT and served under MEDIA_URL.
• std::cin (C++) — std::cin is C++'s standard input stream, used to read typed input from the user. You extract values from it with the >> extraction operator.
• std::cout (C++) — std::cout is C++'s standard output stream, used to print text and values to the console. You send data to it with the << insertion operator.
• std::string (C++) — std::string is the C++ standard library type for text. It stores a sequence of characters and, unlike C-style char arrays, manages its own memory and can grow or shrink automatically.
• std::vector (C++) — std::vector is a resizable array from the C++ standard library. It stores elements of one type in contiguous memory and can grow or shrink at runtime.
• STL (Standard Template Library) — The STL is a core part of the C++ standard library that provides ready-made containers (like vector and map), algorithms (like sort and find), and iterators that connect them.
• str() (R) — str() compactly displays the structure of any R object — its type, dimensions, and a preview of its contents. It is the first command analysts run to understand unfamiliar data.
• Stream (Java) — A Stream is a way to process a sequence of data through a pipeline of operations like filter, map, and collect. It lets you transform collections in a clean, declarative style instead of writing manual loops.
• Stream (Node.js) — A stream in Node.js processes data piece by piece instead of loading it all into memory at once. Readable, Writable, Duplex, and Transform streams let you handle large files and network data efficiently.
• Strict Mode (JavaScript) — Strict mode is an opt-in mode that makes JavaScript catch more mistakes by turning silent errors into thrown errors. You enable it with the line "use strict".
• String — A string is a data type that represents text — a sequence of characters such as letters, numbers, and symbols, usually written inside quotes.
• string (C#) — A string in C# is a sequence of characters that represents text, written inside double quotes. Strings are immutable, meaning their contents can't be changed after they're created.
• String (Java) — A String in Java is a sequence of characters used to store text, written in double quotes. Strings are objects and are immutable, meaning their contents can't be changed after they're created.
• String (Python) — A string in Python is text wrapped in single or double quotes. Strings are immutable, meaning their contents can't be changed once created.
• String Interpolation (Ruby) — String interpolation embeds the result of a Ruby expression inside a double-quoted string using #{...}. It builds strings from variables and code without manual concatenation.
• String Methods (JavaScript) — String methods are built-in functions for working with text, such as toUpperCase(), slice(), split(), and includes(). They return new strings without changing the original.
• String Templates (Kotlin) — String templates embed variables and expressions directly inside strings using $name for a variable and ${expression} for anything more complex, avoiding manual concatenation.
• String vs &str (Rust) — String is an owned, growable, heap-allocated UTF-8 string; &str is a borrowed, fixed view into string data. The two work together: String owns the buffer, &str references part of it.
• Struct (Ruby) — Struct is a built-in Ruby class that quickly generates a simple class with named attributes, accessors, equality, and a constructor — ideal for lightweight value objects without boilerplate.
• Struct (Rust) — A struct is a custom data type that groups related named fields into one value. Structs are how you model real-world entities in Rust, similar to objects or records in other languages.
• Style Sheets (Matplotlib) — Style sheets are named bundles of default settings that change a plot's whole look — colors, fonts, grid, background — in one line. plt.style.use('ggplot') restyles every subsequent plot at once.
• subplot() (Matplotlib) — plt.subplot() adds a single Axes to the current Figure at a position in a grid, specified as (rows, columns, index). It is the older pyplot way to build multi-panel figures one panel at a time.
• subplots() (Matplotlib) — plt.subplots() creates a Figure and a grid of Axes in one call, returning both. It is the standard, recommended way to start a Matplotlib plot, especially when you want several panels arranged in rows and columns.
• Subquery — A subquery is a query nested inside another query. The inner query runs first, and its result is used by the outer query — for example, to filter on a calculated value.
• sum, mean, std (with axis) (NumPy) — Aggregation functions like sum(), mean(), and std() reduce an array to summary values. With no axis they reduce the whole array to one number; with an axis they reduce along just that dimension.
• SUM() — SUM() is an aggregate function that adds up the values in a numeric column and returns the total. It ignores NULL values.
• Supervised Learning — Supervised learning is a type of machine learning where the model learns from labeled examples — data where the correct answer is already known — so it can predict the answer for new, unseen data.
• suspend Function (Kotlin) — A suspend function is one marked with the suspend keyword that can pause and resume without blocking a thread. It may only be called from a coroutine or another suspend function.
• switch Statement (C#) — A switch statement compares one value against several possible cases and runs the matching block. It is a clean alternative to a long chain of if/else if statements.
• Symbol (Ruby) — A symbol is an immutable, reusable identifier written with a leading colon, like :name. Symbols are used as lightweight, memory-efficient names — especially for hash keys and method references.
• Syntax — Syntax is the set of rules that define how code must be written in a programming language — the grammar and punctuation the computer requires to understand it.
• System.out.println() (Java) — System.out.println() prints a line of text to the console and then moves to a new line. It is Java's standard way to display output and is usually the first thing you learn.
• Table (SQL) — A table is the basic structure that holds data in a relational database. It is organized like a spreadsheet, with rows for individual records and columns for each piece of information.
• Tag (Git) — A Git tag is a label that marks a specific commit, most often used to mark release versions like v1.0.0. Unlike a branch, a tag is fixed and doesn't move as new commits are added.
• TAM (Total Addressable Market) — TAM is the total annual revenue available if a product captured 100% of its market. It answers the question: how big could this business possibly get?
• Template (C++) — A template lets you write a function or class that works with any type, with the actual type filled in when you use it. This is how C++ supports generic, reusable code.
• Template (Django) — A Django template is an HTML file containing Django Template Language tags. Views render it into final HTML by passing a context dictionary, whose keys become variables you display with {{ }} and control with {% %}.
• Template (Flask) — A Flask template is an HTML file (stored in the templates/ folder) containing Jinja2 placeholders. Flask renders it into final HTML by combining the file with data passed from a view function.
• Template Inheritance (Django) — Template inheritance lets Django templates share a common layout. A base template defines the page skeleton with {% block %} placeholders, and child templates use {% extends %} to fill in only the blocks they need to change.
• Template Literal (JavaScript) — A template literal is a string written with backticks that lets you embed variables and expressions using ${ }. It also allows multi-line strings.
• Template Tags & Filters (Django) — Template tags are the {% %} constructs that add logic to Django templates (loops, conditionals, URL reversing), and filters are the | transforms that format values. You can also write custom ones in a templatetags module.
• Tensor — A tensor is a multi-dimensional array of numbers, the basic data structure used in deep learning frameworks like PyTorch and TensorFlow to hold inputs, weights, and outputs.
• Ternary Operator (JavaScript) — The ternary operator is a one-line shortcut for an if/else that returns a value. It uses the form condition ? valueIfTrue : valueIfFalse.
• Test Data — Test data is a portion of the dataset held back and never used during training, used to measure how well a model performs on new, unseen examples.
• this (JavaScript) — this is a keyword that refers to the object a function is currently running on. Its value depends on how the function is called.
• Tibble (R) — A tibble is the tidyverse's modern reimagining of the data frame. It behaves like a data frame but prints more cleanly, never silently changes types, and never converts strings to factors.
• tight_layout() (Matplotlib) — fig.tight_layout() automatically adjusts the spacing around and between subplots so that titles, axis labels, and tick labels don't overlap or get clipped. It fixes the common 'labels cut off' problem.
• Timers (Node.js) — Node.js timers schedule code to run later: setTimeout runs once after a delay, setInterval runs repeatedly, and setImmediate runs after the current event-loop phase. Each returns a handle you can cancel.
• title, xlabel, ylabel (Matplotlib) — set_title(), set_xlabel(), and set_ylabel() add the descriptive text to a plot — the heading above it and the names of the x and y axes. They turn a bare chart into one a reader can understand.
• to_csv() (Pandas) — df.to_csv() writes a DataFrame out to a comma-separated values file or string. It is the counterpart to read_csv and the simplest way to export results for sharing or storage.
• Tokenization — Tokenization is the process of breaking text into smaller pieces called tokens — words, parts of words, or characters — so a language model can process it.
• Training Data — Training data is the set of examples a machine learning model learns from. The model studies this data and adjusts its internal parameters to capture the patterns it contains.
• Trait (Rust) — A trait defines a set of methods that a type can implement — Rust's version of an interface. Traits enable shared behavior and are the foundation of Rust's generics and polymorphism.
• Transaction (SQL) — A transaction groups several SQL statements into a single all-or-nothing unit of work. Either every statement succeeds and is saved (COMMIT), or none are (ROLLBACK).
• Transformer — A transformer is a neural network architecture that processes sequences (like sentences) using a mechanism called attention, which lets the model weigh how relevant each word is to every other word.
• transpose() / .T (NumPy) — Transposing flips a 2-D array over its diagonal, swapping its rows and columns so an (m, n) array becomes (n, m). The shortcut is the .T attribute, and it returns a view rather than copying the data.
• Truthy & Falsy (JavaScript) — In JavaScript, every value is either truthy or falsy when used in a condition. Falsy values are false, 0, "", null, undefined, NaN, and 0n; everything else is truthy.
• Truthy and Falsy (Ruby) — In Ruby only nil and false are falsy; every other value — including 0, "", and [] — is truthy. This simple rule governs how all conditionals behave.
• try / catch (C#) — try/catch is how C# handles errors. Code that might fail goes in the try block, and the catch block runs instead if an exception occurs, preventing a crash.
• try / catch (Java) — try/catch is how Java handles errors. Code that might fail goes in the try block, and the catch block runs instead if an exception occurs, preventing a crash.
• try / except (Python) — try/except is how Python handles errors. Code that might fail goes in the try block, and the except block runs instead if an exception occurs, preventing a crash.
• Tuple (Python) — A tuple is an ordered collection of items written in parentheses. It works like a list but is immutable, so its contents can't be changed after creation.
• Tuple (TypeScript) — A tuple is an array with a fixed number of elements whose types are known at each position, like `[string, number]`. It lets you type the slots of an array individually.
• twinx() (Matplotlib) — ax.twinx() creates a second y-axis that shares the same x-axis, so you can plot two series with different units or scales on one chart. ax.twiny() does the mirror image for a shared y-axis.
• Type Alias (TypeScript) — A type alias gives a name to any type using the `type` keyword, so you can reuse it. Unlike an interface, it can name unions, tuples, primitives, and more — not just object shapes.
• Type Annotation (TypeScript) — A type annotation is the part after a colon that tells TypeScript what type a variable, parameter, or return value should be, such as `: number` or `: string`. It lets the compiler check your code for type mistakes.
• Type Assertion (TypeScript) — A type assertion tells the compiler to treat a value as a specific type, using the `as` keyword. You are overriding TypeScript's inference because you know more about the type than it does.
• Type Guard (TypeScript) — A type guard is a runtime check that narrows a value to a more specific type, such as `typeof x === "string"` or `"id" in obj`. Inside the check, TypeScript treats the value as that narrower type.
• Type Inference (Kotlin) — Type inference lets the Kotlin compiler deduce a variable's or function's type from context, so you can omit explicit type annotations while keeping full static type safety.
• Type Inference (TypeScript) — Type inference is TypeScript's ability to figure out a type automatically from the value you assign, without you writing an annotation. If you write `let x = 5`, TypeScript already knows x is a number.
• type() (Python) — type() returns the data type of a value, such as int, str, or list. It is commonly used to inspect or debug what kind of object you're working with.
• typeof (JavaScript) — typeof is an operator that returns a string naming the type of a value, such as "number", "string", or "object". It is used to check what kind of data you have.
• typeof (Type Operator) (TypeScript) — In a type position, the `typeof` operator gives you the type of an existing variable or object. It lets you derive a type from a value instead of writing it out by hand.
• Types & Type Inference (Rust) — Rust is statically and strongly typed: every value has a type known at compile time. Type inference lets you usually skip writing types, while the compiler still checks them rigorously.
• TypeScript — TypeScript is a programming language built on top of JavaScript that adds static types. It catches type-related mistakes while you write code, then compiles down to plain JavaScript that runs anywhere JS does.
• ufunc (Universal Function) (NumPy) — A ufunc is a NumPy function that operates element-wise on whole arrays in fast compiled code — examples include np.sqrt, np.exp, np.add, and np.sin. Ufuncs are how NumPy applies math across an array without a Python loop.
• Underfitting — Underfitting happens when a model is too simple to capture the underlying pattern in the data, so it performs poorly on both the training data and new data.
• Union Type (TypeScript) — A union type lets a value be one of several types, written with a vertical bar between them, like `string | number`. The value can be any one of the listed types.
• UNIQUE Constraint — A UNIQUE constraint guarantees that every value in a column (or set of columns) is different across all rows. It prevents duplicate entries like two users with the same email.
• unique() (NumPy) — np.unique() returns the sorted, distinct values of an array with duplicates removed. With return_counts=True it also tells you how many times each distinct value appears.
• Unit Economics — Unit economics is the profit or loss a business makes from a single unit — usually one customer. Healthy unit economics mean each customer earns more than they cost.
• unknown (TypeScript) — `unknown` is the type-safe counterpart of `any`. It can hold any value, but TypeScript won't let you use it until you narrow it down to a specific type first.
• Unsupervised Learning — Unsupervised learning is machine learning on data that has no labels. The model explores the data on its own to find hidden structure, such as natural groups or patterns.
• UPDATE Statement — UPDATE changes the values in existing rows of a table. You set the new column values and use a WHERE clause to choose which rows are affected.
• URL Namespacing / reverse() (Django) — URL namespacing in Django scopes URL names to an app so 'blog:detail' and 'shop:detail' don't collide. You set app_name in urls.py and reverse names with reverse() in Python or {% url %} in templates instead of hard-coding paths.
• url_for() (Flask) — url_for() builds a URL to a view by its function name instead of hard-coding the path. It is used in templates and views so links keep working even if you change the route's URL pattern.
• URLconf / urls.py (Django) — A URLconf is Django's URL configuration — the urls.py files that map URL patterns to views using path(). When a request arrives, Django walks the patterns top to bottom and calls the view of the first one that matches.
• useCallback — useCallback is a React Hook that returns a memoized version of a function, keeping the same function reference between renders unless its dependencies change. It is mainly used to prevent unnecessary re-renders of child components.
• useContext — useContext is a React Hook that reads a value from a Context, letting a component access shared data without passing it down through props at every level. It is the consumer side of the Context API.
• useEffect — useEffect is the React Hook for running side effects in a component, such as fetching data, setting up subscriptions, or updating the document title. It runs after the component renders.
• useMemo — useMemo is a React Hook that caches (memoizes) the result of an expensive calculation so it is only recomputed when its dependencies change. It helps avoid redoing costly work on every render.
• useRef — useRef is a React Hook that gives you a mutable container whose value persists across renders without causing a re-render when it changes. It is most often used to access a DOM element directly.
• useState — useState is the React Hook that adds state to a functional component. It returns a pair: the current state value and a function to update it, which triggers a re-render.
• using Directive — A using directive at the top of a C# file imports a namespace so you can use its types without typing the full path. For example, `using System;` lets you write Console instead of System.Console.
• Utility Type (TypeScript) — Utility types are built-in generic types that transform other types, such as `Partial<T>`, `Pick<T, K>`, `Omit<T, K>`, and `Record<K, V>`. They save you from rewriting common type transformations.
• V8 Engine (Node.js) — V8 is Google's open-source JavaScript engine, written in C++, that Node.js uses to execute your code. It compiles JavaScript to fast machine code with just-in-time compilation and manages memory with garbage collection.
• val vs var (Kotlin) — In Kotlin, val declares a read-only (immutable) reference that can't be reassigned, while var declares a mutable one that can. Prefer val by default for safer, clearer code.
• Valuation — Valuation is the estimated total worth of a company, used to set the price of its shares when raising money or being sold. SaaS startups are often valued as a multiple of revenue.
• value_counts() (Pandas) — s.value_counts() counts how many times each distinct value appears in a Series and returns the tallies sorted from most to least frequent. It is the fastest way to summarize a categorical column.
• var (C#) — var lets the C# compiler infer a variable's type from the value you assign, so you don't have to write the type explicitly. The variable is still strongly typed at compile time.
• var (JavaScript) — var is the original keyword for declaring variables in JavaScript. It is function-scoped and hoisted, which is why modern code prefers let and const instead.
• Variable — A variable is a named container that stores a value in a program's memory. The value it holds can change as the program runs.
• Variable (C#) — A variable in C# is a named storage location that holds a value of a specific type. You declare it by writing the type followed by a name, then assign a value with the equals sign.
• Variable (C++) — A variable in C++ is a named storage location with a fixed type that holds a value. Unlike some languages, you must declare a variable's type before using it.
• Variable (Java) — A variable in Java is a named container that stores a value. Because Java is statically typed, you must declare a variable's type when you create it, and it can only hold values of that type.
• Variable (Python) — A variable in Python is a name that points to a value stored in memory. You create one with the equals sign, and Python figures out the type automatically.
• Vec<T> (Rust) — Vec<T> is Rust's growable, heap-allocated array — an ordered list of values of the same type that can shrink and grow at runtime. It is the most common collection in Rust.
• Vector (R) — A vector is R's most basic data structure: an ordered sequence of elements that all share the same type (numeric, character, logical, etc.). Even a single value in R is a length-1 vector.
• Vectorization (NumPy) — Vectorization means expressing computations as operations on whole arrays rather than as explicit Python loops over elements. NumPy executes them in optimized C, so vectorized code is far faster and more concise.
• Vectorization (Pandas) — Vectorization is applying an operation to a whole Series or DataFrame at once instead of looping row by row. pandas runs these operations in fast compiled C/NumPy code, making vectorized code far quicker than Python loops.
• Vectorization (R) — Vectorization is R's practice of applying operations to entire vectors at once, element by element, instead of writing explicit loops. It makes code shorter, clearer, and much faster.
• vectorize() (NumPy) — np.vectorize() wraps an ordinary Python function so it can be called on whole arrays, applying it element by element and handling broadcasting. It is a convenience wrapper, not a true performance optimization.
• Version Control — Version control is a system that records changes to files over time so you can recall specific versions later, see who changed what, and collaborate safely. Git is the most popular version-control system.
• View (Django) — A Django view is the Python code that receives an HTTP request and returns an HTTP response. It can be a function (function-based view) or a class (class-based view), and it usually queries models and renders a template.
• View (SQL) — A view is a saved SELECT query that you can treat like a virtual table. It doesn't store data itself, but shows the result of its query whenever you read from it.
• View Function (Flask) — A view function in Flask is the Python function attached to a route. It receives the request, runs your logic, and returns the response — a string, a rendered template, JSON, or a Response object.
• View vs Copy (NumPy) — A view is a new array object that shares the same underlying data as the original, so writing to one changes the other; a copy is independent data. Knowing which an operation returns is key to avoiding subtle bugs.
• Viewport — The viewport is the visible area of a web page in the browser window — what fits on screen without scrolling. On mobile, the viewport meta tag controls how the page is scaled.
• ViewSet & Router (DRF) — A ViewSet groups the logic for a set of related API endpoints (list, retrieve, create, update, destroy) into one class. Paired with a DRF Router, it auto-generates the URL routes for full CRUD on a resource.
• Virtual DOM — The Virtual DOM is a lightweight, in-memory representation of the real page that React keeps and updates. React compares the new virtual tree to the previous one and changes only the parts of the actual page that differ.
• Virtual Environment (Python) — A virtual environment is an isolated Python setup for a single project, with its own installed packages. It keeps each project's dependencies separate so they don't conflict.
• Virtual Function (C++) — A virtual function is a member function marked with the virtual keyword so that the correct version runs based on the object's actual type at runtime. This is the basis of polymorphism in C++.
• void (TypeScript) — `void` is the return type for a function that doesn't return a useful value. It signals that the function runs for its side effects, like logging or updating state, rather than producing a result.
• Web Accessibility (a11y) — Web accessibility (often shortened to a11y) is the practice of building websites that everyone can use, including people with disabilities. It covers things like screen reader support, keyboard navigation, and sufficient color contrast.
• when Expression (Kotlin) — when is Kotlin's multi-branch conditional, replacing switch. It can match values, ranges, types, or arbitrary boolean conditions, and it's an expression that returns a value.
• WHERE Clause — The WHERE clause filters rows so a query returns only those that meet a condition. Without it, a query acts on every row in the table.
• where() (NumPy) — np.where(condition, x, y) builds a new array choosing elements from x where the condition is True and from y where it is False. Called with only a condition, it returns the indices where that condition holds.
• while Loop (C#) — A while loop in C# repeats a block of code as long as a condition stays true. It is used when you don't know in advance how many times you need to loop.
• while Loop (C++) — A while loop in C++ repeats a block of code as long as its condition stays true. It is used when you don't know in advance how many times you'll need to loop.
• while Loop (Java) — A while loop repeats a block of code as long as a condition stays true. It is used when you don't know in advance how many times the loop should run.
• while Loop (Python) — A while loop repeats a block of code as long as a condition stays True. It is used when you don't know in advance how many times you need to loop.
• with / Context Manager (Python) — The with statement sets up and automatically cleans up a resource, such as a file, even if an error happens. The object it manages is called a context manager.
• Worker Threads (Node.js) — Worker threads let Node.js run JavaScript in parallel on separate threads, mainly for CPU-intensive work. They prevent heavy computation from blocking the single-threaded event loop and freezing the rest of the app.
• Working Directory — The working directory is the folder of files you actually see and edit on your computer. It is the current state of your project, separate from the staging area and committed history.
• WSGI (Flask) — WSGI (Web Server Gateway Interface) is the Python standard that lets web servers talk to Python web applications. A Flask app is a WSGI application, which is why servers like gunicorn, uWSGI, and Werkzeug can run it.
• WSGI vs ASGI (Django) — WSGI and ASGI are the interfaces between web servers and Django. WSGI is the long-standing synchronous standard; ASGI is the newer asynchronous one that adds support for async views, WebSockets, and long-lived connections.
• xlim and ylim (Matplotlib) — set_xlim() and set_ylim() set the visible range of a plot's x and y axes, controlling how far each axis extends. They let you zoom in on a region or fix consistent scales across charts.
• xticks and yticks (Matplotlib) — set_xticks() and set_xticklabels() control where the tick marks sit on an axis and what text labels them. They let you place ticks at chosen positions and replace numbers with custom labels.
• yield (Python) — yield is the keyword that turns a function into a generator. It hands back a value and pauses the function, resuming from the same spot the next time a value is requested.
• yield (Ruby) — yield calls the block that was passed to the current method, optionally passing it arguments. It's how a method hands control to its block, enabling custom iteration and callback patterns.
• z-index — The CSS z-index property controls the stacking order of overlapping elements — which one appears in front. A higher z-index sits on top of a lower one.
• zeros() and ones() (NumPy) — np.zeros() and np.ones() create new arrays of a given shape filled entirely with 0s or 1s. They are the usual way to pre-allocate an array you will fill in later, or to build constant arrays.
• zip() (Python) — zip() combines two or more sequences element by element, pairing the first items together, the second items together, and so on. It is handy for looping over several lists at once.

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary