내적 결합

무엇이 내중성입니까

내집성이란 한 모듈의 내부 기능이 서로 밀접한 관계를 가진 정도를 말한다. 특정한 임무나 관련 임무 그룹을 수행하는 모듈은 높은 내집성을 가지고 핵심 기능이 없고 대량의 기능을 한데 모은 모듈은 낮은 내집성을 가진다.

결합성

결합이란 모듈 A와 모듈 B 기능의 상관 정도를 가리킨다.만약에 두 모듈의 기능이 코드 차원에서 고도로 중첩된다면 모듈 간에 방법이 대량으로 서로 호출된다면 이 두 모듈은 높은 결합이다.모듈 A의 변경 사항은 B를 변경합니다.
강한 결합성은 코드의 수정 가능성에 불리하다. 왜냐하면 코드를 유지하는 비용을 증가시켰기 때문이다. 코드의 수정 가능성을 높이려면 코드의 높은 내적 집합과 낮은 결합을 해야 한다.

내중성과 결합성을 측정하다

작은 예를 들어 내중성과 결합성을 어떻게 판단하는지 설명한다.다음은 모듈 A의 코드입니다.

""" Module A(a.py) - Implement functions that operate on series of numbers """

def squares(narray):
	""" Return array of squares of numbers """
	return pow_n(array, 2)

def cubes(narray):
	""" Return array of cubes of numbers """
	return pow_n(array, 3)

def pow_n(narray, n):
	""" Return array of numbers raised to arbitrary power n each """
	return [pow(x, n) for x in narray]

def frequency(string, word):
	""" Find the frequency of occurrences of word in string as percentage """
	word_l = word.lower()
	string_l = string.lower()

	# words in string
	words = string_l.split()
	count = w.count(word_l)
	
	# return frequency as percentage
	return 100.0 * count / len(words)

다음은 모듈 B 코드입니다.

""" Module B(b.py) - Implement functions provide some statistical methods """

import a

def rms(narray):
	""" Return root mean square of array of numbers """
	return pow(sum(a.squares(narray)), 0.5)

def mean(array):
	""" Return mean of an array of numbers """
	return 1.0 * sum(array) / len(array)

def variance(array):
	""" Return variance of an array of numbers """
	
	# square of variation from mean
	avg = mean(array)
	array_d = [(x - avg) for x in array]
	variance = sum(a.squares(array_d))
	return variance

def standard_deviation(array):
	""" Return standard deviation of an array of numbers """
	return pow(variance(array), 0.5)

모듈 A와 B의 함수를 분석합니다.
모듈
핵심 기능
무관 기능수
기능 종속성
B
4
0
3 * 1 = 3
A
3
1
0
1) 모듈 B에는 4개의 함수가 있는데 모두 핵심 기능을 중심으로 한다.이 모듈에는 핵심 기능과 무관한 기능이 없고 모든 모듈 B는 100% 내장되어 있다.2) 모듈 A에는 4개의 함수가 있는데 그중 3개는 핵심 기능과 관련이 있지만 마지막 frequency 함수는 핵심 기능과 무관하기 때문에 A는 75%의 내중성에 불과하다.3) 모듈 B 중 3개의 함수는 모듈 A 중의 square 함수에 의존하고 있기 때문에 모듈 B와 모듈 A는 강한 결합성을 가진다. 이곳의 모듈 B는 모듈 A에 대한 함수 차원에서의 결합성이 75%이다.4) 모듈 A는 모듈 B의 함수에 의존하지 않으므로 모듈 A는 모듈 B와 독립적으로 작동하며 모듈 A는 모듈 B에 대한 결합성은 0이다.

어떻게 개선

모듈 A의 내중성을 높이려면 마지막 무관 함수를 간단하게 제거하고 다른 모듈에 이식할 수 있다.현재 모듈 B에서 모듈 A까지의 결합성을 분석합니다. 1) B의 3개 함수는 A의 한 함수에만 의존합니다.2) A에서 의존하는 함수는 square이며, 그 기능은 하나의 그룹을 받아들여 각 그룹의 제곱을 되돌려주는 것이다.3) 이 함수의 API는 간단하므로 향후 수정될 가능성이 적습니다.4) 시스템에 두 가지 결합 방식이 없고 의존 방향은 B에서 A까지입니다.종합적으로 보면 B에서 A까지 강한 결합이 존재하지만 이것은'좋은'결합이고 시스템의 수정성에 조금도 영향을 주지 않는다.

또 다른 예

다음은 모듈 A의 코드입니다.

