재사용성

작성자

익명

작성일

2026.08.12

조회수

버전

재사용성 소프트웨어 공학 SOLID 원칙 디자인 패턴 모듈화 결합도와 응집도 인터페이스 기반 설계 중급

재사용성 (Reusability)

1. 개요

재사용성(Reusability)이란 소프트웨어 공학에서 이미 개발된 코드, 모듈, 설계 또는 문서 등의 자산을 새로운 시스템이나 동일 시스템의 다른 부분에서 수정 없이 또는 최소한의 수정만으로 다시 사용할 수 있는 '능력(Capability)'이자, 이를 통해 개발 효율을 높이는 '실천 방식(Practice)'을 의미한다.

현대 소프트웨어 개발 환경은 시스템의 규모가 거대해지고 요구사항의 변경 주기가 매우 짧아졌다. 모든 기능을 매번 처음부터 개발(Scratch development)하는 것은 막대한 비용과 시간을 소모하며, 검증되지 않은 코드를 반복 작성함으로써 버그 발생 가능성을 높인다. 따라서 검증된 자산을 재사용함으로써 개발 생산성을 높이고, 소프트웨어의 전반적인 품질과 신뢰성을 확보하는 것이 현대 개발 프로세스의 핵심 가치이다.

2. 재사용성의 수준과 유형

재사용은 단순히 코드 몇 줄을 복사하는 수준부터 시스템 전체의 구조를 정의하는 프레임워크 수준까지 다양한 계층에서 이루어진다.

재사용 수준	단위	특징	예시
코드 수준	함수, 메서드	가장 작은 단위의 재사용. 특정 기능을 수행하는 로직의 반복 사용.	유틸리티 함수 (DateFormatter, StringUtils)
모듈/컴포넌트 수준	클래스, 패키지, UI 컴포넌트	독립적인 기능을 수행하는 논리적 단위. 인터페이스를 통해 외부와 소통.	React 공통 버튼 컴포넌트, 인증 모듈
설계 수준	[[디자인 패턴]]	특정 문제 상황에 대한 검증된 해결책(템플릿)을 적용.	싱글톤 패턴, 전략(Strategy) 패턴
프레임워크 수준	라이브러리 집합, 플랫폼	애플리케이션의 기본 골격을 제공하며, 개발자가 세부 로직을 채워 넣는 방식.	Spring Framework, Django, Flutter

3. 재사용성을 높이는 설계 원칙

재사용 가능한 소프트웨어를 설계하기 위해서는 코드의 독립성을 확보하고 변경에 유연하게 대응할 수 있는 구조를 갖춰야 한다. 이는 소프트웨어 공학의 표준인 [[SOLID]] 원칙과 밀접하게 연관된다.

모듈화 (Modularity): 시스템을 서로 독립적인 작은 단위(모듈)로 나누는 것이다. 각 모듈이 명확한 책임과 역할을 가질 때 다른 프로젝트로의 이식이 쉬워진다.
캡슐화 (Encapsulation): 객체의 내부 구현 상세를 숨기고 필요한 인터페이스만을 외부에 노출하는 것이다. 내부 구현이 변경되어도 이를 사용하는 외부 코드에 영향을 주지 않아 재사용성이 향상된다.
낮은 [[결합도]] (Low Coupling): 모듈 간의 상호 의존성을 최소화하는 것이다. 특정 모듈을 수정하거나 교체할 때 다른 모듈에 미치는 영향이 적을수록 재사용하기 쉽다.
높은 [[응집도]] (High Cohesion): 하나의 모듈이 하나의 책임만을 가지며, 관련된 기능들이 밀접하게 모여 있는 상태를 말한다. 이는 [[SOLID]]의 단일 책임 원칙(SRP)과 직결되며, 응집도가 높을수록 모듈의 목적이 명확해져 재사용 시 예측 가능성이 높아진다.
확장성 (Extensibility): 기존 코드를 수정하지 않고 기능을 확장할 수 있어야 한다. 이는 [[SOLID]]의 개방-폐쇄 원칙(OCP)에 해당하며, 인터페이스나 추상 클래스를 통해 구현함으로써 재사용 가능한 구조를 완성한다.

4. 재사용성 구현 기법

기술적으로 재사용성을 구현하는 방법은 언어와 패러다임에 따라 다양하지만, 주로 다음과 같은 기법들이 사용된다.

4.1 상속과 합성 (Inheritance vs Composition)

