Constructing Software from Reusable Components (CBSE)

UPI Study › Courses › Software Engineering › Free lessons › Lesson 2.6 Free with a free account

Constructing Software from Reusable Components (CBSE)

Software Engineering · Chapter 2: Iterative, Incremental, and Specialized Process ModelsSection 2.6 · lesson 16 of 1037 min · free with a free account

← Assembling Systems: Integration and Configuration ApproachesNext lesson: Formal Techniques in Software Engineering: Concepts and Practice →

Earn 3 college credits for Software EngineeringRecommended for credit by NCCRS · Computer Science 301 · self-paced · one payment, lifetime access
Enroll in Software Engineering · $250 →Download the syllabus (PDF)

In this lesson

Component-based software engineering: 5 activities, and the trade-offs of reuse.

  • Define component-based software engineering, and the problem it solves
  • Describe the 5 CBSE activities in order
  • Distinguish qualifying a component from adapting one
  • Weigh the benefits of reuse against its risks

Transcript

Everything said in the video, section by section (855 words). Read along, or search it.

Iterative, Incremental, and Specialized Process Models

Building from Reusable Components

Most systems need things that countless other systems have already built. This section covers component-based software engineering, or C B S E, a process model for building systems from reusable pieces. Its five activities, the difference between qualifying and adapting a component, and the real trade-offs of reuse.

Why Rebuild What Exists?

Solved Problems, Solved Once

A team building a new system rarely needs to write a brand new way of handling logins, processing card payments, or showing a calendar. Reliable, well-tested pieces that solve exactly these problems already exist. Writing them again, from nothing, spends time and budget on a problem that has effectively already been solved. Component-based software engineering turns that observation into a process. A system is built largely by identifying existing, reusable components, and assembling them into the larger whole. A component here is a self-contained, independently deployable unit of functionality, with a defined interface. A team can acquire it, test it, and plug it in, without needing to understand or rewrite its internal code.

Where the Effort Goes

Not the End of Custom Code

C B S E does not eliminate custom development. Most real systems still need original code, for whatever makes them unique. What changes is where a team spends its effort. Instead of building everything, including parts that other systems have already solved, effort concentrates on assembling proven components correctly. And on building only the parts that are genuinely new.

Figure 2.6(a)

The 5 CBSE Activities

C B S E is organized around five recurring activities. Identify candidate components. Qualify them. Adapt them. Compose them into the system. And update the repository. It is drawn as a cycle for a reason. A component adapted or newly built on one project often becomes a candidate for reuse on the next. The dashed path, from updating the repository back to identifying candidates, is what makes C B S E a genuine cycle, rather than a one-time shortcut.

Activities 1 and 2

Identify, Then Qualify

The process begins by identifying candidates. The team searches for existing components that might satisfy part of the system's requirements, in the organization's own library, or from outside sources. This produces a pool of candidates, not a final decision. Each candidate is then qualified, evaluated against the system's real needs. Does its functionality genuinely match what is required? Is its interface compatible with the rest of the system? Does it meet expectations for performance and reliability? Suppose a team adopts a component without qualifying it, and it later behaves differently under real conditions. That is exactly what qualification exists to catch, before any component is relied upon.

Activities 3 to 5

Adapt, Compose, Update

A qualified component rarely fits perfectly without any changes. Adaptation covers the modifications, or the wrapping code, needed to make it work in this specific system, without altering what it fundamentally does. Composition then integrates the components into the system's architecture. This is where separate pieces start operating together, as one working system. Finally, components that were newly built, adapted, or simply proven useful are added back to the organization's repository. That makes them easier for future projects to find, and reuse. Notice the difference between the two middle words. Qualifying checks whether a candidate fits. Adapting is the work of making a qualified candidate actually fit.

Figure 2.6(b)

The Pool Narrows

A realistic pool of candidates narrows considerably on the way to a finished system. Identification produces a broad pool. During qualification, some are rejected, for the wrong functionality, an incompatible interface, or weak reliability. Some of the survivors still need adaptation before they can be used. So far fewer components end up in the finished system than the team started out considering.

Table 2.6

Every Benefit Has a Trade-Off

Building from reusable components is not a free win. It trades one set of risks for another. Development is faster, because proven functionality does not need rebuilding. But time must be spent qualifying candidates instead. Components have usually been used and tested elsewhere. But a track record does not guarantee they behave identically in a new context. Effort concentrates on what is unique to the system. But the system now depends on components it does not fully control, or fully understand. And imperfect fit is expected, because adaptation handles it. But adapted components can drift from their original, well-tested behavior. None of these trade-offs cancels the benefit. Each one complicates it, and is worth planning for.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. Component-based software engineering builds a system largely by assembling existing, reusable components. A component is a self-contained, independently deployable unit of functionality, with a defined interface. Qualification checks whether a candidate genuinely fits. Adaptation modifies or wraps it so that it does. Composition integrates the components into the system's overall architecture. And a component repository is the shared library that later projects search for candidates.

Key Takeaways

What to Carry Forward

To pull this together. C B S E builds a system largely by assembling existing, reusable components, rather than writing everything from scratch. Its five activities, identify, qualify, adapt, compose, and update the repository, form a repeating cycle across projects. Qualification checks whether a candidate fits. Adaptation is the work of making it fit. The pool of candidates narrows considerably by the time a system is composed. And reuse trades benefits like speed and prior testing for risks like external dependency and imperfect fit. Both sides are part of using the model well.

