Component
A software component is a modular part of a software system that encapsulates related functionality and interacts with other parts through defined boundaries.
React Quickly, Second Edition
A functional component is a React component defined as a JavaScript function that receives properties as its argument and returns user-interface output.
- How it is used
- Builds reusable UI pieces that can be nested and customized with props.
- How deep it goes
- Works through functional definitions, prop destructuring, and class-to-function conversion; leaves interacting gallery components for later treatment.
- Examples
- Uses a nested website menu and an image gallery to compare component definitions and property handling.
- What you can do after
- Build it from scratch as a functional component, pass props, nest instances, and convert a simple render-only class.
Build a Frontend Web Framework (From Scratch)
A modular application unit that can load data, execute lifecycle logic, and produce part of a user interface.
- How it is used
- Splits an application view into manageable, composable parts responsible for display and interaction.
- How deep it goes
- Builds from pure rendering functions toward component classes with render(), mount(), and unmount(); introduces independent state and lifecycle as later capabilities.
- Examples
- Uses a to-do application split into a form, list, and items, including input events and conditional item editing.
- What you can do after
- Build it from scratch as composable JavaScript rendering functions, then implement a basic class with rendering, mounting, and unmounting methods.
Read how Build a Frontend Web Framework (From Scratch) explains component →
Pro Angular 16
A component is a modular application building block that encapsulates a portion of user-interface structure and behavior.
- How it is used
- Structures Angular user interfaces into reusable blocks that manage templates and supply their bindings with data and logic.
- How deep it goes
- Works through class creation, decorator configuration, module declaration, host placement, component coordination, styling, and testing.
- Examples
- Uses a model-backed product count, separate product form and table components, and a service-backed message display.
- What you can do after
- Build it from scratch: define and register a component, attach it to a host element, and move a UI feature into its template.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A software component is a part of a software system that may range from a function or class to a service or entire system.
- How it is used
- Uses components to build Wardley value chains and to examine architectural change risk.
- How deep it goes
- Defines components as architectural building blocks, then elaborates mapping, evolution judgments, and coupling; does not provide implementation instructions.
- Examples
- Illustrates components with advertising-campaign applications, remote-working tools, and a group exercise that assesses evolution criteria.
- What you can do after
- Evaluate/understand it: place components on a Wardley Map, discuss uncertain evolution positions, and identify coupling-related change risks.
Build Financial Software with Generative AI (From Scratch)
A user interface component is a reusable software unit that encapsulates part of an application's visual structure and interaction behavior.
- How it is used
- Organizes a financial dashboard into reusable navigation, data-display, and image components.
- How deep it goes
- Defines components and walks through extraction, properties, state, presentation, and data-fetching trade-offs.
- Examples
- Uses a dashboard navigation refactor, an audit-record display, a company listing, and an image wrapper.
- What you can do after
- Apply it via React and Next.js to extract reusable UI pieces and decide where to fetch and present data.
Read how Build Financial Software with Generative AI (From Scratch) explains component →
React in Depth
A component is a self-contained software building block that provides a specific part of a user interface or application behavior.
- How it is used
- Uses components to organize reusable React UI, from a breakfast form to shared interface libraries.
- How deep it goes
- Works through a RadioGroup interface, child-component composition, and a re-render experiment rather than stopping at a definition.
- Examples
- Uses a breakfast-ordering RadioGroup and paired parent-rendering experiments to expose interface and rendering decisions.
- What you can do after
- Build it from scratch as a composable React UI element, then test its interactions and assess its rendering behavior.
Web Components in Action
A component is a reusable, standalone unit of interface code that combines structure, styling, behavior, and optionally a customization API.
- How it is used
- Uses reusable interface units to package structure, styling, behavior, and configuration for larger applications.
- How deep it goes
- Explains APIs, modules, reflection, styling boundaries, and event behavior through implementations, while deferring some internals as unchanged code.
- Examples
- Demonstrates configurable search and a modular slider with external attributes, templates, styling, event handlers, and mapped DOM elements.
- What you can do after
- Build it from scratch as a shareable custom element with a planned API, separated modules, configurable attributes, and reusable styling.
Microservices Patterns, Second Edition
A modular structural unit of a software system that groups related implementation or functionality.
- How it is used
- Uses components as deployable units for organizing subdomains and reasoning about application architecture.
- How deep it goes
- Defines component packaging and collaboration, compares partitioning options, and defers detailed partitioning decisions.
- Examples
- Compares single-component and multi-service arrangements for consumer, order, and delivery management.
- What you can do after
- Evaluate component partitioning and independent-deployment requirements against coordination and upgrade trade-offs.
Read how Microservices Patterns, Second Edition explains component →
Refactoring to Rust
A component is an isolated, reusable software unit that encapsulates a related portion of functionality, data, or user interface.
- How it is used
- Separates concerns into isolated UI units and coordinates state, actions, rendering, and data fetching.
- How deep it goes
- Defines components through React examples and Yew's create, update, and view methods, while deferring deeper Properties usage.
- Examples
- Uses React and Yew list components with pagination, paper-search results, loading states, links, and asynchronous updates.
- What you can do after
- Build it from scratch with React or Yew, connect state transitions to rendering, and mount a WebAssembly component in an application.
Design for Developers
A user interface component is a reusable, self-contained visual and interactive unit of a user interface.
- How it is used
- Uses reusable UI components to make repeated interface patterns consistent across pages and practical to implement.
- How deep it goes
- Explains components through repetition, scalability, performance, and maintenance, but stops short of framework-specific implementation.
- Examples
- Uses blog typography, hotel listings, orange Add to Bag buttons, and stock-status controls as repeated interface patterns.
- What you can do after
- Build it from scratch as a maintainable component system that serves minimal code and supports later iteration.
Vanilla Web
A self-contained software unit designed for use in multiple parts of an application or across applications.
- How it is used
- Organizes repeated interface features into reusable units with clear boundaries in a browser-native application.
- How deep it goes
- Works through custom-element registration, per-instance state, parameterization, and connection-time behavior; defers detailed lifecycle treatment and slots.
- Examples
- Uses a greeting element, independent counter buttons, rating widgets, and product-related elements.
- What you can do after
- Build it from scratch as a reusable custom element with independent state and an explicit consumer interface.
Think Like a CTO
A component is a distinct major part of a software system that contributes a defined capability or function.
- How it is used
- Frames components as units for software reuse, enterprise risk assessment, and architecture documentation.
- How deep it goes
- Defines components through business criticality and shows how to map and assess support needs, while leaving implementation logistics out of high-level diagrams.
- Examples
- Uses Linux, MySQL, Postgres, Firefox, Open Office, JQuery, Gson, and a File Microservice for profile photos.
- What you can do after
- Evaluate component risks and support gaps, and communicate system boundaries with a high-level architectural diagram.
Grokking Software Architecture
A component is a modular software unit that encapsulates related functionality and interacts with other units through defined boundaries.
- How it is used
- Replaces duplicated scorecards with reusable components that can be assembled to meet specific user requirements.
- How deep it goes
- Defines composability and explains component-level design through scorecards, cohesion, coupling, and architecture across scales.
- Examples
- Uses LEGO bricks, duplicated industry scorecards, and reusable Header and CashFlowAnalysisComponent blocks as examples.
- What you can do after
- Apply component composition to assemble scorecards from reusable units, building only the requirements unique to each one.
Read how Grokking Software Architecture explains component →
D3.js in Action, Third Edition
A component is a modular, reusable user-interface unit that encapsulates part of an application's structure or behavior.
- How it is used
- Organizes dashboards and visualizations into small, reusable units with focused responsibilities.
- How deep it goes
- Explains folder responsibilities and a Rectangle-to-BarChart decomposition, but does not cover component internals.
- Examples
- Uses dashboard folders, Rectangle.js, BarChart.js, Axis components, scatterplots, and bar charts as concrete examples.
- What you can do after
- Build reusable chart elements and compose them into a bar chart or complete visualization.
Read how D3.js in Action, Third Edition explains component →
Also covered in
- React Hooks in Action: With Suspense and Concurrent Mode
- Deep Learning with R, Third Edition
- Data-Oriented Programming: Reduce software complexity
- Build Python Web Apps with Streamlit
- Simple Object-Oriented Design: Create clean, maintainable applications
- Software Security for Developers
- .NET MAUI in Action
- Data Pipelines with Apache Airflow, Second Edition
- Build an AI Agent (From Scratch)
- Python How-To
- Tiny CSS Projects
- Functional Design and Architecture: Examples in Haskell
What to know first
- classA class is a programming-language construct that defines a type’s structure and behavior and provides a basis for creating or representing objects.
- HTMLHTML is the standard markup language for structuring content and elements in documents on the web.
- Document Object ModelThe Document Object Model is a platform-independent programming interface that represents a document as a structured tree of nodes and provides ways to access and modify its content and structure.
- JavaScriptJavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
Related concepts
- component templateuses · An Angular component template is declarative, HTML-based markup containing expressions and bindings that define a component’s rendered view.
- controllerincludes · A controller is a software component that receives input or requests and coordinates other components or operations to produce a response or change application state.
- directivekind of · A directive is a framework-specific instruction attached to markup that controls processing, rendering, or the behavior of an element or template.
- serviceincludes · A software service is a capability or set of operations made available to users or other software through a defined interaction boundary.
- pluginincludes · A plugin is a software component that extends a host application's capabilities through an extension or integration mechanism.
- React hookuses · A React Hook is a function-based API that enables function components to access state, effects, context, and other React capabilities.
Questions about component
What is component?
A software component is a modular part of a software system that encapsulates related functionality and interacts with other parts through defined boundaries.
Which Manning books explain component?
React Quickly, Second Edition, Build a Frontend Web Framework (From Scratch), Pro Angular 16, Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Build Financial Software with Generative AI (From Scratch), React in Depth, Web Components in Action, Microservices Patterns, Second Edition and 6 more.
What should I know before learning component?
Manning books that teach component usually introduce class, HTML, Document Object Model and JavaScript first.
What kinds of component are there?
Kinds of component include controller, service and plugin.
What is component a kind of?
Component is a kind of directive. A directive is a framework-specific instruction attached to markup that controls processing, rendering, or the behavior of an element or template.
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.













