Essential Ideas Behind Effective Software Design, Explained

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

Essential Ideas Behind Effective Software Design

Software Engineering · Chapter 7: Behavioral Models and Requirements AnalysisSection 7.8 · lesson 54 of 1037 min · free with a free account

← How the Software Design Process WorksNext lesson: Designing Software the Object-Oriented Way →

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

Abstraction, modularity, information hiding, and functional independence.

  • Explain what makes a design good, not just working
  • Define abstraction, modularity, and information hiding
  • Define functional independence, via cohesion and coupling
  • Judge cohesion and coupling in a simple design

Transcript

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

Behavioral Models and Requirements Analysis

Essential Ideas Behind Effective Software Design

Two systems can both work correctly on the day they ship. Only one of them is still easy to understand and change a year later. What accounts for that difference? This section covers four ideas behind effective design. Abstraction, modularity, information hiding, and functional independence.

Working Isn't Enough

2 Systems, 1 Year Later

A design that produces correct output today is not automatically a good design. What separates a good design from one that merely works is how well it holds up afterward. How easily can someone understand it, extend it, and change one part of it, without breaking parts that seem unrelated? A handful of ideas keep showing up across software design as the vocabulary for judging that. They are abstraction, modularity, information hiding, and functional independence. None of them is a step-by-step process. They are qualities to design toward.

Abstraction

What It Does, Not How

Abstraction means describing something by what it does, rather than how it does it. A stack, for example, can be fully described by three operations. Push, pop, and peek. That says nothing about whether it is built on an array, or on a linked list, underneath. The benefit shows up the moment something needs to change. Because code using the stack only relies on push, pop, and peek, the implementation can be swapped without touching any of that code.

Modularity

Manageable Pieces

Modularity means dividing a system into separate, named pieces, called modules, each responsible for a distinct part of the work. Rather than one enormous program, a modular system is a collection of smaller pieces that can each be read, tested, and reasoned about largely on their own. Modularity and abstraction work together naturally. Each module presents an abstract interface to the rest of the system, which only needs to know that interface. So a developer can hold one module in their head at a time, rather than the whole system at once.

Information Hiding

Keeping Internal Decisions Private

Information hiding is the discipline of keeping a module's internal decisions private. Its data structures, algorithms, and implementation choices stay inside. Only what other parts genuinely need is exposed. The practical payoff is containment. If a module's internals are properly hidden, a change inside it, like switching a data structure, or rewriting an algorithm, stays inside that module. It does not ripple outward, into every piece of code that depended on how the module used to work.

Think About It

Abstraction vs. Information Hiding

Here is a question to think about. If abstraction and information hiding sound similar, what actually separates them? Abstraction is about what gets exposed. It describes something by its behavior, rather than its mechanics. Information hiding is about what gets deliberately concealed. Implementation decisions stay private, so the rest of the system cannot come to depend on them. In practice, good abstraction and good information hiding usually go together.

Table 1

Functional Independence

Functional independence is the goal that modularity, abstraction, and information hiding are all working toward. It means modules that can be understood, changed, and tested largely on their own. Two measures capture how close a design comes. Cohesion is how closely related the responsibilities inside a single module are. Aim for high cohesion, each module focused on one clear purpose. Coupling is how much one module depends on another's internal details. Aim for low coupling, with modules meeting through small, stable interfaces.

Figure 2

Cohesion and Coupling, Side by Side

Here are the two measures, side by side. On the left, each module does one clearly named thing. Validate order, calculate total, and apply discount. Each connection between them is single and simple. On the right, each module bundles two unrelated responsibilities, like validating an order and sending an email. And the modules are tangled together by several overlapping connections.

Reading Figure 2

Which Is Safer to Change?

So which design is safer to change? The design on the left. Touching calculate total gives no reason to affect apply discount. The design on the right is much riskier to touch. Validating an order has nothing to do with sending an email. And because of the tangle, a change to any one module's mixed responsibilities can easily affect several others.

Apply It

The OrderProcessor Module

Let's apply that. A module named order processor validates orders, sends confirmation emails, and generates shipping labels. And several other modules call directly into its internal helper functions. What is wrong with this design? It has low cohesion, because three unrelated responsibilities are bundled into one module. And it has high coupling, because other modules depend on its internal details, rather than a small, stable interface. Any change risks several unrelated jobs, and every module that reached inside.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. Abstraction describes what something does rather than how, so its implementation can change freely. Modularity divides a system into separate, named modules. Information hiding keeps a module's internal decisions, like its data structures and algorithms, private. Functional independence is a module being understandable, changeable, and testable largely on its own. Cohesion measures how focused a module's responsibilities are. And coupling measures how much one module depends on another's internal details.

Key Takeaways

What to Carry Forward

To pull this together. A good design holds up over time, staying understandable and changeable, not just correct on the day it ships. Abstraction lets an implementation change without affecting the code that uses it. Modularity divides a system into focused pieces that can be understood largely on their own. Information hiding keeps internal decisions private, containing the effect of any change. And functional independence means aiming for high cohesion, and low coupling.

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 Essential Ideas Behind Effective Software Design

What is the difference between abstraction and information hiding in software design?
Abstraction is about what gets exposed: describing something by what it does rather than how it does it. Information hiding is about what gets concealed: keeping a module's data structures, algorithms, and implementation choices private so other code cannot depend on them. A stack described only by push, pop, and peek is an abstraction, and keeping its array or linked list hidden is information hiding. Good designs usually use both together.
What is modularity in software engineering?
Modularity means dividing a system into separate, named pieces called modules, each responsible for a distinct part of the work. Instead of one enormous program, the system becomes smaller pieces that can be read, tested, and reasoned about largely on their own. Each module presents an abstract interface to the rest of the system, so a developer can focus on one module at a time instead of holding the whole system in mind.
What is functional independence in software design?
Functional independence means modules can be understood, changed, and tested largely on their own, and it is the goal that modularity, abstraction, and information hiding all work toward. It is judged with two measures: cohesion, how closely related the responsibilities inside one module are, and coupling, how much one module depends on another's internal details. A design aims for high cohesion and low coupling, with modules meeting through small, stable interfaces.
What makes a software design good rather than just working?
A good design holds up after it ships: it stays easy to understand, extend, and change without breaking parts that seem unrelated. Two systems can both produce correct output on launch day, yet only one may still be easy to modify a year later. Abstraction, modularity, information hiding, and functional independence are the qualities designers aim for to get that durability; they are qualities to design toward rather than a step-by-step process.

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 →