""" Mudule A(a.py) - Provides string processing functions """
import b

def ntimes(string, char):
	""" Return number of times character 'char' occurs in string """
	return string.count(char)

def common_words(text1, text2):
	""" Return common word across text1 and text2 """

	# A text is a collection of strings split using newlines
	strings1 = text1.split('
')
	strings2 = text2.split('
')

	common = []
	for string1 in strings1:
		for string2 in strings2:
			common += b.common(string1, string2)
	
	# drop duplicates
	return list(set(common))

다음은 모듈 B 코드입니다.

""" Module B(b.py) - Provides text processing functions to user """

import a

def common(string1, string2):
	""" Return common words across string1 and string2 """

	s1 = set(string1.lower().split())
	s2 = set(string2.lower().split())
	return s1.intersection(s2)

def common_words(text1, text2):
	""" Return common words across two input files """

	lines1 = open(filename1).read()
	lines2 = open(filename2).read()

	return a.common_words(lines1, lines2)

모듈 A와 B의 함수를 분석합니다.
모듈
핵심 기능
무관 기능수
기능 종속성
B
2
0
1 * 1 = 1
A
2
0
1 * 1 = 1
1) 모듈 A와 모듈 B는 각각 두 개의 함수가 있는데 각 함수는 각 모듈을 처리하는 핵심 기능이기 때문에 모듈 A와 모듈 B는 모두 100%의 내중성을 가진다.2) 모듈 A의 한 함수는 모듈 B의 한 함수에 의존하는 동시에 모듈 B의 한 함수도 모듈 A의 한 함수에 의존한다.따라서 모듈 A에서 모듈 B까지 강한 결합성이 있고, 모듈 B에서 모듈 A까지도 강한 결합성이 있다.결합성은 양방향이라는 것이다.

두 모듈 간의 양방향 결합성은 각 모듈의 수정 가능성을 상대방과 밀접하게 연결시킨다. 모듈 A의 어떠한 수정도 모듈 B의 행위에 신속하게 영향을 주고 반대로도 마찬가지다.그래서 이것은 나쁜 결합이다.

수정 가능한 정책 향상

명시적 인터페이스 제공

하나의 모듈은 외부 코드에 함수, 클래스, 방법을 인터페이스로 제공해야 한다.인터페이스는 모듈의 API로 볼 수 있는데 실제로 API는 인터페이스에서 발전된 것이다.이 모듈 API를 사용하는 모든 외부 코드를 자랑하는 고객입니다.모듈의 경우 내부 방법이나 함수이거나 API의 구성 방법이나 함수가 아니더라도 사유 표지를 명확하게 덧붙이거나 기록해야 한다.

양방향 의존성 감소

상기 두 번째 예에서 알 수 있듯이 결합 방향이 일방적이라면 두 모듈 간의 결합은 관리할 수 있다. 즉, 이것은 큰 소프트웨어 품질 결함을 초래하지 않는다는 것이다.그러나 양방향 결합으로 인해 두 모듈 사이가 밀접하게 연결되어 모듈이 사용되기 어렵고 유지 보수 원가가 높아진다.일부 언어(예를 들어python)는 인용을 바탕으로 하는 쓰레기 회수 메커니즘을 사용하는데 양방향 결합이 존재하면 변수와 대상 간의 은식 인용 순환 체인을 초래하여 쓰레기 회수 운행 결과가 이상적이지 않을 수 있다.양방향 의존은 이런 방식으로 깨뜨릴 수 있다. 첫 번째 모듈은 항상 두 번째 모듈 이외의 함수를 사용하고 두 번째 모듈도 이렇게 할 수 있다.각 모듈에서 공통적으로 사용하는 함수를 하나의 모듈에 일괄적으로 봉인할 수 있다는 것이다.위에서 제시한 두 번째 예는 모듈 B의common 함수를 모듈 A에 간단하게 이식할 수 있다.

공공 서비스를 추상화하다

추상적으로 자주 사용하는 기능과 방법의 보조 모듈을 사용하면 두 모듈 간의 결합을 줄이고 그들의 내중성을 증가시킬 수 있다.위의 두 번째 예에서 모듈 A는 모듈 B의 보조 모듈과 같다.보조 모듈은 중간부품이나 매개체로 여길 수 있으며 다른 모듈의 공공 서비스를 추상화하여 의존하는 코드가 모두 같은 곳에 놓여 있고 각 모듈에서 반복적으로 나타나지 않게 한다.또한 한 모듈에서 핵심 기능과 관련이 크지 않은 함수를 다른 보조 모듈에 이식하여 이 모듈의 내중성을 높일 수 있다.

