Assembling Systems: Integration and Configuration Approaches

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

Assembling Systems: Integration and Configuration Approaches

Software Engineering · Chapter 2: Iterative, Incremental, and Specialized Process ModelsSection 2.5 · lesson 15 of 1038 min · free with a free account

← Parallel Workflows: Concurrent Development StrategiesNext lesson: Constructing Software from Reusable Components (CBSE) →

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

Big-bang vs. incremental integration, and knowing exactly what you are combining.

  • Define system integration as its own decision
  • Distinguish big-bang from incremental integration
  • Compare how easily each isolates a defect
  • Explain why integration depends on configuration awareness

Transcript

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

Iterative, Incremental, and Specialized Process Models

Assembling Systems

Separately excellent pieces of software do not automatically make a working system. This section covers the two basic strategies for combining pieces, big-bang and incremental integration. And the configuration awareness that either strategy depends on, knowing exactly which version of each piece you are combining.

3 Excellent Pieces

Integration Day Goes Wrong

Three teams each build one piece of a ride-sharing app, in isolation, for four months. The rider app, the driver app, and the matching engine that connects them. Each team demonstrates its own piece working flawlessly on its own. On the day everything is first combined, the driver app sends location updates in a format the matching engine does not recognize. The rider app expects a response field that was renamed weeks earlier. And nobody can say which version of the matching engine's interface any given test was even run against. Three separately excellent pieces took two more months to become one working system.

Integration as Its Own Decision

How the Pieces Come Together

System integration is the act of bringing separately built pieces, such as modules, components, or subsystems, together into a single, working system. It is a different question from the one iteration answers. How a process repeats, in cycles or in a single pass, is a decision about the shape of the whole effort. How the pieces actually get combined is a narrower, separate decision. And every process model eventually has to answer it. There are two basic answers. All at once, near the end. Or gradually, a few pieces at a time.

Figure 1

All at Once, or One at a Time

Here are the two strategies. At the top is big-bang integration. Every piece is built and tested separately, and combined all at once, near the end, in a single step. Teams can work with little coordination, and no shared integration environment is needed until that final step. But the first time the whole system runs together, is also the first time anyone can check that the pieces actually fit. At the bottom is incremental integration. Pieces are combined a few at a time, in a planned sequence. Each addition is tested against the growing system before the next piece is added, so the system is verified as a whole, throughout construction.

Table 1

Big-Bang vs. Incremental Integration

Here they are compared. Big-bang combines pieces once, near the end. Incremental combines them gradually, throughout construction. Under big-bang, integration defects surface all at once, at the final combination. Incrementally, they surface early, as each piece is added. Isolating a defect's source is difficult under big-bang, because many pieces were combined at once, and any of them could be the cause. Incrementally, it is straightforward. The pieces already combined were already working together, so only the newest piece is suspect. In return, big-bang has low coordination overhead, while incremental needs each addition sequenced and ready on time.

Table 2

How Each Strategy Fails

Each strategy invites its own failure modes. Big-bang invites a late whole-system surprise, because the system's first real test happens only after everything is combined. It invites defect misattribution, where time is lost checking innocent pieces before finding the real source. And it invites interface drift, where pieces are built against assumptions about an interface that quietly changed. Incremental integration, if overused, invites integration churn. Constant re-integration consumes more effort than it catches. Incremental integration is not free. It needs an integration environment maintained throughout, and closer coordination. Big-bang avoids that overhead, by concentrating all of the integration effort, and all of the risk, into one event.

Configuration Awareness

Know Exactly What You Are Combining

Whichever strategy a team uses, combining pieces reliably requires knowing exactly which version of each piece is being combined. A mismatched or outdated version is itself a common cause of integration failure, even when no piece contains a real defect. Three questions matter. Which version of each piece is in this build? Without an answer, a failure cannot be traced to a known cause. Has any piece changed since the last successful integration? Without an answer, every attempt starts from an unclear baseline. And can this exact combination be rebuilt later? Without that, a defect that appears once may never be reproduced, or fixed with confidence. This is configuration awareness at the level a process needs. The full formal discipline of controlling changes comes later in the course.

Table 4

When That Awareness Is Tested

The shape of the process changes when this awareness is tested most. A single pass with big-bang integration seems to get by with looser tracking, while pieces are built separately. But at the one final combination, every version must line up at once, with no earlier checkpoint to have caught a mismatch. One untracked mismatch can undo months of separately correct work. An iterative effort with incremental integration needs continuous tracking instead, because every combination has to be known and reproducible. Small mismatches surface quickly there, but only if the tracking is kept current. Neither strategy removes the need for configuration awareness. It only changes when the cost of lacking it is paid.

Judgment, Not Default

When Big-Bang Is Fine

As with iteration, neither strategy is right in general. Picture a team building a simple, two-piece integration, with one interface that has been contractually fixed and unchanged for years. It chooses incremental integration anyway, and spends significant ongoing effort maintaining an integration environment throughout construction. Incremental integration earns its overhead when pieces are numerous, interfaces are still settling, or isolating defects quickly really matters. Here, there was little of that uncertainty. A single, well-verified big-bang combination would likely have reached the same correct result, for less effort.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. System integration is bringing separately built pieces together into a single, working system. Big-bang integration combines every piece once, near the end. Incremental integration combines pieces gradually, testing each addition against the growing system. An integration environment is the shared setting where combined pieces are run and verified together. Configuration awareness is knowing which version of each piece makes up a given build. And a reproducible build is a combination whose exact composition is known, and can be assembled again with the same result.

Key Takeaways

What to Carry Forward

To pull this together. System integration, how separately built pieces are combined, is a decision distinct from the overall shape of the process. Big-bang integration combines every piece once, near the end. Incremental integration verifies the growing system after each addition. Incremental integration makes a defect's source far easier to find, but needs an ongoing environment and closer coordination. Big-bang avoids that overhead, but concentrates all the integration risk into a single, late event. And under either strategy, reliable integration depends on configuration awareness, knowing exactly which version of each piece is being combined.

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 Assembling Systems: Integration and Configuration Approaches

What is system integration in software engineering?
System integration is the act of bringing separately built pieces, such as modules, components or subsystems, together into a single working system. It is a separate decision from the overall shape of the process, such as whether work runs in cycles or one pass. Every process model must eventually choose how to combine pieces: all at once near the end, or gradually.
What is the difference between big-bang and incremental integration?
Big-bang integration builds and tests every piece separately, then combines them all at once near the end, while incremental integration combines pieces a few at a time and tests each addition against the growing system. Big-bang needs little coordination but surfaces defects late and all together. Incremental integration surfaces defects early but needs an ongoing integration environment and closer coordination.
Why is it easier to find bugs with incremental integration?
With incremental integration, the pieces already combined were already working together, so when a test fails, the newest piece is the prime suspect. Under big-bang integration, many pieces are combined at once and any of them could be the cause, which invites defect misattribution, where time is lost checking innocent pieces before finding the real source.
Why does configuration awareness matter for integration?
Configuration awareness, knowing exactly which version of each piece is in a build, matters because a mismatched or outdated version is a common cause of integration failure even when no piece has a real defect. Teams need to know each piece's version, whether anything changed since the last successful integration, and whether the exact combination can be rebuilt later to reproduce a defect.

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 →