상속은 부모 클래스의 기능을 물려받는 방식이며, 합성은 다른 객체를 자신의 멤버 변수로 포함하여 기능을 사용하는 방식이다. 현대 소프트웨어 설계에서는 유연성을 위해 '상속보다는 합성(Composition over Inheritance)'을 권장한다.

// [상속] - 강한 결합도, 부모 클래스 변경 시 자식 클래스 모두 영향
class Animal { void eat() { System.out.println("Eating..."); } }
class Dog extends Animal { void bark() { System.out.println("Barking..."); } }

// [합성] - 약한 결합도, 런타임에 동작 변경 가능
interface EatBehavior { void eat(); }
class NormalEat implements EatBehavior { public void eat() { System.out.println("Eating..."); } }
class FastEat implements EatBehavior { public void eat() { System.out.println("Eating quickly..."); } }

class Dog {
    private EatBehavior eatBehavior; // 합성을 통해 기능 주입
    
    public Dog(EatBehavior eb) { this.eatBehavior = eb; }
    
    // 전략 패턴을 적용하여 런타임에 동작(EatBehavior)을 교체 가능하게 함으로써 재사용성 극대화
    public void performEat() { eatBehavior.eat(); }
    public void setEatBehavior(EatBehavior eb) { this.eatBehavior = eb; }
}

4.2 제네릭 (Generics)

데이터 타입(Type)을 확정 짓지 않고 파라미터화하여, 다양한 타입에 대해 동일한 로직을 적용할 수 있게 하는 기법이다.

// 제네릭 예제: 어떤 타입의 배열이든 받아 첫 번째 요소를 반환하는 재사용 가능한 함수
function getFirstElement<T>(array: T[]): T | undefined {
    return array[0];
}

const numFirst = getFirstElement([1, 2, 3]); // T가 number로 결정
const strFirst = getFirstElement(["A", "B", "C"]); // T가 string으로 결정

4.3 인터페이스 기반 설계 (Interface-based Design)

구현체가 아닌 인터페이스(추상화된 규격)에 의존하게 함으로써, 내부 구현이 바뀌더라도 사용하는 쪽의 코드를 수정할 필요가 없게 만드는 설계 방식이다.

// 인터페이스 정의
interface MessageSender {
    void send(String message);
}

// 다양한 구현체 (재사용 가능한 부품들)
class EmailSender implements MessageSender {
    public void send(String msg) { System.out.println("Sending Email: " + msg); }
}
class SmsSender implements MessageSender {
    public void send(String msg) { System.out.println("Sending SMS: " + msg); }
}

// 사용하는 쪽은 인터페이스에만 의존 (구현체가 바뀌어도 코드 수정 없음)
class NotificationService {
    private final MessageSender sender;
    public NotificationService(MessageSender sender) { this.sender = sender; }
    public void notifyUser(String msg) { sender.send(msg); }
}

5. 라이브러리 및 패키지 관리

재사용된 코드를 효율적으로 배포하고 관리하기 위해 현대 개발 환경에서는 패키지 매니저를 활용한다.

패키지 매니저 (Package Manager): 외부 라이브러리의 설치, 업데이트, 의존성 해결을 자동화하는 도구이다. (예: npm, Maven, Gradle, PyPI, NuGet)
버전 관리 (Versioning): 시맨틱 버전닝(Semantic Versioning, SemVer)을 통해 Major.Minor.Patch 형태로 버전을 관리하여, 재사용하는 측에서 하위 호환성 여부를 판단할 수 있게 한다.
사내 프라이빗 저장소: 기업 내부에서 개발한 공통 모듈을 외부로 노출하지 않고 안전하게 공유하기 위해 Nexus나 Artifactory 같은 프라이빗 저장소를 운영하여 중앙 집중식으로 자산을 관리한다.

6. 재사용 자산의 문서화 (Documentation)

아무리 기술적으로 완벽하게 설계된 모듈이라도 사용법을 알 수 없다면 실제로 재사용될 수 없다. 문서화는 재사용성을 완성하는 마지막 단계이다.

API 문서화: Javadoc, Swagger, TSDoc 등을 사용하여 함수의 입력 파라미터, 반환 값, 예외 상황을 명확히 정의한다.
가이드라인 및 예제 제공: 'Quick Start' 가이드나 실제 적용 사례(Example Code)를 제공하여 사용자가 빠르게 도입할 수 있도록 돕는다.
변경 이력(Changelog) 관리: 버전 업데이트 시 변경된 사항과 마이그레이션 방법을 명시하여 재사용자의 혼란을 최소화한다.

