응집도

<응집도와 결합도(Coupling and Cohesion)>
- 설계의 기본 원칙 : 응집도(=개별모듈)는 높게 결합도(=모듈관의 관계)는 낮게

- Fundamental principle of SD
  - A large system should be partitioned into mangeable routines&models

- Goal
  - Routines are as independent as possible
  - Each routine carries out a single problem-ralted function

- Mesures
  - Coupling and Cohesion





<응집도(Cohesion)>
- Cohesion is the measure of the strength of functional relatedness of elements within a routine

- Element?
  - Any priece of code that accomplished som task or defines some data

- Ensuring good cohesion is the best way to minimise coupling





<Classes of Cohesion>
- Good Cohension
  - Funcional(기능적)
  - Sequential(순차적)
  - Communicational(통신적)
-------------------------------Modularity Line
- Poor
  - Procedural(절차적)
  - Temporal(시간적)
  - Logical(논리적)
  - Coincidental(우연적)

Q : Doing one function only?
Y-> Functional(Best) //기능적
N-> Module related by?

Q : Module related by?
Data(동일한 데이터를 이용) -> Sequence important?
N-> Communicational //통신적
Y-> Sequential //순차적

Q : Module related by?
Control Flow -> Sequence import
Y-> Procedual //절차적
N -> Temporal //시간적, 특정한 시간에서만 

Q : Module related by?
None -> Activities same category?
Y-> Coincidental(Worest) //우연적, 기능들이 아무 관련이 없다
N -> Logical //논리적, 기능들이 서로 논리적으로 관련





<Functional Cohesion(기능적 응집도)>
- A FC routine contatins elements that all contribute to the execution of one and only one problem related task
  - Compute Cosine of Angle(코사인값을 구하는 코드)
  - Verify User Password(사용자의 비번을 검증하는 기능을 갖는 모듈)
  - Calculate Mortgage Repayment(담보대출을 했을 때 상환액을 구하는 코드)
  - Compute Rocket Trajectory(로켓의 궤도를 계산하는 코드)
- 기능적 응집도를 갖는 모듈은 (하나의 모듈안에 있는 경우) 모듈의 어떤 코드 부분을 제거하면 기능을 제대로 수행하지 못한다






<Advantages(기능적 응집도의 장점)>
- Normally coupled, functionally conhesive routines are:
  - Easy to maintain //유지보수 쉬움
  - Easy to understand //이해하기 쉬움
  - "Black box" //내부가 어떤 식으로 구현되었는 지 알 수 있다 -> 특정 기능만을 수행하기 때문에 
  - ex) mile을 km로 변환하는 모듈(Convert Miles to KMS)
        △ -> △ -> △
      





<Sequential Cohesion(절차적(순차적) 응집도)>
- A SC routine is one whose elements are involved in activites such that output data from one serves as input data to the next
- 한 모듈에 여러가지 기능들을 수행하는 코드
- 이 절차적 응집도는 데이터로 연결되어 있다
- 한 기능의 출력(data)은 다른 기능의 입력(data)으로 연결된다 -> 입출력 관계로 물려있을 때
  - ex) Calcultate Net Profit(순이익) and Convert to Dollars(달라로 변환)
  - pound를 입력 -> Dollar로 변환
  - data : gross profit, total cost)=>△ -> (순이익) -> △ -> (파운드를 달러로 변환)-> △(Dollar)

  - 실제 코드
declare
calculate_net_profit and_convert_to_dollars
(in gross_profit:integer, 
in total_costs:integer) : integer; 
declare np_pounds, np_dollars : integer;

np_pounds <- gross_profit-total_costs;  => 데이터 출력 -> 데이터 입력
np_dollars <- np_pounds*1.654;           => 데이터 출력 -> 데이터 입력
return np_dollars;
end calculate...;






