정보처리기사 실기 완벽 대비 1편: 핵심 이론 총정리 — 소프트웨어 공학, DB, OS, 네트워크, 보안, 빈출 용어까지
정보처리기사 실기 완벽 대비 1편: 핵심 이론 총정리
시험 전략: 실기 시험은 단답형(12~13문제) + 서술형(7~8문제)로 구성되며, 60점 이상이면 합격이다. 코드 문제(2편)로 약 40~50점을 확보하고, 이론 용어로 나머지 점수를 채우는 것이 가장 효율적이다. 이 글에서는 매회 빠지지 않는 핵심 이론을 빈출 순서로 정리한다.
1장. 소프트웨어 공학
1.1 소프트웨어 생명주기 모델
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
┌─────────────────────────────────────────────────────────────────────┐
│ 소프트웨어 생명주기 모델 │
├──────────────────┬──────────────────────────────────────────────────┤
│ 모델 │ 핵심 특징 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 폭포수 │ 순차적 진행 (요구분석→설계→구현→테스트→유지보수)│
│ (Waterfall) │ 되돌아가기 어려움, 문서 중심 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 프로토타입 │ 시제품(프로토타입)을 먼저 만들어 요구사항 확인 │
│ (Prototype) │ 사용자 피드백 반영 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 나선형 │ 계획→위험분석→개발→평가 반복 │
│ (Spiral) │ ★ 위험 분석(Risk Analysis)이 핵심 │
│ │ 대규모 프로젝트에 적합 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 애자일 │ 짧은 반복(Sprint) 주기로 개발 │
│ (Agile) │ 변화에 유연, 고객 협력 중시 │
│ │ 종류: 스크럼, XP, 칸반, 린 │
├──────────────────┼──────────────────────────────────────────────────┤
│ V-모델 │ 폭포수 + 각 단계에 대응하는 테스트 단계 추가 │
│ │ 요구분석↔인수테스트, 설계↔통합테스트 │
└──────────────────┴──────────────────────────────────────────────────┘
1.2 애자일 (Agile) ★빈출
애자일 선언 4가지 핵심 가치:
- 프로세스·도구보다 개인과 상호작용
- 방대한 문서보다 동작하는 소프트웨어
- 계약 협상보다 고객 협력
- 계획 따르기보다 변화 대응
스크럼(Scrum) 핵심 용어 ★★★ 단답형 단골:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 스프린트(Sprint) │ 2~4주 단위의 반복 개발 주기 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 제품 백로그 │ 개발할 전체 요구사항 목록 (우선순위 정렬) │
│ (Product Backlog)│ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 스프린트 백로그 │ 이번 스프린트에서 처리할 작업 목록 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 스크럼 마스터 │ 프로세스 관리, 장애물 제거 담당 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 제품 책임자(PO) │ 제품 백로그 관리, 우선순위 결정 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 번다운 차트 │ 남은 작업량을 시각화한 그래프 │
│ (Burn-down Chart)│ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 속도(Velocity) │ 스프린트당 완료한 작업량 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 일일 스크럼 │ 매일 15분 이내 짧은 회의 (어제/오늘/장애물) │
│ (Daily Scrum) │ │
└──────────────────┴──────────────────────────────────────────────────┘
XP(eXtreme Programming) 핵심 기법 ★★★:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
┌──────────────────┬──────────────────────────────────────────────────┐
│ 기법 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 페어 프로그래밍 │ 두 명이 함께 코딩 (작성자 + 검토자) │
│ (Pair Prog.) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ TDD │ 테스트 먼저 작성 → 코드 구현 → 리팩토링 │
│ (테스트 주도 개발)│ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 리팩토링 │ 기능 변경 없이 코드 구조 개선 │
├──────────────────┼──────────────────────────────────────────────────┤
│ CI │ 지속적 통합, 코드를 자주 빌드·테스트 │
│ (지속적 통합) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 소규모 릴리즈 │ 짧은 주기로 소규모 배포 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 공동 코드 소유 │ 팀 전체가 모든 코드에 대한 책임을 공유 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 계획 게임 │ 사용자 스토리 기반 릴리즈 계획 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 단순 설계 │ 현재 필요한 것만 설계 (YAGNI) │
└──────────────────┴──────────────────────────────────────────────────┘
1.3 요구사항
1
2
3
4
5
6
7
8
9
10
11
12
┌──────────────────┬──────────────────────────────────────────────────┐
│ 구분 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 기능 요구사항 │ 시스템이 수행해야 할 기능 │
│ (Functional) │ 예: 로그인, 검색, 결제 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 비기능 요구사항 │ 품질, 제약 조건 │
│ (Non-Functional) │ 예: 응답시간 2초 이내, 보안, 성능 │
└──────────────────┴──────────────────────────────────────────────────┘
요구사항 개발 프로세스: 도출(Elicitation) → 분석(Analysis)
→ 명세(Specification) → 확인(Validation)
1.4 UML (Unified Modeling Language) ★★★
UML 다이어그램 분류:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
┌─────────────────────────────────────────────────────────────────────┐
│ UML 다이어그램 분류 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ [구조(정적) 다이어그램] — 시스템의 구조를 표현 │
│ • 클래스(Class) 다이어그램 ★ — 클래스 간 관계 │
│ • 객체(Object) — 특정 시점의 인스턴스 │
│ • 컴포넌트(Component) — 컴포넌트 간 의존관계 │
│ • 배치(Deployment) — 물리적 배치 구조 │
│ • 패키지(Package) — 패키지 간 관계 │
│ • 복합 구조(Composite Structure) │
│ │
│ [행위(동적) 다이어그램] — 시스템의 동작을 표현 │
│ • 유스케이스(Use Case) ★ — 사용자와 시스템 간 상호작용 │
│ • 시퀀스(Sequence) ★ — 객체 간 메시지 교환 순서 │
│ • 활동(Activity) — 업무 흐름 (순서도와 유사) │
│ • 상태(State) — 객체의 상태 변화 │
│ • 통신(Communication) — 객체 간 메시지 교환 (구조 중심) │
│ • 타이밍(Timing) — 시간에 따른 상태 변화 │
│ │
└─────────────────────────────────────────────────────────────────────┘
유스케이스 다이어그램 관계 ★★★:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌──────────────────┬──────────────────────────────────────────────────┐
│ 관계 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 포함 (Include) │ 반드시 실행되는 공통 기능 │
│ <<include>> │ 예: 결제 --include-→ 인증 │
│ │ (결제하려면 반드시 인증 필요) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 확장 (Extend) │ 조건에 따라 선택적으로 실행 │
│ <<extend>> │ 예: 결제 ←extend-- 할인적용 │
│ │ (할인 쿠폰이 있을 때만 실행) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 일반화 │ 부모-자식 관계 (상속) │
│ (Generalization) │ 예: 결제 ← 카드결제, 계좌이체 │
└──────────────────┴──────────────────────────────────────────────────┘
★ include: 기본 → 포함 (반드시), 점선 화살표
★ extend: 확장 → 기본 (선택적), 점선 화살표
클래스 다이어그램 관계:
1
2
3
4
5
6
7
8
9
10
11
12
13
┌──────────────────┬───────────────────┬───────────────────────────────┐
│ 관계 │ 표기 │ 설명 │
├──────────────────┼───────────────────┼───────────────────────────────┤
│ 연관 (Association)│ ──────── │ 서로 참조 │
│ 집합 (Aggregation)│ ◇──────── │ 전체-부분 (독립적 존재) │
│ 합성 (Composition)│ ◆──────── │ 전체-부분 (생명주기 동일) │
│ 일반화 │ ────▷ │ 상속 (is-a) │
│ 실체화 │ - - -▷ │ 인터페이스 구현 │
│ 의존 │ - - -→ │ 일시적 사용 관계 │
└──────────────────┴───────────────────┴───────────────────────────────┘
★ 집합(Aggregation): 빈 다이아몬드 ◇ → 부분이 독립 존재 (교수↔학과)
★ 합성(Composition): 채운 다이아몬드 ◆ → 부분이 전체에 종속 (심장↔사람)
1.5 디자인 패턴 ★★★ 매회 출제
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
┌─────────────────────────────────────────────────────────────────────┐
│ GoF 디자인 패턴 23개 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ [생성 패턴 5개] — 객체 생성 │
│ ┌────────────────┬───────────────────────────────────────────┐ │
│ │ Abstract Factory│ 관련 객체 가족을 생성하는 인터페이스 │ │
│ │ Builder │ 복잡한 객체를 단계별로 생성 │ │
│ │ Factory Method │ 객체 생성을 서브클래스에 위임 ★ │ │
│ │ Prototype │ 기존 객체를 복사(clone)하여 생성 │ │
│ │ Singleton ★★ │ 인스턴스가 오직 1개만 존재하도록 보장 │ │
│ └────────────────┴───────────────────────────────────────────┘ │
│ │
│ [구조 패턴 7개] — 클래스/객체 조합 │
│ ┌────────────────┬───────────────────────────────────────────┐ │
│ │ Adapter ★ │ 인터페이스 호환성 문제 해결 (변환기) │ │
│ │ Bridge │ 추상과 구현을 분리 │ │
│ │ Composite │ 트리 구조로 부분-전체 표현 │ │
│ │ Decorator ★ │ 객체에 동적으로 기능 추가 (래퍼) │ │
│ │ Facade ★ │ 복잡한 서브시스템의 단순한 인터페이스 │ │
│ │ Flyweight │ 공유로 메모리 절약 (경량 패턴) │ │
│ │ Proxy │ 접근 제어를 위한 대리 객체 │ │
│ └────────────────┴───────────────────────────────────────────┘ │
│ │
│ [행위 패턴 11개] — 객체 간 상호작용 │
│ ┌────────────────┬───────────────────────────────────────────┐ │
│ │ Observer ★★ │ 상태 변화를 자동 통보 (1:N 의존) │ │
│ │ Strategy ★ │ 알고리즘을 캡슐화하여 교체 가능 │ │
│ │ Template Method │ 알고리즘 골격 정의, 세부단계는 서브클래스 │ │
│ │ Command │ 요청을 객체로 캡슐화 │ │
│ │ State │ 상태에 따라 행위 변경 │ │
│ │ Chain of Resp. │ 요청을 처리할 객체를 체인으로 연결 │ │
│ │ Mediator │ 객체 간 통신을 중재자가 관리 │ │
│ │ Memento │ 객체 상태를 저장·복원 │ │
│ │ Visitor │ 구조 변경 없이 새 연산 추가 │ │
│ │ Iterator │ 내부 구조 노출 없이 순회 │ │
│ │ Interpreter │ 문법 규칙을 클래스로 표현 │ │
│ └────────────────┴───────────────────────────────────────────┘ │
│ │
│ ★ 시험에서 가장 자주 나오는 패턴: │
│ Singleton, Observer, Factory Method, Strategy, Adapter │
│ │
│ 암기 팁: │
│ 생성 — "생빌 프로 팩앱싱" (Builder, Prototype, Factory, Abstract, │
│ Singleton) │
│ 구조 — "구 어브컴데파플프" (Adapter, Bridge, Composite, Decorator,│
│ Facade, Flyweight, Proxy) │
│ 행위 — "행 옵스테커스체메 미비이인" (Observer, Strategy, Template, │
│ Command, State, Chain, Mediator, Memento, Visitor, │
│ Iterator, Interpreter) │
│ │
└─────────────────────────────────────────────────────────────────────┘
1.6 결합도(Coupling)와 응집도(Cohesion) ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
┌─────────────────────────────────────────────────────────────────────┐
│ 결합도 (낮을수록 좋음) ★ 순서 암기 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 좋음 ←──────────────────────────────────→ 나쁨 │
│ │
│ 자료 → 스탬프 → 제어 → 외부 → 공통 → 내용 │
│ Data Stamp Control External Common Content │
│ │
│ 암기: "자 스 제 외 공 내" (자스제외공내) │
│ │
│ • 자료: 파라미터로 단순 데이터만 전달 │
│ • 스탬프: 자료 구조(배열, 객체)를 전달 │
│ • 제어: 제어 요소(플래그)를 전달하여 흐름 제어 │
│ • 외부: 외부에서 정의된 데이터를 공유 │
│ • 공통: 전역 변수를 공유 │
│ • 내용: 다른 모듈 내부를 직접 참조/수정 │
│ │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ 응집도 (높을수록 좋음) ★ 순서 암기 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 나쁨 ←──────────────────────────────────→ 좋음 │
│ │
│ 우연 → 논리 → 시간 → 절차 → 통신 → 순차 → 기능 │
│ Coin. Logical Temporal Proc. Comm. Seq. Functional │
│ │
│ 암기: "우 논 시 절 통 순 기" (우논시절통순기) │
│ │
│ • 우연: 관련 없는 요소들이 한 모듈에 존재 │
│ • 논리: 유사한 성격의 요소를 모아놓음 (유형으로 분류) │
│ • 시간: 특정 시점에 함께 실행되는 요소 │
│ • 절차: 순서대로 실행되는 요소 │
│ • 통신: 같은 데이터를 사용하는 요소 │
│ • 순차: 한 요소의 출력이 다음 요소의 입력 │
│ • 기능: 하나의 기능만 수행 (가장 이상적) │
│ │
└─────────────────────────────────────────────────────────────────────┘
1.7 테스트 ★★★
테스트 레벨:
1
2
3
4
단위 테스트 → 통합 테스트 → 시스템 테스트 → 인수 테스트
(Unit) (Integration) (System) (Acceptance)
├ 알파: 개발자 환경에서 사용자가 테스트
└ 베타: 사용자 환경에서 사용자가 테스트
화이트박스 테스트 (구조 기반) — 내부 로직을 보고 테스트:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
┌──────────────────┬──────────────────────────────────────────────────┐
│ 기법 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 구문 커버리지 │ 모든 문장을 최소 1번 실행 │
│ (Statement) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 결정 커버리지 │ 모든 분기(if의 T/F)를 최소 1번 실행 │
│ (Decision/Branch)│ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 조건 커버리지 │ 개별 조건식의 T/F를 모두 실행 │
│ (Condition) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 조건/결정 │ 조건 + 결정 모두 만족 │
├──────────────────┼──────────────────────────────────────────────────┤
│ MC/DC │ 각 조건이 독립적으로 결정에 영향을 미침 확인 │
│ (변형 조건/결정) │ 항공/국방 등 안전 중요 시스템 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 기본 경로 │ McCabe 순환 복잡도 기반, 독립 경로 테스트 │
│ (Base Path) │ 순환 복잡도 V(G) = E - N + 2 │
└──────────────────┴──────────────────────────────────────────────────┘
블랙박스 테스트 (명세 기반) — 내부 모르고 입출력만 테스트:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌──────────────────┬──────────────────────────────────────────────────┐
│ 기법 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 동치 분할 │ 입력값을 유효/무효 클래스로 나누어 대표값 테스트 │
│ (Equivalence) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 경계값 분석 │ 경계값과 그 바로 위/아래 값 테스트 │
│ (Boundary) │ 예: 1~100이면 0,1,100,101 테스트 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 원인-결과 그래프 │ 입력 조건과 출력 결과의 관계를 그래프로 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 결정 테이블 │ 조건 조합에 따른 결과를 표로 정리 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 상태 전이 │ 상태 변화에 따른 동작 테스트 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 오류 추정 │ 경험 기반으로 오류 예상 후 테스트 │
└──────────────────┴──────────────────────────────────────────────────┘
통합 테스트 방법:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌──────────────────┬──────────────────────────────────────────────────┐
│ 방법 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 빅뱅(Big Bang) │ 모든 모듈을 한꺼번에 통합 테스트 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 하향식(Top-down) │ 상위 → 하위 순서로 통합 │
│ │ 스텁(Stub) 사용 ★ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 상향식(Bottom-up)│ 하위 → 상위 순서로 통합 │
│ │ 드라이버(Driver) 사용 ★ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 샌드위치 │ 하향식 + 상향식 동시 진행 │
└──────────────────┴──────────────────────────────────────────────────┘
★ 스텁(Stub): 하위 모듈 대체 (하향식에서 사용)
★ 드라이버(Driver): 상위 모듈 대체 (상향식에서 사용)
2장. 데이터베이스
2.1 관계 대수 ★★★ 매회 출제
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
┌─────────────────────────────────────────────────────────────────────┐
│ 관계 대수 연산자 │
├──────────────────┬──────────────────────────────────────────────────┤
│ 연산 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ σ (시그마) │ Selection (셀렉션): 행 선택 (WHERE) │
│ Select │ σ 조건(R) 예: σ age>20(학생) │
├──────────────────┼──────────────────────────────────────────────────┤
│ π (파이) │ Projection (프로젝션): 열 선택 (SELECT) │
│ Project │ π 속성(R) 예: π 이름,학과(학생) │
├──────────────────┼──────────────────────────────────────────────────┤
│ ⋈ (보타이) │ Join (조인): 두 릴레이션 결합 │
│ Join │ R ⋈ 조건 S │
├──────────────────┼──────────────────────────────────────────────────┤
│ ÷ (나누기) │ Division (디비전): R÷S │
│ Division │ S의 모든 튜플과 관련된 R의 튜플 추출 │
├──────────────────┼──────────────────────────────────────────────────┤
│ ∪ │ 합집합 (Union) │
│ ∩ │ 교집합 (Intersection) │
│ − │ 차집합 (Difference) │
│ × │ 카티션 곱 (Cartesian Product) │
└──────────────────┴──────────────────────────────────────────────────┘
★ σ = 행(가로) 선택, π = 열(세로) 선택 — 반드시 구분!
2.2 정규화 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
┌─────────────────────────────────────────────────────────────────────┐
│ 정규화 단계 │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ 비정규형 │
│ ↓ 도메인이 원자값 │
│ 1NF (제1정규형) │
│ ↓ 부분 함수 종속 제거 │
│ 2NF (제2정규형) │
│ ↓ 이행 함수 종속 제거 │
│ 3NF (제3정규형) │
│ ↓ 결정자이면서 후보키가 아닌 것 제거 │
│ BCNF (보이스-코드 정규형) │
│ ↓ 다치 종속 제거 │
│ 4NF │
│ ↓ 조인 종속 제거 │
│ 5NF │
│ │
│ 암기: "도부이결다조" (도메인→부분→이행→결정자→다치→조인) │
│ │
│ ★★★ 1NF~BCNF 가장 자주 출제: │
│ 1NF: 원자값 (반복 그룹 제거) │
│ 2NF: 완전 함수 종속 (부분 종속 제거) │
│ 3NF: 이행 종속 제거 (A→B→C이면 A→C 제거) │
│ BCNF: 모든 결정자가 후보키 │
│ │
└─────────────────────────────────────────────────────────────────────┘
2.3 이상 (Anomaly)
1
2
3
4
5
6
7
8
9
10
11
12
13
┌──────────────────┬──────────────────────────────────────────────────┐
│ 이상 종류 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 삽입 이상 │ 불필요한 데이터 없이는 삽입 불가 │
│ (Insertion) │ 예: 학과 정보 없이 학생 등록 불가 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 삭제 이상 │ 필요한 데이터까지 함께 삭제됨 │
│ (Deletion) │ 예: 유일한 학생 삭제 시 학과 정보도 소멸 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 갱신 이상 │ 일부만 수정하면 데이터 불일치 발생 │
│ (Update) │ 예: 학과명 변경 시 일부 행만 변경 │
└──────────────────┴──────────────────────────────────────────────────┘
→ 이상 현상을 해결하기 위해 정규화를 수행한다.
2.4 트랜잭션 ACID ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
┌──────────────────┬──────────────────────────────────────────────────┐
│ 특성 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ Atomicity │ 원자성: 전부 실행 or 전부 취소 (All or Nothing) │
│ (원자성) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ Consistency │ 일관성: 트랜잭션 전후 DB 상태 일관성 유지 │
│ (일관성) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ Isolation │ 격리성: 동시 트랜잭션 간 간섭 없음 │
│ (격리성) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ Durability │ 지속성: 커밋된 데이터는 영구적으로 보존 │
│ (지속성) │ │
└──────────────────┴──────────────────────────────────────────────────┘
2.5 SQL ★★★ (DDL / DML / DCL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌─────────────────────────────────────────────────────────────────────┐
│ SQL 분류 │
├──────────────────┬──────────────────────────────────────────────────┤
│ 분류 │ 명령어 │
├──────────────────┼──────────────────────────────────────────────────┤
│ DDL │ CREATE, ALTER, DROP, TRUNCATE │
│ (데이터 정의어) │ → 테이블 구조 정의/변경/삭제 │
├──────────────────┼──────────────────────────────────────────────────┤
│ DML │ SELECT, INSERT, UPDATE, DELETE │
│ (데이터 조작어) │ → 데이터 조회/삽입/수정/삭제 │
├──────────────────┼──────────────────────────────────────────────────┤
│ DCL │ GRANT, REVOKE │
│ (데이터 제어어) │ → 권한 부여/회수 │
├──────────────────┼──────────────────────────────────────────────────┤
│ TCL │ COMMIT, ROLLBACK, SAVEPOINT │
│ (트랜잭션 제어) │ → 트랜잭션 확정/취소/저장점 │
└──────────────────┴──────────────────────────────────────────────────┘
DDL 핵심 구문:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
-- 테이블 생성
CREATE TABLE 학생 (
학번 INT PRIMARY KEY,
이름 VARCHAR(20) NOT NULL,
학과 VARCHAR(30),
FOREIGN KEY(학과) REFERENCES 학과(학과명)
);
-- 컬럼 추가/수정/삭제
ALTER TABLE 학생 ADD 연락처 VARCHAR(15);
ALTER TABLE 학생 MODIFY 이름 VARCHAR(30);
ALTER TABLE 학생 DROP COLUMN 연락처;
-- 테이블 삭제
DROP TABLE 학생 CASCADE; -- 참조하는 다른 테이블도 함께 삭제
DROP TABLE 학생 RESTRICT; -- 참조하는 테이블이 있으면 삭제 거부
DCL 핵심 구문:
1
2
3
4
5
6
7
-- 권한 부여
GRANT SELECT, INSERT ON 학생 TO 홍길동 WITH GRANT OPTION;
-- WITH GRANT OPTION: 부여받은 권한을 다른 사용자에게도 부여 가능
-- 권한 회수
REVOKE SELECT ON 학생 FROM 홍길동 CASCADE;
-- CASCADE: 홍길동이 다른 사람에게 부여한 권한도 함께 회수
2.6 뷰(View)
1
2
3
4
5
6
7
8
9
10
11
12
-- 뷰 생성
CREATE VIEW 성적우수학생 AS
SELECT 학번, 이름, 평점 FROM 학생 WHERE 평점 >= 4.0;
-- 뷰 삭제
DROP VIEW 성적우수학생;
★ 뷰 특징:
• 논리적 테이블 (물리적 데이터 없음)
• 보안 (특정 컬럼만 노출)
• 독립성 (원본 테이블 변경 시 뷰도 자동 변경)
• DML 제약: 집계함수, GROUP BY, JOIN 뷰에서는 INSERT/UPDATE/DELETE 제한
2.7 인덱스
1
2
3
4
5
6
7
8
9
10
11
12
13
┌──────────────────┬──────────────────────────────────────────────────┐
│ 종류 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 클러스터드 인덱스│ 데이터가 인덱스 순서대로 물리적으로 정렬 │
│ (Clustered) │ 테이블당 1개만 가능 (보통 PK) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 넌클러스터드 │ 별도의 인덱스 페이지에 키 저장 │
│ (Non-Clustered) │ 테이블당 여러 개 가능 │
└──────────────────┴──────────────────────────────────────────────────┘
CREATE INDEX idx_학생_이름 ON 학생(이름);
CREATE UNIQUE INDEX idx_학생_학번 ON 학생(학번);
DROP INDEX idx_학생_이름;
3장. 운영체제
3.1 프로세스 스케줄링 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
┌─────────────────────────────────────────────────────────────────────┐
│ CPU 스케줄링 알고리즘 │
├──────────────────┬───────┬──────────────────────────────────────────┤
│ 알고리즘 │선점여부│ 설명 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ FCFS │비선점 │ 먼저 온 순서대로 처리 (선입선출) │
│ (First Come) │ │ 호위 효과(Convoy Effect) 발생 가능 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ SJF │비선점 │ 실행 시간이 가장 짧은 것 먼저 │
│ (Shortest Job) │ │ 기아(Starvation) 발생 가능 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ SRT │선점 │ SJF의 선점 버전 │
│ (Shortest Remain)│ │ 남은 시간이 더 짧은 프로세스 선점 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ 우선순위 │둘다 │ 우선순위가 높은 것 먼저 │
│ (Priority) │ │ 기아 → 에이징(Aging)으로 해결 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ RR │선점 │ 시간 할당량(Time Quantum)만큼 돌아가며 │
│ (Round Robin) │ │ 시분할 시스템에 적합 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ HRN │비선점 │ (대기시간+서비스시간)/서비스시간 │
│ (Highest Response│ │ 높은 값 우선, SJF 기아 문제 해결 │
│ Ratio Next) │ │ ★ 에이징 기법 적용 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ 다단계 큐 │선점 │ 여러 큐에 우선순위 배정 │
│ (MLQ) │ │ 큐 간 이동 불가 │
├──────────────────┼───────┼──────────────────────────────────────────┤
│ 다단계 피드백 큐 │선점 │ 큐 간 이동 가능 │
│ (MLFQ) │ │ 가장 일반적인 스케줄링 │
└──────────────────┴───────┴──────────────────────────────────────────┘
3.2 교착상태 (Deadlock) ★★★
교착상태 발생 조건 4가지 (모두 충족 시 발생):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
┌──────────────────┬──────────────────────────────────────────────────┐
│ 조건 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 상호 배제 │ 한 번에 하나의 프로세스만 자원 사용 │
│ (Mutual Excl.) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 점유와 대기 │ 자원을 보유한 채 다른 자원을 대기 │
│ (Hold & Wait) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 비선점 │ 다른 프로세스의 자원을 빼앗을 수 없음 │
│ (No Preemption) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 환형 대기 │ 프로세스들이 원형으로 서로의 자원을 대기 │
│ (Circular Wait) │ │
└──────────────────┴──────────────────────────────────────────────────┘
해결 방법: 예방(Prevention), 회피(Avoidance), 탐지(Detection), 회복(Recovery)
★ 회피: 은행가 알고리즘(Banker's Algorithm) — 안전 상태 유지
3.3 페이지 교체 알고리즘 ★★★ (계산 문제 출제)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
┌──────────────────┬──────────────────────────────────────────────────┐
│ 알고리즘 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ FIFO │ 가장 먼저 들어온 페이지를 교체 │
│ │ Belady's Anomaly 발생 가능 ★ │
├──────────────────┼──────────────────────────────────────────────────┤
│ LRU │ 가장 오래 사용하지 않은 페이지 교체 │
│ (Least Recently │ 가장 많이 사용되는 알고리즘 │
│ Used) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ LFU │ 사용 빈도가 가장 낮은 페이지 교체 │
│ (Least Frequently│ │
│ Used) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ OPT (최적) │ 가장 오랫동안 사용되지 않을 페이지 교체 │
│ (Optimal) │ 이론적으로 최적, 실제 구현 불가능 │
└──────────────────┴──────────────────────────────────────────────────┘
★ Belady's Anomaly: 프레임 수를 늘렸는데 오히려 페이지 부재 증가 (FIFO에서 발생)
4장. 네트워크
4.1 OSI 7계층 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
┌─────────────────────────────────────────────────────────────────────┐
│ OSI 7계층 │
├─────┬────────────────┬─────────────────┬────────────────────────────┤
│계층 │ 이름 │ 단위(PDU) │ 장비/프로토콜 │
├─────┼────────────────┼─────────────────┼────────────────────────────┤
│ 7 │ 응용(Application)│ 메시지/데이터│ HTTP, FTP, SMTP, DNS │
│ 6 │ 표현(Presentation)│ 메시지/데이터│ JPEG, MPEG, 암호화 │
│ 5 │ 세션(Session) │ 메시지/데이터 │ SSL/TLS, RPC │
│ 4 │ 전송(Transport) │ 세그먼트 │ TCP, UDP │
│ 3 │ 네트워크(Network)│ 패킷 │ IP, ICMP, 라우터 │
│ 2 │ 데이터링크(Data Link)│ 프레임 │ MAC, 스위치, 브리지 │
│ 1 │ 물리(Physical) │ 비트 │ 리피터, 허브, 케이블 │
└─────┴────────────────┴─────────────────┴────────────────────────────┘
암기: "아파서티네데물" (응표세전네데물)
4.2 주요 프로토콜 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
┌──────────────────┬──────────────────────────────────────────────────┐
│ 프로토콜 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ HTTP/HTTPS │ 웹 문서 전송 (80/443 포트) │
├──────────────────┼──────────────────────────────────────────────────┤
│ FTP │ 파일 전송 (20: 데이터, 21: 제어) │
├──────────────────┼──────────────────────────────────────────────────┤
│ SMTP │ 메일 전송 (25포트) │
│ POP3/IMAP │ 메일 수신 (110/143포트) │
├──────────────────┼──────────────────────────────────────────────────┤
│ DNS │ 도메인 → IP 변환 (53포트) │
├──────────────────┼──────────────────────────────────────────────────┤
│ DHCP │ IP 주소 자동 할당 │
├──────────────────┼──────────────────────────────────────────────────┤
│ ARP │ IP → MAC 주소 변환 ★ │
│ RARP │ MAC → IP 주소 변환 ★ │
├──────────────────┼──────────────────────────────────────────────────┤
│ SNMP │ 네트워크 장비 관리/모니터링 │
├──────────────────┼──────────────────────────────────────────────────┤
│ ICMP │ 오류 보고 (ping 명령어) │
└──────────────────┴──────────────────────────────────────────────────┘
4.3 라우팅 프로토콜
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌──────────────────┬──────────────────────────────────────────────────┐
│ 프로토콜 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ RIP │ 거리 벡터 방식, 홉 수 기준 (최대 15홉) │
│ │ 소규모 네트워크 │
├──────────────────┼──────────────────────────────────────────────────┤
│ OSPF │ 링크 상태 방식, 대규모 네트워크 │
│ │ 다익스트라 알고리즘 사용 │
├──────────────────┼──────────────────────────────────────────────────┤
│ BGP │ 경로 벡터 방식, AS(자율시스템) 간 라우팅 │
│ │ 인터넷 백본 라우팅 │
└──────────────────┴──────────────────────────────────────────────────┘
★ 라우팅 분류:
• IGP (내부): RIP, OSPF
• EGP (외부): BGP
4.4 IP 주소 ★
1
2
3
4
5
6
7
8
9
10
11
12
13
┌──────────────────┬──────────────────────────────────────────────────┐
│ 클래스 │ 범위 │
├──────────────────┼──────────────────────────────────────────────────┤
│ A 클래스 │ 0.0.0.0 ~ 127.255.255.255 (대규모 네트워크) │
│ B 클래스 │ 128.0.0.0 ~ 191.255.255.255 (중규모) │
│ C 클래스 │ 192.0.0.0 ~ 223.255.255.255 (소규모) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 사설 IP │ 10.x.x.x, 172.16~31.x.x, 192.168.x.x │
│ 루프백 │ 127.0.0.1 (자기 자신) │
└──────────────────┴──────────────────────────────────────────────────┘
서브넷 마스크: IP 주소에서 네트워크 부분과 호스트 부분을 구분
예: 255.255.255.0 → /24 (앞 24비트가 네트워크)
5장. 보안
5.1 보안 3요소 (CIA) ★★★
1
2
3
4
5
6
7
8
9
10
11
12
┌──────────────────┬──────────────────────────────────────────────────┐
│ 요소 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 기밀성 │ 인가된 사용자만 접근 가능 │
│ (Confidentiality)│ → 암호화 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 무결성 │ 비인가 수정 방지, 정보의 정확성 보장 │
│ (Integrity) │ → 해시, 전자서명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 가용성 │ 인가된 사용자가 필요 시 접근 가능 │
│ (Availability) │ → 이중화, 백업 │
└──────────────────┴──────────────────────────────────────────────────┘
5.2 암호화 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
┌─────────────────────────────────────────────────────────────────────┐
│ 암호화 방식 │
├──────────────────┬──────────────────────────────────────────────────┤
│ 방식 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 대칭키 (비밀키) │ 암호화 키 = 복호화 키 (같은 키) │
│ │ 빠름, 키 분배 문제 │
│ │ DES, 3DES, AES ★, SEED, ARIA │
├──────────────────┼──────────────────────────────────────────────────┤
│ 비대칭키 (공개키)│ 암호화 키 ≠ 복호화 키 (공개키/개인키 쌍) │
│ │ 느림, 키 분배 문제 해결 │
│ │ RSA ★, ECC, DSA │
├──────────────────┼──────────────────────────────────────────────────┤
│ 해시 함수 │ 단방향 (복호화 불가), 고정 길이 출력 │
│ │ 무결성 검증 │
│ │ MD5, SHA-256 ★, SHA-512 │
└──────────────────┴──────────────────────────────────────────────────┘
★ 대칭키: "DAS" (DES, AES, SEED)
★ 비대칭키: "RSA"
5.3 보안 공격 유형 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
┌──────────────────┬──────────────────────────────────────────────────┐
│ 공격 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ SQL Injection │ SQL 구문을 삽입하여 DB 조작 ★ │
├──────────────────┼──────────────────────────────────────────────────┤
│ XSS │ 악성 스크립트를 웹 페이지에 삽입 ★ │
│ (Cross-Site │ Stored/Reflected/DOM 유형 │
│ Scripting) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ CSRF │ 사용자의 인증 상태를 이용해 의도치 않은 요청 │
│ (Cross-Site │ │
│ Request Forgery)│ │
├──────────────────┼──────────────────────────────────────────────────┤
│ DoS / DDoS │ 서비스 거부 공격 (대량 트래픽으로 마비) │
│ │ SYN Flooding, Smurf, Land Attack 등 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 스니핑 (Sniffing)│ 네트워크 트래픽 도청 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 스푸핑 (Spoofing)│ IP/ARP/DNS 등을 위조하여 속임 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 세션 하이재킹 │ 유효한 세션을 가로채기 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 랜섬웨어 │ 데이터 암호화 후 금전 요구 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 키로거 │ 키보드 입력 기록 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 백도어 │ 시스템에 몰래 설치한 비밀 접근 경로 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 사회공학 │ 사람의 심리를 이용한 공격 (피싱, 스미싱 등) │
│ (Social Eng.) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 제로데이 │ 패치 이전 취약점을 이용한 공격 │
│ (Zero-day) │ │
└──────────────────┴──────────────────────────────────────────────────┘
DoS 공격 세부 유형:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
┌──────────────────┬──────────────────────────────────────────────────┐
│ 공격 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ SYN Flooding │ TCP 3-way handshake의 SYN만 대량 전송 │
│ │ 서버 대기 큐 고갈 │
├──────────────────┼──────────────────────────────────────────────────┤
│ Smurf │ ICMP 브로드캐스트 + 출발지 IP 위조 │
├──────────────────┼──────────────────────────────────────────────────┤
│ Land Attack │ 출발지 = 목적지 IP로 위조 │
├──────────────────┼──────────────────────────────────────────────────┤
│ Ping of Death │ 비정상적으로 큰 ICMP 패킷 전송 │
├──────────────────┼──────────────────────────────────────────────────┤
│ Teardrop │ IP 패킷 Fragment Offset 조작 │
└──────────────────┴──────────────────────────────────────────────────┘
5.4 접근 제어
1
2
3
4
5
6
7
8
9
10
11
12
┌──────────────────┬──────────────────────────────────────────────────┐
│ 방식 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ DAC │ 임의적 접근 제어 (소유자가 권한 부여) │
│ (Discretionary) │ 신분(Identity) 기반 │
├──────────────────┼──────────────────────────────────────────────────┤
│ MAC │ 강제적 접근 제어 (시스템이 결정) │
│ (Mandatory) │ 보안 등급(Label) 기반, 군사 시스템 │
├──────────────────┼──────────────────────────────────────────────────┤
│ RBAC │ 역할 기반 접근 제어 │
│ (Role-Based) │ 역할(Role)에 권한 부여, 가장 일반적 │
└──────────────────┴──────────────────────────────────────────────────┘
6장. 빈출 핵심 용어 사전 ★★★
단답형에서 용어를 물어보는 문제가 매회 5~7개 출제된다. 아래 용어만 외워도 상당 부분 대응 가능하다.
6.1 소프트웨어 공학 용어
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 형상 관리 │ SW 변경사항을 체계적으로 추적·통제 │
│ (SCM) │ 도구: Git, SVN, CVS │
├──────────────────┼──────────────────────────────────────────────────┤
│ 리팩토링 │ 기능 변경 없이 코드 구조 개선 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 클린 코드 │ 가독성 높고 단순하며 의존성 낮은 코드 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 코드 스멜 │ 리팩토링이 필요한 나쁜 코드 징후 │
│ (Code Smell) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 기술 부채 │ 빠른 개발을 위해 미룬 기술적 결함 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 워크스루 │ 검토자들이 사전 검토 후 회의에서 결함 발견 │
│ (Walkthrough) │ 비공식 검토 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 인스펙션 │ 공식적, 체계적 검토 (체크리스트 사용) │
│ (Inspection) │ 중재자(Moderator)가 진행 │
├──────────────────┼──────────────────────────────────────────────────┤
│ CASE 도구 │ SW 개발 자동화 도구 │
│ │ 상위: 요구분석·설계, 하위: 구현·테스트 │
├──────────────────┼──────────────────────────────────────────────────┤
│ EAI │ 기업 내 이기종 시스템 통합 │
│ │ Point-to-Point, Hub&Spoke, │
│ │ Message Bus ★, ESB │
├──────────────────┼──────────────────────────────────────────────────┤
│ FTR │ 공식 기술 검토 (Formal Technical Review) │
└──────────────────┴──────────────────────────────────────────────────┘
6.2 신기술/IT 용어 ★★★
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 클라우드 컴퓨팅 │ 인터넷으로 IT 자원을 제공하는 서비스 │
│ │ IaaS(인프라), PaaS(플랫폼), SaaS(소프트웨어) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 블록체인 │ 분산 원장 기술, P2P로 데이터 무결성 보장 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 디지털 트윈 │ 물리적 객체를 가상으로 복제하여 시뮬레이션 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 엣지 컴퓨팅 │ 데이터 발생 지점(엣지)에서 처리 (지연시간↓) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 포그 컴퓨팅 │ 클라우드와 엣지의 중간 계층 처리 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 메시 네트워크 │ 노드가 서로 직접 연결된 그물망 네트워크 │
├──────────────────┼──────────────────────────────────────────────────┤
│ SDN │ 소프트웨어로 네트워크를 제어 (HW 분리) │
├──────────────────┼──────────────────────────────────────────────────┤
│ NFV │ 네트워크 기능을 가상화 (범용 서버에서 실행) │
├──────────────────┼──────────────────────────────────────────────────┤
│ DevOps │ 개발(Dev) + 운영(Ops) 협업 문화 │
├──────────────────┼──────────────────────────────────────────────────┤
│ MSA │ 서비스를 작은 독립 단위로 분리 │
│ (마이크로서비스) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ Docker │ 컨테이너 기반 가상화 플랫폼 │
├──────────────────┼──────────────────────────────────────────────────┤
│ Kubernetes │ 컨테이너 오케스트레이션 도구 │
├──────────────────┼──────────────────────────────────────────────────┤
│ CI/CD │ 지속적 통합(CI) + 지속적 배포(CD) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 데이터 마이닝 │ 대량 데이터에서 유용한 패턴 발견 │
├──────────────────┼──────────────────────────────────────────────────┤
│ ETL │ 추출(Extract) → 변환(Transform) → 적재(Load) │
├──────────────────┼──────────────────────────────────────────────────┤
│ MQTT │ IoT 경량 메시지 프로토콜 (발행/구독 모델) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 그레이웨어 │ 악성은 아니지만 불쾌한 소프트웨어 (애드웨어 등) │
├──────────────────┼──────────────────────────────────────────────────┤
│ APT │ 지능형 지속 위협 (특정 대상 장기 공격) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 제로 트러스트 │ 내/외부 구분 없이 항상 검증 │
│ (Zero Trust) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 매시업 │ 여러 API/데이터를 조합해 새 서비스 생성 │
│ (Mashup) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 시맨틱 웹 │ 기계가 이해할 수 있는 의미 기반 웹 │
├──────────────────┼──────────────────────────────────────────────────┤
│ AJAX │ 비동기 JavaScript + XML, 페이지 새로고침 없이 │
│ │ 서버와 통신 │
├──────────────────┼──────────────────────────────────────────────────┤
│ OAuth │ 제3자 인증 표준 프로토콜 │
├──────────────────┼──────────────────────────────────────────────────┤
│ SSO │ Single Sign-On, 한 번 로그인으로 여러 서비스 │
└──────────────────┴──────────────────────────────────────────────────┘
6.3 데이터베이스/설계 용어
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 스키마 │ DB 전체 구조와 제약 조건 정의 │
│ │ 외부/개념/내부 스키마 (3단계) │
├──────────────────┼──────────────────────────────────────────────────┤
│ ER 다이어그램 │ 개체-관계 모델 (Entity-Relationship) │
│ │ 개체(사각형), 속성(타원), 관계(마름모) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 카디널리티 │ 관계에서 대응 수 (1:1, 1:N, M:N) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 슈퍼키 │ 유일성 만족하는 속성 집합 │
│ 후보키 │ 유일성 + 최소성 │
│ 기본키 │ 후보키 중 선택된 하나 │
│ 대체키 │ 기본키 제외 나머지 후보키 │
│ 외래키 │ 다른 테이블의 기본키를 참조 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 무결성 제약 │ 개체 무결성: PK는 NULL 불가 │
│ │ 참조 무결성: FK는 참조 테이블에 존재해야 함 │
│ │ 도메인 무결성: 속성값이 도메인 범위 내 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 반정규화 │ 성능 향상을 위해 의도적으로 정규화 위반 │
│ (Denormalization)│ 테이블 병합, 중복 허용 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 파티셔닝 │ 큰 테이블을 분할 (Range, Hash, List) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 클러스터링 │ 같은 값을 가진 데이터를 물리적으로 근접 저장 │
└──────────────────┴──────────────────────────────────────────────────┘
6.4 소프트웨어 품질
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ ISO/IEC 9126 │ SW 품질 특성 6가지 │
│ │ 기능성, 신뢰성, 사용성, 효율성, │
│ │ 유지보수성, 이식성 │
├──────────────────┼──────────────────────────────────────────────────┤
│ ISO/IEC 25010 │ 9126 후속, 8가지 품질 특성 │
│ │ + 보안성, 호환성 │
├──────────────────┼──────────────────────────────────────────────────┤
│ CMMI │ 소프트웨어 성숙도 모델 │
│ │ 초기→관리→정의→정량적관리→최적화 (5단계) │
├──────────────────┼──────────────────────────────────────────────────┤
│ SPICE │ ISO/IEC 15504, 프로세스 평가 모델 │
│ │ 불완전→수행→관리→확립→예측→최적화 (6단계) │
└──────────────────┴──────────────────────────────────────────────────┘
7장. 화면 설계 & UI/UX
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ UI │ 사용자 인터페이스 (화면, 버튼 등) │
│ UX │ 사용자 경험 (사용 과정 전체의 경험) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 와이어프레임 │ 화면 구조의 뼈대 (저수준 설계) │
│ 목업(Mockup) │ 실제와 유사한 정적 디자인 │
│ 프로토타입 │ 인터랙션이 가능한 동적 모형 │
│ 스토리보드 │ 화면별 상세 설명 + 흐름 문서 │
├──────────────────┼──────────────────────────────────────────────────┤
│ UI 설계 원칙 │ 직관성, 유효성, 학습성, 유연성 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 접근성 │ 장애인, 고령자도 사용할 수 있도록 설계 │
│ (Accessibility) │ WCAG 지침 준수 │
└──────────────────┴──────────────────────────────────────────────────┘
8장. 기타 빈출 주제
8.1 소프트웨어 아키텍처 패턴
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌──────────────────┬──────────────────────────────────────────────────┐
│ 패턴 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ MVC │ Model-View-Controller, 가장 일반적 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 레이어드 │ 계층 분리 (Presentation-Business-Data) │
├──────────────────┼──────────────────────────────────────────────────┤
│ 클라이언트-서버 │ 요청-응답 구조 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 파이프-필터 │ 데이터가 파이프를 통해 순차 처리 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 브로커 │ 분산 시스템에서 중개자가 통신 관리 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 마스터-슬레이브 │ 주 서버가 작업을 종 서버에 분배 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 이벤트 버스 │ 이벤트 발행-구독 방식 │
└──────────────────┴──────────────────────────────────────────────────┘
8.2 소프트웨어 재공학 / 재사용
1
2
3
4
5
6
7
8
9
10
11
12
┌──────────────────┬──────────────────────────────────────────────────┐
│ 용어 │ 설명 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 역공학 │ 기존 코드에서 설계/명세를 추출 │
│ (Reverse Eng.) │ │
├──────────────────┼──────────────────────────────────────────────────┤
│ 재공학 │ 기존 시스템을 분석·재구성하여 새 시스템 구축 │
│ (Reengineering) │ 분석→재구성→역공학→이관 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 이식 │ 다른 환경에서 동작하도록 변환 │
│ (Migration) │ │
└──────────────────┴──────────────────────────────────────────────────┘
8.3 데이터 흐름도(DFD)
1
2
3
4
5
6
7
8
┌──────────────────┬──────────────────────────────────────────────────┐
│ 구성 요소 │ 표기 │
├──────────────────┼──────────────────────────────────────────────────┤
│ 프로세스 │ 원(○) — 데이터 변환 │
│ 데이터 흐름 │ 화살표(→) — 데이터 이동 │
│ 데이터 저장소 │ 평행선(=) — DB, 파일 │
│ 외부 엔티티 │ 사각형(□) — 시스템 외부의 사람/시스템 │
└──────────────────┴──────────────────────────────────────────────────┘
1편 마무리: 이 글에서 다룬 이론을 반복 암기하면 단답형/서술형의 60~70%를 커버할 수 있다. 특히 ★★★ 표시된 주제는 매회 빠지지 않고 출제되므로 반드시 외우자. 2편에서는 코드 출력 문제(C, Java, Python)와 SQL 실전을 다룬다.