7. 재사용성의 트레이드오프 (Trade-off)

재사용성을 지나치게 추구할 경우 다음과 같은 부작용이 발생할 수 있으며, 이는 설계 시 반드시 고려해야 할 요소이다.

과도한 일반화 (Over-generalization): 모든 상황에 맞추려다 보니 코드가 지나치게 추상화되어 가독성이 떨어지고 복잡도가 증가하는 현상이다. 불필요한 파라미터나 추상 계층이 늘어나 오히려 개발 속도가 저하될 수 있다.
의존성 지옥 (Dependency Hell): 재사용하는 라이브러리가 또 다른 라이브러리에 의존하고, 그 버전들이 서로 충돌하여 시스템이 불안정해지는 문제이다.
유지보수 비용의 전이: 공통 모듈의 작은 수정이 해당 모듈을 사용하는 수많은 서비스에 영향을 주어, 수정 시마다 방대한 양의 회귀 테스트(Regression Test)가 필요하게 된다.
런타임 성능 저하: 추상화 계층(인터페이스, 래퍼 클래스 등)이 많아질수록 간접 호출이 증가하여 미세한 성능 저하가 발생할 수 있다.

8. 재사용성 향상을 위한 테스트 전략

재사용 가능한 컴포넌트는 다양한 환경에서 동작해야 하므로 일반적인 코드보다 더 엄격한 테스트 전략이 필요하다.

단위 테스트 (Unit Testing): 모듈의 최소 단위가 독립적으로 정확히 동작하는지 검증한다. 특히 경계값 분석(Boundary Value Analysis)을 통해 다양한 입력값에 대응하는지 확인한다.
계약 테스트 (Contract Testing): 인터페이스의 입력과 출력 규격(Contract)이 준수되는지 테스트하여, 구현체가 바뀌어도 인터페이스를 사용하는 쪽에서 문제가 없음을 보장한다.
회귀 테스트 (Regression Testing): 공통 모듈 수정 후, 기존에 해당 모듈을 사용하던 다른 기능들이 망가지지 않았는지 확인하는 자동화 테스트 세트를 구축한다.

9. 산업계 재사용 사례 연구

실제 산업계에서는 다음과 같은 방식으로 재사용성을 극대화하고 있다.

디자인 시스템 (Design System): 토스(Toss), 구글(Material Design) 등은 UI 컴포넌트, 컬러 가이드, 타이포그래피를 표준화하여 '디자인 시스템'으로 구축한다. 이를 통해 디자이너와 개발자가 동일한 컴포넌트 라이브러리를 재사용함으로써 일관된 UX를 유지하고 개발 속도를 획기적으로 높인다.
[[MSA]]의 섀시 패턴 (Chassis Pattern): MSA 환경에서 각 서비스마다 공통적으로 필요한 로깅, 인증, 모니터링, 설정 관리 기능을 '서비스 섀시(Service Chassis)'라는 공통 프레임워크로 만들어 재사용한다. 이를 통해 개발자는 비즈니스 로직 구현에만 집중할 수 있다.

10. 재사용성 측정 및 평가 지표

재사용성을 정량적으로 평가하기 위해 다음과 같은 지표를 활용할 수 있다.

코드 중복률 (Code Duplication Rate): 정적 분석 도구(예: SonarQube)를 사용하여 전체 코드 중 중복된 비율을 측정한다. 중복률이 높을수록 재사용성이 낮음을 의미한다.
컴포넌트 활용 빈도 (Component Usage Frequency): 특정 공통 모듈이나 라이브러리가 전체 프로젝트 중 몇 군데에서 참조되고 있는지 측정한다.
수정 전파 범위 (Change Propagation Scope): 공통 모듈 하나를 수정했을 때 영향을 받는 클래스나 모듈의 개수를 측정하여 [[결합도]]를 평가한다.

📝 마크다운 원본

이 문서의 마크다운 원본 내용입니다.

# 재사용성 (Reusability)

## 1. 개요
**재사용성(Reusability)**이란 소프트웨어 공학에서 이미 개발된 코드, 모듈, 설계 또는 문서 등의 자산을 새로운 시스템이나 동일 시스템의 다른 부분에서 수정 없이 또는 최소한의 수정만으로 다시 사용할 수 있는 **'능력(Capability)'**이자, 이를 통해 개발 효율을 높이는 **'실천 방식(Practice)'**을 의미한다.