<Problem?>
- Not as readily reusable
- ex) gross profit(data), Total Costs(data)
      모듈 : Calculate Net Profit //순이익만을 계산하는 기능만 -> 재사용이 쉽다

      Pounds(data), Dollars(data)
      모듈 : Calculate Net Profit and Convert to Dollars //두 개의 기능을 한 번에 사용 -> 재사용이 어려움






<Communicational Cohsion(통신적 응집도)>
- A CmC routine is one whose elements contribute to activities that use the same input data
- △ -> △ -> △ (동일한 data를 사용, 독립적으로 행동도 가능)
- ex) Determine Customer Details(고객의 잔액 조회, 고객의 이름 조회)
 Customer Account Number(입력 데이터) //고객의 계좌번호 이용
 Customer Balance, Customer Name(출력 데이터)

- 실제 코드
Routines : Determine Customer Details
Uses : Customer Account Number
Returns : Customer Name, Customer Balance

Begin

Use Customer AccountTnumber To
Find Customer Name
Find Customer Balance
Return Customer Name, Customer Balance

End





<Problem>
- Not as readily reusable
- ex) Solution -> 분리
    Get Customer Name(고객의 이름만을 필요로 할 때)
    - Customer Account Number(입력 데이터)
    - Customer Name(출력 데이터)

    Get Customer Balance(고객의 잔액만을 필요로 할 때)
    - Customer Account Number(입력 데이터)
    - Customer Balance(출력 데이터)

  



<Procedual Cohesion(절차적 응집도) -> 실행 순서>
- 데이터랑은 관련x, 개별o, 독립o, 실행순서로 여러개의 기능 발현(control)
- ex) Calculate trajectory(궤도 계산)
       and
-------------------------------------- 서로 개별적인 기능(절차로 엮여있다. 즉, 궤도를 계산해서(첫 번째 스탭) 알람을 활성화 시켜라(두 번째 스탭))
       activate alarms(알람을 활성화)






<Temporal Cohesion(시간적 응집도)>
- A TC routine is one whose elemets are involved in activities that are related in time
- 실행되는 순간이 같은 경우에 한 모듈이 같을 때

- 실제코드
declare initialise_everything
(in-out arrayA : array[0...99] of integer,
(in-out arrayB : array[0...99] of integer, //배열 A와 B는 관련은 없다
in-out X : integer, in-out Y : integer):empty;

//하지만 초기화 되는 '시점'은 같다
declare count : integer=0;
do(count < 100)
arrayA[count] <-0; arrayB[count] <-0; //arrayA만 초기화 시키면 오류
count <- count+1;
end do;
X<-0; Y<-0
end initialise_everything






<Logical Cohesion(논리적 응집도)>
- A LC routine is one whose elements contribute to activities of the same general category in which the activities to be 
  executed are selected from outside the routine
- ex)
declare convert_distance(in distance:real, inflag:integer) : real;
declare conv_distance = 0.0: real;

if(flag=1) then
conv_distance <-distance*8/5 //miles -> kms
else if(flag=2) then
conv_distance <-distance*5/8; //kms -> miles
end if;
return conv_distance;
end convert_distance;
- 이후 모듈이 변경되면 사용하면 모듈도 변경이 되어야 한다
- △(변경되어야 한다(2)) -> △(변경되면(1)) 




<Solution>
- 기능분리
  -ex) Convert Miles to KMS
      - miles(입력 데이터)
      - kms(출력 데이터)

  - Convert KMS to miles
      - kms(입력 데이터)
      - miles(출력 데이터)






<Routine Specification>
- declare miscellaneous_functions
  (in flag:integer, in pounds:real, in miles:real,
   in-out dollar s:real, in-out kms:real): empty

if(flag=1) then
  dollars <- pounds*1.45;
else if(flag=2) then
    kms <- miles*1.6;
end if
end miscellaneous_functions;





<Solution>
- 기능 분리
  - ex) Convert Miles to KMS
    - miles(입력 데이터)
    - kms(출력 데이터)

    Convert Pounds to Dollars
      - pounds(입력 데이터)
      - dollars(출력 데이터)