상속 기술 사용

각 클래스에 비슷한 코드나 함수가 있을 때 클래스 계승을 사용할 수 있다.계승 방법을 사용하여 각 종류의 유니버설 코드를 계승을 통해 공유한다.다음 예제에서는 단어가 나타나는 빈도에 따라 텍스트 파일을 정렬합니다.

""" Module textrank - Rank text files in order of degree of a specific word frequency. 
"""

import operator

class TextRank(object):
	""" Accept text files as inputs and rank them in terms of how much a word occurs 
	in them """

	def __init__(self, word, *filenames):
		self.word = word.strip().lower()
		self.filenames = filenames

	def rank(self):
		""" Rank the files. A tuple is returned with (filename, #occur) in decreasing
		order of occurences """

	occurs = []
	for fpath in self.filenames:
		with open(fpath, 'r') as f:
			data = f.read()
			words = map(lambda x: x.lower().strip(), data.split())
			# filter empty words
			count = words.count(self.word)
			occurs.appen((fpath, count))
	# return in sorted order
	return sorted(occurs, key=operator.itemgetter(1), reverse=True)

다음은 또 다른 모듈:urlrank.이 모듈은 여러 URL을 같은 방법으로 정렬합니다.

""" Mudule urlrank - Rank URLs in order of degree of a specific word frequency """
import operator
import requests

class URLRank(object):
	""" Accept URLs as inputs and rank them in trems of how much a word occurs
	in them """

	def __init__(self, word, *urls):
		self.word = word.strip().lower()
		self.urls = urls

	def rank(self):
		""" Rank the URLs. A tuple is returned with (url, #occur) in decreasing
		order of occurenecs """

		occurs = []
		for url in urls:
			data = requests.get(url).text
			words = map(lambda x: x.lower().strip(), data.split())
			# filter empty words
			count = words.count(self.word)
			occurs.append((url, count))
		
		# return in sorted order
		return sorted(occurs, key=operator.itemgetter(1), reverse=True)

위의 두 모듈은 모두 여러 개의 입력된 데이터 집합을 정렬하는 것이다. 근거는 모두 어떤 단어가 데이터 집합에 나타나는 빈도이기 때문에 이 두 모듈에는 비슷한 코드가 많아서 수정성을 떨어뜨린다. 다음은 계승을 이용하여 이 두 모듈을 재구성한다.기본 RankBase:

""" Mudule rankbase - Logic for ranking text using degree of word frequency """

import operator

class RankBase(object):
	""" Accept text data as inputs and rank them in terms of how much a word occurs
	in them """

	def __init__(self, word):
		self.word = word.lower().strip()

	def rank(self, *texts):
		""" Rank input data. A tuple is returnes with (idx, #occur) in decreasing
		order of occurences ""'

		words = map(lambda x: x.lower().strip(), text.split())
		count = words.count(self.word)
		occurs[idx] = count
	
		# return dictionary
		return occurs
	
	def sort(self, occurs):
		""" Return the ranking data in sorted order """
		return sorted(occurs, key=operator.itemgetter(1), reverse=True)

textrank 모듈

""" Module textrank - Rank text files in order of degree of specific word frequency """

import operator
from rankbase import RankBase

class TextRank(RankBase):
	""" Accept text files as inputs and rank them in terms of how much a word occurs
	in them """

	def __init__(self, word, *filenames):
		super().__init__(word)
		self.filenames = filenames

	def rank(self):
		""" Rank the files. A tuple is returned with (filename, #occur) in decreasing
		order of occurences. """
		texts = map(lambda x: open(x, 'r').read(), self.filenames)
		occurs = super().rank(*texts)
		occurs = [(self.filenames[x], y) for x, y in occurs.items()]
		return self.sort(occurs)

urlrank 모듈:

""" Mudule urlrank - Rank URLs in order of defree of a specific word frequency """

import operator
from rankbase import RankBase

class URLRank(RankBase):
	""" Accept URLs as inputs and rank them in terms of how much a word occurs in
	them """

	def __init__(self, word, *urls):
		super().__init__(word)
		self.urls = urls

	def rank(self):
		""" Rank the URLs. A tuple is returned with (url, #occur) in decreasing order
		of occurences ""'

		texts = map(lambda x: requests.get(x).text, self.urls)
		occurs = super().rank(*texts)
		occurs = [(self.urls[x], y) for x, y in occurs.items]
		return self.sort(occurs)