현대 소프트웨어 개발 환경은 시스템의 규모가 거대해지고 요구사항의 변경 주기가 매우 짧아졌다. 모든 기능을 매번 처음부터 개발(Scratch development)하는 것은 막대한 비용과 시간을 소모하며, 검증되지 않은 코드를 반복 작성함으로써 버그 발생 가능성을 높인다. 따라서 검증된 자산을 재사용함으로써 개발 생산성을 높이고, 소프트웨어의 전반적인 품질과 신뢰성을 확보하는 것이 현대 개발 프로세스의 핵심 가치이다.

## 2. 재사용성의 수준과 유형
재사용은 단순히 코드 몇 줄을 복사하는 수준부터 시스템 전체의 구조를 정의하는 프레임워크 수준까지 다양한 계층에서 이루어진다.

| 재사용 수준 | 단위 | 특징 | 예시 |
| :--- | :--- | :--- | :--- |
| **코드 수준** | 함수, 메서드 | 가장 작은 단위의 재사용. 특정 기능을 수행하는 로직의 반복 사용. | 유틸리티 함수 (DateFormatter, StringUtils) |
| **모듈/컴포넌트 수준** | 클래스, 패키지, UI 컴포넌트 | 독립적인 기능을 수행하는 논리적 단위. 인터페이스를 통해 외부와 소통. | React 공통 버튼 컴포넌트, 인증 모듈 |
| **설계 수준** | [[디자인 패턴]] | 특정 문제 상황에 대한 검증된 해결책(템플릿)을 적용. | 싱글톤 패턴, 전략(Strategy) 패턴 |
| **프레임워크 수준** | 라이브러리 집합, 플랫폼 | 애플리케이션의 기본 골격을 제공하며, 개발자가 세부 로직을 채워 넣는 방식. | Spring Framework, Django, Flutter |

## 3. 재사용성을 높이는 설계 원칙
재사용 가능한 소프트웨어를 설계하기 위해서는 코드의 독립성을 확보하고 변경에 유연하게 대응할 수 있는 구조를 갖춰야 한다. 이는 소프트웨어 공학의 표준인 [[SOLID]] 원칙과 밀접하게 연관된다.

*   **모듈화 (Modularity):** 시스템을 서로 독립적인 작은 단위(모듈)로 나누는 것이다. 각 모듈이 명확한 책임과 역할을 가질 때 다른 프로젝트로의 이식이 쉬워진다.
*   **캡슐화 (Encapsulation):** 객체의 내부 구현 상세를 숨기고 필요한 인터페이스만을 외부에 노출하는 것이다. 내부 구현이 변경되어도 이를 사용하는 외부 코드에 영향을 주지 않아 재사용성이 향상된다.
*   **낮은 [[결합도]] (Low Coupling):** 모듈 간의 상호 의존성을 최소화하는 것이다. 특정 모듈을 수정하거나 교체할 때 다른 모듈에 미치는 영향이 적을수록 재사용하기 쉽다.
*   **높은 [[응집도]] (High Cohesion):** 하나의 모듈이 하나의 책임만을 가지며, 관련된 기능들이 밀접하게 모여 있는 상태를 말한다. 이는 [[SOLID]]의 **단일 책임 원칙(SRP)**과 직결되며, 응집도가 높을수록 모듈의 목적이 명확해져 재사용 시 예측 가능성이 높아진다.
*   **확장성 (Extensibility):** 기존 코드를 수정하지 않고 기능을 확장할 수 있어야 한다. 이는 [[SOLID]]의 **개방-폐쇄 원칙(OCP)**에 해당하며, 인터페이스나 추상 클래스를 통해 구현함으로써 재사용 가능한 구조를 완성한다.

## 4. 재사용성 구현 기법
기술적으로 재사용성을 구현하는 방법은 언어와 패러다임에 따라 다양하지만, 주로 다음과 같은 기법들이 사용된다.

### 4.1 상속과 합성 (Inheritance vs Composition)
상속은 부모 클래스의 기능을 물려받는 방식이며, 합성은 다른 객체를 자신의 멤버 변수로 포함하여 기능을 사용하는 방식이다. 현대 소프트웨어 설계에서는 유연성을 위해 **'상속보다는 합성(Composition over Inheritance)'**을 권장한다.

```java
// [상속] - 강한 결합도, 부모 클래스 변경 시 자식 클래스 모두 영향
class Animal { void eat() { System.out.println("Eating..."); } }
class Dog extends Animal { void bark() { System.out.println("Barking..."); } }

// [합성] - 약한 결합도, 런타임에 동작 변경 가능
interface EatBehavior { void eat(); }
class NormalEat implements EatBehavior { public void eat() { System.out.println("Eating..."); } }
class FastEat implements EatBehavior { public void eat() { System.out.println("Eating quickly..."); } }

class Dog {
    private EatBehavior eatBehavior; // 합성을 통해 기능 주입
    
    public Dog(EatBehavior eb) { this.eatBehavior = eb; }
    
    // 전략 패턴을 적용하여 런타임에 동작(EatBehavior)을 교체 가능하게 함으로써 재사용성 극대화
    public void performEat() { eatBehavior.eat(); }
    public void setEatBehavior(EatBehavior eb) { this.eatBehavior = eb; }
}
```

### 4.2 제네릭 (Generics)
데이터 타입(Type)을 확정 짓지 않고 파라미터화하여, 다양한 타입에 대해 동일한 로직을 적용할 수 있게 하는 기법이다.

```typescript
// 제네릭 예제: 어떤 타입의 배열이든 받아 첫 번째 요소를 반환하는 재사용 가능한 함수
function getFirstElement<T>(array: T[]): T | undefined {
    return array[0];
}

const numFirst = getFirstElement([1, 2, 3]); // T가 number로 결정
const strFirst = getFirstElement(["A", "B", "C"]); // T가 string으로 결정
```

### 4.3 인터페이스 기반 설계 (Interface-based Design)
구현체가 아닌 인터페이스(추상화된 규격)에 의존하게 함으로써, 내부 구현이 바뀌더라도 사용하는 쪽의 코드를 수정할 필요가 없게 만드는 설계 방식이다.

```java
// 인터페이스 정의
interface MessageSender {
    void send(String message);
}

// 다양한 구현체 (재사용 가능한 부품들)
class EmailSender implements MessageSender {
    public void send(String msg) { System.out.println("Sending Email: " + msg); }
}
class SmsSender implements MessageSender {
    public void send(String msg) { System.out.println("Sending SMS: " + msg); }
}

// 사용하는 쪽은 인터페이스에만 의존 (구현체가 바뀌어도 코드 수정 없음)
class NotificationService {
    private final MessageSender sender;
    public NotificationService(MessageSender sender) { this.sender = sender; }
    public void notifyUser(String msg) { sender.send(msg); }
}
```

## 5. 라이브러리 및 패키지 관리
재사용된 코드를 효율적으로 배포하고 관리하기 위해 현대 개발 환경에서는 패키지 매니저를 활용한다.

*   **패키지 매니저 (Package Manager):** 외부 라이브러리의 설치, 업데이트, 의존성 해결을 자동화하는 도구이다. (예: npm, Maven, Gradle, PyPI, NuGet)
*   **버전 관리 (Versioning):** 시맨틱 버전닝(Semantic Versioning, SemVer)을 통해 `Major.Minor.Patch` 형태로 버전을 관리하여, 재사용하는 측에서 하위 호환성 여부를 판단할 수 있게 한다.
*   **사내 프라이빗 저장소:** 기업 내부에서 개발한 공통 모듈을 외부로 노출하지 않고 안전하게 공유하기 위해 Nexus나 Artifactory 같은 프라이빗 저장소를 운영하여 중앙 집중식으로 자산을 관리한다.

## 6. 재사용 자산의 문서화 (Documentation)
아무리 기술적으로 완벽하게 설계된 모듈이라도 사용법을 알 수 없다면 실제로 재사용될 수 없다. 문서화는 재사용성을 완성하는 마지막 단계이다.

*   **API 문서화:** Javadoc, Swagger, TSDoc 등을 사용하여 함수의 입력 파라미터, 반환 값, 예외 상황을 명확히 정의한다.
*   **가이드라인 및 예제 제공:** 'Quick Start' 가이드나 실제 적용 사례(Example Code)를 제공하여 사용자가 빠르게 도입할 수 있도록 돕는다.
*   **변경 이력(Changelog) 관리:** 버전 업데이트 시 변경된 사항과 마이그레이션 방법을 명시하여 재사용자의 혼란을 최소화한다.

## 7. 재사용성의 트레이드오프 (Trade-off)
재사용성을 지나치게 추구할 경우 다음과 같은 부작용이 발생할 수 있으며, 이는 설계 시 반드시 고려해야 할 요소이다.

1.  **과도한 일반화 (Over-generalization):** 모든 상황에 맞추려다 보니 코드가 지나치게 추상화되어 가독성이 떨어지고 복잡도가 증가하는 현상이다. 불필요한 파라미터나 추상 계층이 늘어나 오히려 개발 속도가 저하될 수 있다.
2.  **의존성 지옥 (Dependency Hell):** 재사용하는 라이브러리가 또 다른 라이브러리에 의존하고, 그 버전들이 서로 충돌하여 시스템이 불안정해지는 문제이다.
3.  **유지보수 비용의 전이:** 공통 모듈의 작은 수정이 해당 모듈을 사용하는 수많은 서비스에 영향을 주어, 수정 시마다 방대한 양의 회귀 테스트(Regression Test)가 필요하게 된다.
4.  **런타임 성능 저하:** 추상화 계층(인터페이스, 래퍼 클래스 등)이 많아질수록 간접 호출이 증가하여 미세한 성능 저하가 발생할 수 있다.

## 8. 재사용성 향상을 위한 테스트 전략
재사용 가능한 컴포넌트는 다양한 환경에서 동작해야 하므로 일반적인 코드보다 더 엄격한 테스트 전략이 필요하다.

*   **단위 테스트 (Unit Testing):** 모듈의 최소 단위가 독립적으로 정확히 동작하는지 검증한다. 특히 경계값 분석(Boundary Value Analysis)을 통해 다양한 입력값에 대응하는지 확인한다.
*   **계약 테스트 (Contract Testing):** 인터페이스의 입력과 출력 규격(Contract)이 준수되는지 테스트하여, 구현체가 바뀌어도 인터페이스를 사용하는 쪽에서 문제가 없음을 보장한다.
*   **회귀 테스트 (Regression Testing):** 공통 모듈 수정 후, 기존에 해당 모듈을 사용하던 다른 기능들이 망가지지 않았는지 확인하는 자동화 테스트 세트를 구축한다.

## 9. 산업계 재사용 사례 연구
실제 산업계에서는 다음과 같은 방식으로 재사용성을 극대화하고 있다.

*   **디자인 시스템 (Design System):** 토스(Toss), 구글(Material Design) 등은 UI 컴포넌트, 컬러 가이드, 타이포그래피를 표준화하여 '디자인 시스템'으로 구축한다. 이를 통해 디자이너와 개발자가 동일한 컴포넌트 라이브러리를 재사용함으로써 일관된 UX를 유지하고 개발 속도를 획기적으로 높인다.
*   **[[MSA]]의 섀시 패턴 (Chassis Pattern):** MSA 환경에서 각 서비스마다 공통적으로 필요한 로깅, 인증, 모니터링, 설정 관리 기능을 '서비스 섀시(Service Chassis)'라는 공통 프레임워크로 만들어 재사용한다. 이를 통해 개발자는 비즈니스 로직 구현에만 집중할 수 있다.

## 10. 재사용성 측정 및 평가 지표
재사용성을 정량적으로 평가하기 위해 다음과 같은 지표를 활용할 수 있다.

*   **코드 중복률 (Code Duplication Rate):** 정적 분석 도구(예: SonarQube)를 사용하여 전체 코드 중 중복된 비율을 측정한다. 중복률이 높을수록 재사용성이 낮음을 의미한다.
*   **컴포넌트 활용 빈도 (Component Usage Frequency):** 특정 공통 모듈이나 라이브러리가 전체 프로젝트 중 몇 군데에서 참조되고 있는지 측정한다.
*   **수정 전파 범위 (Change Propagation Scope):** 공통 모듈 하나를 수정했을 때 영향을 받는 클래스나 모듈의 개수를 측정하여 [[결합도]]를 평가한다.

AI 생성 콘텐츠 안내

이 문서는 AI 모델(gemma-4-31b)에 의해 생성된 콘텐츠입니다.

주의사항: AI가 생성한 내용은 부정확하거나 편향된 정보를 포함할 수 있습니다. 중요한 결정을 내리기 전에 반드시 신뢰할 수 있는 출처를 통해 정보를 확인하시기 바랍니다.

위키너와나