About Software Engineering at UPI Study

Software Engineering (Computer Science 301) is a self-paced online course of 103 video lessons in 15 chapters, from process models and agile to requirements, design, user interfaces, reliability, security and project management. It carries a NCCRS credit recommendation for 3 semester credits.

Every lesson transcript is free on pages like this one, and the videos are free with a free UPI Study account. Enrolling adds a practice quiz after each lesson, the graded work and final exam that earn the credit, lifetime access, and an official transcript on completion. UPI Study has helped over 130,000 students with college credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Enroll now → Course details Download the syllabus All Computer Science courses Every course with PRO →

Compare: Software Engineering vs Systems Analysis

Why take it here

Why students take Software Engineering with UPI Study

How professional software gets builtSoftware Engineering covers how teams turn requirements into working, maintainable software: process models, agile, requirements, design, testing, reliability and project management. It is a core course in computer science and software degrees.
Credit at a fraction of the priceThe same 3 credits can cost $750 or more at a US college. Here it is one payment, self-paced, with lifetime access.
Finish your degree soonerTransfer credits reduce the courses you still owe, so you can graduate earlier or lighten a heavy semester.
Strengthen an applicationA completed college-level course on an official transcript shows admissions and scholarship committees you can do the work.
Study on your own scheduleNo start dates, no deadlines. Watch the lessons, practice, and take the final when you are ready.
130,000+students helped with college creditsACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Where the credit goes

Universities that work with NCCRS

Software Engineering carries a NCCRS credit recommendation. These universities work with NCCRS; some are UPI Study's signed partners. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Thomas Edison State UniversityThomas Edison State UniversitySigned partnerUniversity of the PeopleUniversity of the PeopleSigned partnerCharter Oak State CollegeCharter Oak State CollegeSigned partnerStrayer UniversityStrayer UniversitySigned partnerColumbia Southern UniversityColumbia Southern UniversitySigned partnerIndiana TechIndiana TechSigned partnerPenn StatePenn StateWorks with NCCRSSouthern New Hampshire UniversitySouthern New Hampshire UniversityWorks with NCCRSSUNYSUNYWorks with NCCRS +many more cooperating universitiesFind my college →

Find my college → Not listed? Ask Athena in the corner of this page, or book a 15-minute call.

FAQ

Questions students ask us

About Constructing Software from Reusable Components (CBSE)

What is component-based software engineering (CBSE)?
Component-based software engineering is a process model that builds a system largely by identifying existing, reusable components and assembling them into the larger whole. A component is a self-contained, independently deployable unit of functionality with a defined interface. CBSE does not eliminate custom code; it concentrates effort on assembling proven pieces correctly and building only what is genuinely new.
What are the five activities of CBSE?
The five CBSE activities are identifying candidate components, qualifying them, adapting them, composing them into the system and updating the component repository. They form a cycle: components newly built, adapted or proven useful on one project are added back to the repository, where they become candidates for reuse on the next project, rather than a one-time shortcut.
What is the difference between qualifying and adapting a component?
Qualifying checks whether a candidate component fits, while adapting is the work of making a qualified component actually fit. Qualification evaluates functionality, interface compatibility, performance and reliability against the system's real needs. Adaptation then adds modifications or wrapping code so the component works in this specific system without changing what it fundamentally does.
What are the risks of building software from reusable components?
Reuse trades one set of risks for another. Time saved on building is partly spent qualifying candidates. A component's track record elsewhere does not guarantee identical behavior in a new context. The system comes to depend on components it does not fully control or understand. And adapted components can drift from their original, well-tested behavior. Each risk is worth planning for.

About the Software Engineering course

How many college credits is Software Engineering?
Software Engineering (Computer Science 301) carries a NCCRS credit recommendation for 3 semester credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.
How much does Software Engineering cost and what is included?
$250, paid once, with lifetime access: all 103 video lessons, a practice quiz after each, the graded work and final exam, and an official transcript when you finish. Students who want several courses choose UPI Study PRO instead.
Which universities accept UPI Study credits?
UPI Study has signed partner agreements with universities such as Thomas Edison State University, University of the People and Charter Oak State College, and works with universities such as Penn State, SNHU and SUNY. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities. Use "Find my college" on this page to check yours.
How long does Software Engineering take?
It is self-paced with no deadlines. The 103 lessons total about 11 hours of video; most students add reading and practice time and finish in a few weeks to a few months, on their own schedule.
How are the exams done?
Quizzes and assignments are online in the course. The final exam is taken online with proctoring; a person on the UPI Study team checks assignments, usually within two days.
How do my credits reach my college?
When the course shows 100% complete, request the official transcript from your dashboard. It is sent to the college you name, and you can send it to more than one. Check your college first with "Find my college" on this page, or ask Athena.

Ready for the full course? Earn 3 credits in Software Engineering.

103 video lessons, a quiz after each one, and the graded work that earns the credit. Recommended for credit by NCCRS.

Enroll in Software Engineering →Download the syllabusEvery course with PRO →
Software Engineering
3 credits · NCCRSEnroll →