Module
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.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- How it is used
- Builds reproducible, composable infrastructure by grouping resources and sharing standardized configurations across environments and teams.
- How deep it goes
- Explains module boundaries, patterns, dependencies, testing, sharing, and release governance, with implementation examples but no complete provider-specific deployment.
- Examples
- Demonstrates network, subnet, server, database, load-balancer, and tags modules through Python, Terraform JSON, state outputs, repositories, and release workflows.
- What you can do after
- Builds and shares reusable modules, connects them through outputs, tests changes, and releases governed versions.
The Quick Python Book, Fourth Edition
- How it is used
- Organizes reusable Python code and keeps identically named objects distinct through module namespaces.
- How deep it goes
- Works through file creation, import forms, name access, search paths, and reload without detailing the import system's implementation.
- Examples
- Uses a circle-area module, qualified function calls, and a text-processing refactor into separate modules.
- What you can do after
- Build it from scratch: place related definitions in a Python file, import them from another file, and choose qualified or selective access.
Read how The Quick Python Book, Fourth Edition explains module →
Web Components in Action
- How it is used
- Uses modules to let Web Components import dependencies instead of making the page maintain a script tag for every component.
- How deep it goes
- Works through entry files, imports, exports, template separation, and a library wrapper; defers a deeper account of modules.
- Examples
- Builds a harp from imported component files, separates a business-card template, and wraps MIDI.js for sound.
- What you can do after
- Build it from scratch: load one component entry module, import its dependencies, and separate rendering into an importable template.
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
An application module is a Terraform module that contains the infrastructure configuration for an application.
- How it is used
- Packages application infrastructure for reuse and deployment across environments.
- How deep it goes
- Explains root-module arrangements, version selection, inputs, outputs, and the resource-graph caveat without detailing an application module’s full implementation.
- Examples
- Contrasts environment tfvars files with staging and production root modules, including a versioned registry call that outputs an application URL.
- What you can do after
- Operate/configure it by choosing a root-module arrangement and setting environment-specific inputs and module versions.
Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains module →
The Joy of JavaScript
A module system is a set of rules and mechanisms for organizing code into modules and controlling how they export and import bindings.
- How it is used
- Organizes application code into separately understandable files with explicit dependencies and exposed APIs.
- How deep it goes
- Works through dynamic patterns, ESM syntax, loading behavior, and tooling benefits, but defers loader configuration and build-tool specifics.
- Examples
- Contrasts CommonJS require with ESM import, then uses validation imports, conditional algorithm loading, and a bundler dependency tree.
- What you can do after
- Build it from scratch using ESM imports and exports, and evaluate static versus dynamic loading for an application's dependencies.
CSS in Depth, Second Edition
A module is a reusable, relatively small unit of page structure and styling that is independent of its surrounding page context.
- How it is used
- Organizes page styling into reusable units that can be assembled without tying their selectors to particular page locations.
- How deep it goes
- Develops class-based encapsulation through composition, naming, responsive behavior, and an isolated development workflow; treats dropdown JavaScript only briefly.
- Examples
- Builds a notification, composes a dropdown with a menu, and tests an image-and-text module in a narrow sidebar.
- What you can do after
- Build it from scratch: define focused, reusable CSS modules, compose them into pages, and document new ones in a pattern library.
Python Workout: 50 ten-minute exercises
- How it is used
- Promotes reuse, testing, maintainability, and abstraction when functionality serves multiple programs.
- How deep it goes
- Explains file structure, imports, namespaces, execution guards, packages, and selected implementation trade-offs.
- Examples
- Uses sales-tax and menu modules, import aliases, selective imports, __all__, and direct-execution tests.
- What you can do after
- Build it from scratch, import it into programs, control direct execution, organize packages, and publish them with Poetry.
Read how Python Workout: 50 ten-minute exercises explains module →
Elixir in Action, Third Edition
A module is a named unit of Elixir code that groups functions and other definitions for compilation and loading.
- How it is used
- Organizes small Elixir functions into named units that can be compiled, loaded, called, and assembled into OTP applications.
- How deep it goes
- Explains definition syntax, naming, imports, aliases, compilation, bytecode loading, and runtime lookup without becoming a full language reference.
- Examples
- Uses Geometry, Geometry.Rectangle, IO, iex, .ex source files, and compiled .beam files to demonstrate module organization and invocation.
- What you can do after
- Build it from scratch using defmodule and def, compile it, load it in iex, and call its functions through qualified or aliased names.
Simple Object-Oriented Design: Create clean, maintainable applications
A module is a separately organized application unit containing its own domain model and related components.
- How it is used
- Organizes large business systems into independently evolving components that collaborate through clear contracts.
- How deep it goes
- Develops domain boundaries, interface design, compatibility, extension points, and dependency monitoring without prescribing one architecture.
- Examples
- Uses Billing, Delivery, Inventory, Invoice, caching, registration APIs, and JUnit internal-class coupling as concrete cases.
- What you can do after
- Evaluate/understand module designs by checking domain ownership, API simplicity, client coupling, compatibility, and dependency growth.
Read how Simple Object-Oriented Design: Create clean, maintainable applications explains module →
The Well-Grounded Rubyist, Fourth Edition
A module is a Ruby construct that groups constants, methods, and other definitions under a namespace and can provide reusable behavior.
- How it is used
- Organizes shared object behavior without requiring classes to share a superclass, and keeps nested names separate.
- How deep it goes
- Works through definition, inclusion, lookup, extension, namespaces, and inclusion callbacks, while treating the mechanics of extend only preliminarily.
- Examples
- Uses a greeting mixin, stacklike behavior, temperature conversion, nested class names, and an inclusion callback.
- What you can do after
- Build it from scratch: define reusable Ruby behavior, mix it into classes, and use modules to separate namespaces.
Read how The Well-Grounded Rubyist, Fourth Edition explains module →
Learn AI-Assisted Python Programming, Second Edition
- How it is used
- Uses modules to extend Python for data processing, visualization, automation, file formats, websites, games, and other specialized tasks.
- How deep it goes
- Defines purpose-specific code collections and demonstrates importing and calling them, without descending into internal implementation.
- Examples
- Uses csv for NFL statistics, zipfile for multiple CSV files, and module tables covering visualization, data processing, and machine learning.
- What you can do after
- Apply modules via Python import statements, identify installation requirements, and use their functions in practical programs.
Read how Learn AI-Assisted Python Programming, Second Edition explains module →
Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
A PowerShell module is a package that groups commands, functions, variables, and related resources for reuse.
- How it is used
- Packages focused PowerShell functions into reusable, discoverable commands for automation, testing, deployment, and optional publication.
- How deep it goes
- Descends from basic .psm1 creation through loading, reloading, manifests, exports, private helpers, discovery performance, and revision management.
- Examples
- Uses Get-MachineInfo, Set-TMServiceLogon, Get-DiskInfo, MyTools.psm1, database code, and PowerShell Gallery searches.
- What you can do after
- Build it from scratch as a discoverable script module, test its commands, control its public surface, and publish versioned revisions.
Learn Haskell by Example
A Haskell module is a source-code unit that groups related definitions and controls their visibility through imports and exports.
- How it is used
- Organizes related definitions into reusable library and executable units with controlled visibility.
- How deep it goes
- Explains declarations, path-based names, exports, imports, qualification, and re-exports, while deferring deeper compilation details.
- Examples
- Uses Lib and Main, Graph, a line-numbering library, and a Csv re-export module.
- What you can do after
- Build it from scratch by naming files, declaring modules, selecting exports, importing dependencies, and arranging reusable code.
Data-Oriented Programming: Reduce software complexity
A software unit that aggregates stateless functions separately from the data entities those functions manipulate.
- How it is used
- Organizes system functionality into API-facing groups while separating it from data entities.
- How deep it goes
- Defines stateless functions, explicit data arguments, usage-only module relations, and the contrast with implicit object state; defers polymorphism.
- Examples
- Uses a Library module containing search, borrowing, returning, blocking, login, and lending-list functions.
- What you can do after
- Build it from scratch by extracting functionality from requirements, grouping exposed functions, and passing manipulated data explicitly.
Read how Data-Oriented Programming: Reduce software complexity explains module →
Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond
A separate source file or file-level unit that encapsulates code and can be imported or exported as part of a larger program.
- How it is used
- Organizes reusable JavaScript logic into files that share selected values without relying on globals.
- How deep it goes
- Defines file scope, works through default and named exports and imports, and addresses browser bundling without detailing loader internals.
- Examples
- Uses a shared statistics function and separate game-interface files to illustrate private helpers and small module APIs.
- What you can do after
- Build it from scratch by separating logic into files, exporting needed values, importing them, and bundling browser code with Browserify.
Secrets of the JavaScript Ninja, Second Edition
A bounded unit of code used to organize and reuse program functionality.
- How it is used
- Organizes growing JavaScript programs into reusable, loosely coupled clusters while hiding implementation details.
- How deep it goes
- Works from the module pattern through AMD and CommonJS to ES6 export and import forms, with browser-compatibility guidance.
- Examples
- Uses a greeting module to test exported and private identifiers, plus exercises on valid imports and default exports.
- What you can do after
- Build it from scratch with the module pattern, or apply ES6 exports and imports to share selected functionality.
Read how Secrets of the JavaScript Ninja, Second Edition explains module →
Pro Angular 16
A module is a self-contained software unit that groups related functionality and can be incorporated into an application.
- How it is used
- Organizes file dependencies and configures root and optional feature groups in Angular applications.
- How deep it goes
- Works through file-level imports and exports and shows root-module configuration; defers details of decorator properties.
- Examples
- Uses named imports between TypeScript files, an `AppModule` listing, and an administration module that selects Angular Material features.
- What you can do after
- Build it from scratch by exporting and importing file features, then configuring a root or optional feature module.
Refactoring to Rust
Rust's module system organizes related items into modules and controls how code is named, accessed, and structured within crates.
- How it is used
- Organizes related crate items by purpose while controlling how other code names and accesses them.
- How deep it goes
- Works through inline and file declarations, imports, visibility, nesting, and paths, using compiler errors to motivate fixes.
- Examples
- Refactors a greeting program into input and output modules, then compares absolute and relative paths in a snack crate.
- What you can do after
- Build it from scratch: split a Rust crate into modules, expose needed items, and correct imports across them.
Practices of the Python Pro
- How it is used
- Organizes related code by concern and exposes selected functionality to other modules through imports.
- How deep it goes
- Explains files, namespaces, encapsulation, import forms, and organization, but stops short of package implementation.
- Examples
- Uses state-capital calculations, sales-tax and receipt files, shopping-cart decomposition, and layered application modules.
- What you can do after
- Build it from scratch by dividing code into concern-based .py files and importing required names explicitly.
Get Programming: Learn to code with Python
A separable software component, typically a file, that groups code and provides a limited unit of functionality.
- How it is used
- Uses modules to divide larger programs into manageable tasks that work together.
- How deep it goes
- Defines modules through inputs, tasks, and outputs, then describes independent environments; defers code examples of information passing.
- Examples
- Illustrates modules with a group research project and two Python files sharing class definitions.
- What you can do after
- Apply it via Python imports to use definitions from another file, and practice dividing larger tasks into reusable pieces.
Read how Get Programming: Learn to code with Python explains module →
Essential TypeScript 5, Third Edition
An ECMAScript module is a JavaScript module defined by the ECMAScript module system, with explicit imports and exports.
- How it is used
- Splits an application into files with explicit exported features and imported dependencies.
- How deep it goes
- Works through default and named imports and exports, then addresses Node.js and TypeScript configuration failures.
- Examples
- Uses a tax calculation, product utilities, and a TypeScript sum function with a generated-file import path.
- What you can do after
- Operate/configure ECMAScript modules in Node.js and TypeScript projects, then export and import functions between files.
Read how Essential TypeScript 5, Third Edition explains module →
Rust Servers, Services, and Apps
The Rust module system organizes code into named modules that provide separation and visibility boundaries.
- How it is used
- Organizes web-application functionality into Rust modules, separating handlers, database access, models, and state.
- How deep it goes
- Shows file restructuring, module declarations, imports, and exports through application code.
- Examples
- Uses an initial application module and later splits handlers into authentication and course modules.
- What you can do after
- Build application modules that separate authentication and course handlers, then import and configure their routes.
F# in Action: A Revised Edition of Get Programming with F#
A module is a language construct that groups related declarations such as data types, values, and functions under a named scope.
- How it is used
- Organizes domain types and the functions that act on them, especially when separating data from behavior.
- How deep it goes
- Defines module members, qualification, nesting, file constraints, and namespace trade-offs without detailing compiled implementation beyond static-class mapping.
- Examples
- Uses a retail Basket, a MyMaths utility with a Complicated submodule, and Domain, Logic, and Program application groups.
- What you can do after
- Apply it via F# modules to group types and functions, nest related functionality, and choose namespaces when multi-file hierarchies require them.
Read how F# in Action: A Revised Edition of Get Programming with F# explains module →
Julia as a Second Language
A module is a Julia namespace that groups related functions, types, constants, and other definitions.
- How it is used
- Groups related definitions so reusable functionality can be loaded and same-named functions can occupy separate namespaces.
- How deep it goes
- Defines modules and works through loading, namespace separation, multi-file organization, and function shadowing.
- Examples
- Uses Statistics functions, separate volume calculations, a multi-file geometry package, and an angle-arithmetic shadowing error.
- What you can do after
- Build it from scratch with `module` and `include`, and import existing functions before extending them.
Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
A module is a packaged unit of reusable code and related resources that can be loaded into a software environment.
- How it is used
- Extends PowerShell with reusable command sets for Azure and other PowerShell-enabled products.
- How deep it goes
- Defines modules, distinguishes them from snap-ins, and demonstrates discovery, installation, verification, and command lookup without covering implementation internals.
- Examples
- Uses the Az module, PowerShell Gallery searches, YAML conversion commands, and module inventory exercises.
- What you can do after
- Operate/configure modules by finding, reviewing, installing, verifying, and querying their commands.
Functional Design and Architecture: Examples in Haskell
A software module is a separately organized unit of code with a defined responsibility and boundary.
- How it is used
- Organizes code around encapsulated responsibilities and keeps domain, implementation, and asset dependencies separated.
- How deep it goes
- Descends from opaque types and smart constructors to export lists, reexports, project structure, and corrected cross-layer dependencies.
- Examples
- Uses an opaque Value type, smart constructor functions, an Andromeda project tree, and vendor-dependent versus corrected hardware modules.
- What you can do after
- Evaluate/understand module boundaries, hide representations, design export lists, and detect dependencies that mix implementation with assets.
Read how Functional Design and Architecture: Examples in Haskell explains module →
Learn Rust in a Month of Lunches
- How it is used
- Organizes growing Rust code, clarifies names, and limits which functions and types users can access.
- How deep it goes
- Defines modules and works through `mod`, `pub`, nested modules, and paths; file organization is only briefly introduced.
- Examples
- Uses a printing module and nested country, province, and city modules.
- What you can do after
- Apply Rust's `mod`, `pub`, and module paths to organize code and control access.
Deep Learning with PyTorch, Second Edition
A reusable network substructure made of a sequence of layers.
- How it is used
- Organizes convolutional network backbones into repeated sequences of convolutions, activations, and pooling.
- How deep it goes
- Defines a block and demonstrates its forward pass, stopping short of general module-system coverage.
- Examples
- Uses LunaBlock with two 3 × 3 Conv3d layers, ReLU activations, and MaxPool3d.
- What you can do after
- Build it from scratch by defining a reusable convolutional block with initialization and forward-processing logic.
Read how Deep Learning with PyTorch, Second Edition explains module →
The Well-Grounded Python Developer: How the pros use Python and Flask
A Python module organized for reuse by applications or other code.
- How it is used
- Organizes reusable functionality into namespaces and separates application domains for maintainable larger applications.
- How deep it goes
- Explains modular boundaries, namespaces, and application roles without detailing module creation syntax or import mechanics.
- Examples
- Uses a MyBlog application, URL endpoint modules, Flask Blueprints, and Python standard library modules as examples.
- What you can do after
- Build larger applications by separating related functionality into focused modules and namespaces.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains module →
Deep Learning with Python, Third Edition
A repeated architectural unit in the Transformer made from attention and feedforward sublayers.
- How it is used
- Organizes Transformer computation into repeated blocks that combine attention with feedforward processing.
- How deep it goes
- Defines modules through architectural repetition and identifies Transformer block composition, but does not detail sublayer implementation.
- Examples
- Uses stacked Transformer blocks and repeated ConvNet blocks, including Xception’s repeated convolution and pooling pattern.
- What you can do after
- Evaluate/understand architecture diagrams by identifying reusable blocks and their attention and feedforward roles.
Read how Deep Learning with Python, Third Edition explains module →
Rust in Action: Systems programming concepts and techniques
A module is a Rust language construct that groups related declarations and organizes a crate's source code.
- How it is used
- Organizes a crate’s source code by grouping related declarations and keeping tests alongside implementation.
- How deep it goes
- Defines file and inline modules, nesting, default privacy, visibility modifiers, and imports; stops short of extensive module-system use.
- Examples
- Uses a Q7 implementation, a nested tests module, use super::*, and cargo test output.
- What you can do after
- Apply Rust module syntax to split declarations, control visibility, and import items within a crate.
Read how Rust in Action: Systems programming concepts and techniques explains module →
Kotlin in Action, 2E
A module is a distinct unit of Kotlin compilation whose declarations share an internal visibility boundary.
- How it is used
- Uses compilation boundaries to hide implementation details while exposing selected Kotlin APIs.
- How deep it goes
- Defines modules and internal visibility, then contrasts them with file, class, package, and public boundaries.
- Examples
- Uses Gradle source sets, Maven projects, IntelliJ IDEA modules, and test access to main-source internal declarations.
- What you can do after
- Operate/configure module boundaries and choose internal visibility for implementation details.
Tiny Python Projects: Learn coding and testing with puzzles and games
- How it is used
- Uses Python files to share reusable functions across programs and to separate importable functionality from command-line execution.
- How deep it goes
- Explains importing, qualified names, and the __name__ guard, but stops short of module packaging or advanced import mechanics.
- Examples
- Demonstrates importing and calling stemmer() from rhymer.py in the REPL.
- What you can do after
- Apply modules by importing reusable functions and preventing command-line startup during imports.
Read how Tiny Python Projects: Learn coding and testing with puzzles and games explains module →
Code Like a Pro in Rust
- How it is used
- Organizes Rust code hierarchically, groups related functionality, and provides namespaces for symbols.
- How deep it goes
- Explains `mod` declarations, nested and file-backed modules, default privacy, and visibility modifiers such as `pub(crate)`.
- Examples
- Demonstrates nested module declarations, separate source files, public and private modules, and a `use` import.
- What you can do after
- Apply Rust `mod` and `pub` declarations to organize code and control symbol visibility.
Effective Platform Engineering
A Terraform module is a reusable package of Terraform configuration that groups resources and exposes configurable inputs and outputs.
- How it is used
- Uses reusable Terraform modules as targets for integration tests that verify provisioned resources, configuration, and acceptance criteria.
- How deep it goes
- Explains module testing through dedicated-account applies and configuration checks, but does not detail module construction.
- Examples
- Uses an AWS VPC module to configure managed-node subnet tags for Karpenter discovery and naming conventions.
- What you can do after
- Evaluate a reusable module by applying it in a dedicated cloud account or project and checking its resources and configuration.
Related concepts
- functionhas part · A function is a callable program unit that performs an operation, may accept inputs, and can produce a result or side effect.
- submoduleincludes · A submodule is a module nested within another module or package and scoped or distributed as part of its containing hierarchy.
- file objectkind of · A file object is a program-accessible representation of an open file or stream, including its access state and input/output operations.
- OTP releasepart of · An OTP release is a self-contained package of an Erlang or Elixir application together with the runtime components and configuration needed to run it.
- Kernelincludes · Kernel is Ruby's built-in module containing fundamental methods that are available to Object instances through inclusion in Object.
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.