Component-based software engineering

(Redirected from Component-oriented programming) Engineering focused on building software from reusable components

Component-based software engineering (CBSE), also called component-based development (CBD), is a style of software engineering that aims to construct a software system from components that are loosely-coupled and reusable. This emphasizes the separation of concerns among components.

To find the right level of component granularity, software architects have to continuously iterate their component designs with developers. Architects need to take into account user requirements, responsibilities and architectural characteristics.

Considerations

For large-scale systems developed by large teams, a disciplined culture and process is required to achieve the benefits of CBSE. Third-party components are often utilized in large systems.

The system can be designed visually with the Unified Modeling Language (UML). Each component is shown as a rectangle, and an interface is shown as a lollipop to indicate a provided interface and as a socket to indicate consumption of an interface.

Component-based usability testing is for components that interact with the end user.

References

George T. Heineman, William T. Councill (2001). Component-Based Software Engineering: Putting the Pieces Together. Addison-Wesley Professional, Reading 2001 ISBN 0-201-70485-4
Clemens Szyperski, Dominik Gruntz, Stephan Murer (2002). Component Software: Beyond Object-Oriented Programming. 2nd ed. ACM Press - Pearson Educational, London 2002 ISBN 0-201-74572-0
Fundamentals of Software Architecture: An Engineering Approach. O'Reilly Media. 2020. ISBN 978-1492043454.
Douglas C. Schmidt. "Why Software Reuse has Failed and How to Make It Work for You". Retrieved 14 May 2024.

Software engineering

Fields

Concepts

Orientations

Models

Developmental	Agile EUP Executable UML Incremental model Iterative model Prototype model RAD UP Scrum Spiral model V-model Waterfall model XP Model-driven engineering Round-trip engineering
Other	SPICE CMMI Data model ER model Function model Information model Metamodeling Object model Systems model View model
Languages	IDEF UML USL SysML

Imperative

Structured	Jackson structures Block-structured Modular Non-structured Procedural Programming in the large and in the small Design by contract Invariant-based Nested function
Object-oriented (comparison, list)	Class-based, Prototype-based, Object-based Agent Immutable object Persistent Uniform Function Call Syntax

Declarative

Functional (comparison)	Recursive Anonymous function (Partial application) Higher-order Purely functional Total Strict GADTs Dependent types Functional logic Point-free style Expression-oriented Applicative, Concatenative Function-level, Value-level
Dataflow	Flow-based Reactive (Functional reactive) Signals Streams Synchronous
Logic	Abductive logic Answer set Constraint (Constraint logic) Inductive logic Nondeterministic Ontology Probabilistic logic Query
DSL	Algebraic modeling Array Automata-based (Action) Command (Spacecraft) Differentiable End-user Grammar-oriented Interface description Language-oriented List comprehension Low-code Modeling Natural language Non-English-based Page description Pipes and filters Probabilistic Quantum Scientific Scripting Set-theoretic Simulation Stack-based System Tactile Templating Transformation (Graph rewriting, Production, Pattern) Visual

Concurrent,
distributed,
parallel

Metaprogramming

Attribute-oriented
Automatic (Inductive)
Dynamic
Extensible
Generic
Homoiconicity
Interactive
Macro (Hygienic)
Metalinguistic abstraction
Multi-stage
Program synthesis (Bayesian, Inferential, by demonstration, by example)
Reflective
Self-modifying code
Symbolic
Template

Separation
of concerns

Categories: