Namespace
A namespace is a naming context or identifier space in which names are defined and resolved, distinguishing them from names in other contexts.
The Well-Grounded Python Developer: How the pros use Python and Flask
A named container that organizes identifiers and their bindings to prevent naming conflicts and control name resolution.
- How it is used
- Organizes named application functionality so convenient names can coexist without collisions.
- How deep it goes
- Works through built-in, module, and function namespaces, including shadowing, name lookup, scope, and variable lifetime.
- Examples
- Uses expense-report directories, mailing addresses, competing add functions, and personalized email names.
- What you can do after
- Apply it via Python modules and Flask Blueprints to separate features and avoid naming conflicts.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains namespace →
Kubernetes in Action, Second Edition
A namespace is a Kubernetes API resource that groups namespaced objects and provides scopes for object names and permissions within a cluster.
- How it is used
- Organizes teams' or clients' API objects into separate naming scopes within one cluster.
- How deep it goes
- Works through listing, creation, targeting, isolation limits, and deletion diagnosis without treating namespaces as runtime isolation.
- Examples
- Uses same-named pods in separate namespaces, kubectl listings, and a Namespace YAML manifest.
- What you can do after
- Operate/configure namespaces with kubectl and manifests, and diagnose a namespace stuck terminating.
Read how Kubernetes in Action, Second Edition explains namespace →
Google Anthos in Action
A namespace is a Kubernetes logical partition that scopes and organizes namespaced resources within a cluster.
- How it is used
- Scopes resource names, organizes tenants in a shared cluster, and identifies deployment targets.
- How deep it goes
- Defines namespace scope and works through creation, labeling, and deployment preparation; defers details of individual security controls.
- Examples
- Uses a service-mesh application namespace, an on-prem Marketplace target namespace, and a GKE Elasticsearch deployment choice.
- What you can do after
- Operate/configure it with kubectl to create and label a namespace, then target it for application deployment.
The Quick Python Book, Fourth Edition
A global namespace is the namespace associated with a module, script, or interactive session and visible as the defining environment for its functions.
- How it is used
- Explains how Python resolves names and how separate module namespaces prevent naming conflicts.
- How deep it goes
- Works through lookup order and function-local bindings, while deferring further namespace details to Python documentation.
- Examples
- Uses identically named module functions, inspected function locals, and a deleted import that raises `NameError`.
- What you can do after
- Diagnose/debug with it by inspecting `dir()`, `globals()`, and `locals()` to locate bindings and investigate missing names.
Read how The Quick Python Book, Fourth Edition explains namespace →
100 C++ Mistakes and How to Avoid Them
The global namespace is the C++ namespace containing declarations that are not enclosed in another namespace.
- How it is used
- Warns against placing related enumeration constants in the global namespace because collisions and ambiguity complicate maintenance.
- How deep it goes
- Defines the global namespace and traces duplicate names, integer mixing, arbitrary values, and out-of-bounds assignments before recommending enum class.
- Examples
- Uses traffic-light and automobile paint colors to contrast unscoped enumerations with separately scoped enum classes.
- What you can do after
- Apply it via enum class, qualified enumerators, and separate types for unrelated color sets.
Read how 100 C++ Mistakes and How to Avoid Them explains namespace →
Clojure: The Essential Reference
A namespace is a Clojure scope that organizes and qualifies names such as functions and variables.
- How it is used
- Organizes access to standard-library names and provides the context for mappings, aliases, and vars.
- How deep it goes
- Defines mapping and alias tables and identifies the global repository, without elaborating garbage-collector mechanics.
- Examples
- Uses clojure.string/upper-case and an ns-map lookup that retrieves and calls the var mapped to +.
- What you can do after
- Diagnose/debug with it: inspect mappings using ns-map, inspect aliases using ns-aliases, and distinguish namespaces from loaded libraries.
Read how Clojure: The Essential Reference explains namespace →
Authorization in Action
A namespace is a prefix or naming context that distinguishes entities, actions, policies, or types belonging to different domains or systems.
- How it is used
- Establishes unambiguous identity and policy domains so authorization decisions target the intended entities and actions.
- How deep it goes
- Defines namespaces, contrasts centralized and hierarchical designs, and details Cedar qualification and type-error checks.
- Examples
- Uses usernames, employee IDs, DNS, X.509, LDAP, PhotoApp::User, Furniture::Table, and Finance::Document.
- What you can do after
- Evaluate/understand how naming boundaries prevent misapplied authorization and how Cedar catches cross-type policy mistakes before deployment.
Python How-To
A global namespace is the module-level namespace that maps identifiers to their corresponding objects.
- How it is used
- Explains how Python finds names used in module code and function calls.
- How deep it goes
- Defines namespaces as dictionary-like mappings and works through lookup and scope behavior without detailing namespace implementation.
- Examples
- Uses a class and instance in `globals()`, an unchanged module variable, and a debugger inspection with `locals()`.
- What you can do after
- Diagnose/debug with it by checking where a name resolves and inspecting global or local variables.
F# in Action: A Revised Edition of Get Programming with F#
A namespace is a programming-language construct that groups and qualifies names to organize code and avoid naming collisions.
- How it is used
- Organizes related types and shortens access to external .NET types through opening namespaces.
- How deep it goes
- Explains hierarchy, declaration scope, qualification, opening, shared namespaces, and the boundary that namespaces cannot contain values.
- Examples
- Uses System.DateTime, System.IO, Foo.Order, and opening System for a console-input exercise.
- What you can do after
- Apply it via F# namespace declarations and open directives to organize types and reduce repeated qualification.
Read how F# in Action: A Revised Edition of Get Programming with F# explains namespace →
Kubernetes for Developers
A Kubernetes namespace is a logical scope that groups and isolates named resources within a cluster.
- How it is used
- Separates environments and applications while supporting repeatable, configuration-driven Kubernetes deployments.
- How deep it goes
- Explains naming, context selection, reuse, and rollout safeguards, but does not detail namespace internals.
- Examples
- Uses production and staging namespaces, repeated resource names, kubectl commands, reusable YAML, and namespace-checking rollout scripts.
- What you can do after
- Operate/configure environments by selecting namespaces, reusing manifests, and validating rollout targets before applying changes.
Refactoring to Rust
A namespace is a named scope that contains identifiers and distinguishes them from identifiers in other scopes.
- How it is used
- Organizes Rust library code into modules and controls how functions, types, and other items are named and accessed.
- How deep it goes
- Explains module namespaces, visibility, imports, and relative or absolute paths through progressively refactored examples.
- Examples
- Demonstrates greeting modules and a libsnack crate using imports, pub items, crate paths, and super paths.
- What you can do after
- Diagnose name-resolution errors and organize functions or types with Rust modules, visibility, imports, and paths.
Python Workout, Second Edition
A namespace is a mapping that associates names with objects and separates those names from other naming contexts.
- How it is used
- Uses modules to organize reusable definitions and prevent naming collisions across files.
- How deep it goes
- Explains module namespaces, import-bound names, and filesystem lookup through sys.path, but stops short of deeper import internals.
- Examples
- Demonstrates import os, qualified module access, from os import sep, and module lookup through sys.path.
- What you can do after
- Apply it via Python's import statement to reuse definitions and choose qualified or direct name bindings.
Read how Python Workout, Second Edition explains namespace →
MongoDB 8.0 in Action, Third Edition
A namespace is MongoDB's unique identifier for a collection formed by combining its database name and collection name with a dot.
- How it is used
- Identifies collections uniquely while inspecting MongoDB databases and collection metadata.
- How deep it goes
- Defines the database-qualified naming format, demonstrates its output, and states the 255-byte limit.
- Examples
- Uses sample_mflix.embedded_movies and db.getCollection("embedded_movies") as concrete namespace examples.
- What you can do after
- Operate mongosh to list collections, inspect metadata, and display a collection's fully qualified namespace.
Read how MongoDB 8.0 in Action, Third Edition explains namespace →
Modern C
An identifier namespace is a C naming domain in which identifiers are associated with distinct kinds of entities and may have separate collision rules.
- How it is used
- Guides C naming policy and limits the names exposed through interfaces.
- How deep it goes
- Defines several C identifier categories and collision risks, but stops short of detailing each namespace's formal lookup rules.
- Examples
- Uses a memory_sum declaration, possible collisions involving N, I, and strip, and a prefixed rewrite.
- What you can do after
- Apply a consistent naming policy and reduce conflicts by exposing fewer identifiers and using distinctive prefixes.
Platform Engineering on Kubernetes
A Kubernetes namespace is a logical scope that isolates and organizes namespaced resources within a cluster.
- How it is used
- Supports environment pipelines and multi-tenant platform layouts by logically partitioning resources within a Kubernetes cluster.
- How deep it goes
- Explains logical boundaries, RBAC, quotas, shared APIs, and isolation trade-offs, but stops short of implementation commands.
- Examples
- Uses namespace-per-environment layouts, shared development clusters, and separate staging and production clusters as contrasting deployment arrangements.
- What you can do after
- Evaluate namespace-based environment layouts and identify when separate clusters provide stronger isolation and access control.
Read how Platform Engineering on Kubernetes explains namespace →
.NET in Action, Second Edition
A namespace is a programming-language construct that groups related types and identifiers under a qualified name.
- How it is used
- Organizes .NET types while building a console application and separating reusable code from top-level program statements.
- How deep it goes
- Explains dotted hierarchies and using directives through C# listings, including how a type’s FullName displays its namespace.
- Examples
- Uses Figgle and HelloDotnet.AsciiArt, then illustrates hierarchy with System.Text.RegularExpressions.Regex.
- What you can do after
- Apply C# namespace declarations and using directives to place a class and refer to types in another namespace.
Read how .NET in Action, Second Edition explains namespace →
Effective Platform Engineering
A namespace is a logical partition that groups and isolates named resources within a cluster.
- How it is used
- Groups platform system resources and test applications into explicit cluster partitions.
- How deep it goes
- Defines namespaces through YAML and connects them to platform configuration, but does not detail namespace-level policy design.
- Examples
- Uses karpenter and test-system as concrete namespace names in cluster bootstrap manifests.
- What you can do after
- Operate/configure namespaces with kubectl and declarative Kubernetes YAML during cluster bootstrap.
Read how Effective Platform Engineering explains namespace →
Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
A namespace is a naming scope that groups related types and helps keep their identifiers distinct from types in other scopes.
- How it is used
- Organizes .NET types and gives custom PowerShell output objects distinctive, collision-resistant names.
- How deep it goes
- Defines namespaces, distinguishes them from classes, and demonstrates hierarchical naming without descending into namespace internals.
- Examples
- Uses System.Speech.Synthesis, Toolmaking.DiskInfo, and MyCompany.ITOps.Storage.DiskInfo as naming examples.
- What you can do after
- Apply it via hierarchical names that identify custom types without intruding on vendor-controlled namespaces.
Learn Go with Pocket-Sized Projects
A JavaScript namespace is a named scope or object used to organize and expose JavaScript-accessible functions and values.
- How it is used
- Organizes Go functions exposed to JavaScript by choosing between the global namespace and a specific JavaScript object.
- How deep it goes
- Shows function registration, object creation, property assignment, and browser invocation.
- Examples
- Uses a multiplication exercise with generate() globally or multiplyApp.generate() under a named object.
- What you can do after
- Apply it via Go's js API to expose a function globally or under a named JavaScript object.
Read how Learn Go with Pocket-Sized Projects explains namespace →
The Well-Grounded Rubyist, Fourth Edition
A Ruby namespace is a naming context that groups definitions and keeps names from different contexts distinct.
- How it is used
- Groups related definitions under nested names so similarly named classes, modules, or methods remain distinct.
- How deep it goes
- Explains nested definitions and `::` lookup, contrasts flattened names, and notes that notation alone cannot identify a class, module, or constant.
- Examples
- Uses `Tools::Hammer` and `Piano::Hammer`, plus Rake tasks named `admin:clean_tmp` and `admin:clean:tmp`.
- What you can do after
- Build nested class or module definitions and refer to a nested class using `::`.
Read how The Well-Grounded Rubyist, Fourth Edition explains namespace →
Related concepts
- namespace collisionaddresses · A namespace collision occurs when distinct software entities use the same identifier within a shared naming scope, causing ambiguity or conflict.
- local namespaceincludes · A local namespace is the mapping of names to objects within a particular local scope, such as an executing function or code block.
- moduleproduced by · A module is a distinct, bounded software unit that groups related code or functionality and provides an organizational or interaction boundary within a larger system.
- scopeused by · Scope is the region of a program in which names are visible and can be resolved according to the language’s lookup rules.
- dir()used by · dir() is a Python built-in function that returns names available in a namespace or attributes associated with an object, module, or type.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.