<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	xmlns:series="https://publishpress.com/"
	>

<channel>
	<title>Book Archives - 아빠프로그래머의 좌충우돌 개발하기!</title>
	<atom:link href="https://www.daddyprogrammer.org/post/category/book/feed/" rel="self" type="application/rss+xml" />
	<link>https://www.daddyprogrammer.org/post/category/book/</link>
	<description>기저귀 갈면서 코딩해야 프로다!</description>
	<lastBuildDate>Thu, 17 Feb 2022 09:53:05 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.5</generator>

<image>
	<url>https://www.daddyprogrammer.org/wp-content/uploads/2019/04/cropped-spring-bird-2295431_960_720-300x300.jpg</url>
	<title>Book Archives - 아빠프로그래머의 좌충우돌 개발하기!</title>
	<link>https://www.daddyprogrammer.org/post/category/book/</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Clean architecture 3부 – 설계 원칙(Design principles)</title>
		<link>https://www.daddyprogrammer.org/post/10820/clean-architecture-design-principles/</link>
					<comments>https://www.daddyprogrammer.org/post/10820/clean-architecture-design-principles/#comments</comments>
		
		<dc:creator><![CDATA[happydaddy]]></dc:creator>
		<pubDate>Fri, 12 Jun 2020 02:38:11 +0000</pubDate>
				<category><![CDATA[Book]]></category>
		<category><![CDATA[Architecture]]></category>
		<guid isPermaLink="false">http://3.36.120.4/?p=10820</guid>

					<description><![CDATA[<p>좋은 소프트웨어 시스템은 깔끔한 코드(clean code)로부터 시작한다. 하지만 좋은 코드를 사용하더라도 아키텍처를 엉망으로 만들 수도 있다. 그 반대도 가능하다. 그래서 좋은 벽돌로 좋은 아키텍처를 정의하는 원칙이 필요한데 그것이 SOLID이다. SOLID 원칙은 함수와 데이터 구조를 클래스로 배치하는 방법, 그리고 이들 클래스를 서로 결합하는 방법을 설명해준다. SOLID 원칙의 목적은 중간 수준의 소프트웨어 구조가 아래와 같도록 만드는 데 [&#8230;]</p>
<p>The post <a href="https://www.daddyprogrammer.org/post/10820/clean-architecture-design-principles/">Clean architecture 3부 – 설계 원칙(Design principles)</a> appeared first on <a href="https://www.daddyprogrammer.org">아빠프로그래머의 좌충우돌 개발하기!</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">좋은 소프트웨어 시스템은 깔끔한 코드(clean code)로부터 시작한다. 하지만 좋은 코드를 사용하더라도 아키텍처를 엉망으로 만들 수도 있다. 그 반대도 가능하다. 그래서 좋은 벽돌로 좋은 아키텍처를 정의하는 원칙이 필요한데 그것이 SOLID이다.</p>



<p class="wp-block-paragraph">SOLID 원칙은 함수와 데이터 구조를 클래스로 배치하는 방법, 그리고 이들 클래스를 서로 결합하는 방법을 설명해준다. SOLID 원칙의 목적은 중간 수준의 소프트웨어 구조가 아래와 같도록 만드는 데 있다.</p>



<ul class="wp-block-list"><li>변경에 유연하다.</li><li>이해하기 쉽다. </li><li>많은 소프트웨어 시스템에 사용될 수 있는 컴포넌트의 기반이 된다. </li></ul>



<p class="wp-block-paragraph"><strong><span class="has-inline-color has-vivid-red-color">S</span></strong>RP(Single Responsibility Principle) : 단일 책임원칙<br><strong><span class="has-inline-color has-vivid-red-color">O</span></strong>CP(Open-Closed Principle) : 개방-폐쇄 원칙<br><strong><span class="has-inline-color has-vivid-red-color">L</span></strong>SP(Liskov Substitution Principle) : 리스코프 치환 원칙<br><strong><span class="has-inline-color has-vivid-red-color">I</span></strong>SP(Interface Segregation Principle) : 인터페이스 분리 원칙<br><span class="has-inline-color has-vivid-red-color"><strong>D</strong></span>IP(Dependency Inversion Principle) : 의존성 역전 원칙</p>



<h3 class="wp-block-heading"><span class="has-inline-color has-vivid-red-color">S</span>RP(Single Responsibility Principle : 단일 책임원칙)</h3>



<ul class="wp-block-list"><li>각 소프트웨어 모듈은 변경의 이유가 단 하나뿐이어야만 한다. 모든 모듈이 단 하나의 일만 해야 한다는 의미는 아니다. <strong><span class="has-inline-color has-vivid-cyan-blue-color">하나의 모듈은 오직 하나의 액터에 대해서만 책임져야 한다</span></strong>는 것이다. 공유된 알고리즘을 서로 다른 이해관계자가 사용할 때 한쪽의 계산 방식이 수정되는 경우 다른 쪽의 로직에 영향을 줄 수가 있다. 즉 <strong><span class="has-inline-color has-vivid-cyan-blue-color">서로 다른 액터가 의존하는 코드는 서로 분리</span></strong>되어야 한다. 예) DateUtil : 해당 모듈을 여러 국가의 컴포넌트에서 사용할 경우 한쪽의 수정이 다른 한쪽의 데이터를 잘 못 나오게 하는 결과를 초래할 수 있다.</li><li><strong><span class="has-inline-color has-vivid-red-color">Facade Pattern (퍼사드 패턴)</span></strong> 대표 1개의 클래스를 생성하여 요청된 메서드를 가진 객체로 작업을 위임한다. 여기서 가장 중요한 메서드는 대표 클래스에서 처리하고 나머지는 각자의 클래스에서 처리하도록 수정해도 된다. 메서드가 하나의 가족을 이루고, 메서드의 가족을 포함하는 각 클래스는 하나의 유효 범위가 된다. 해당 유효 범위 바깥에서는 이 가족에게 감춰진 식구(private멤버)가 있는지를 전혀 알 수 없다.</li></ul>



<h3 class="wp-block-heading"><strong><span class="has-inline-color has-vivid-red-color">O</span>CP(Open-Closed Principle : 개방-폐쇄 원칙)</strong></h3>



<ul class="wp-block-list"><li><strong><span class="has-inline-color has-vivid-cyan-blue-color">기존 코드를 수정하기보다는 반드시 새로운 코드를 추가하는 방식으로 시스템의 행위를 변경할 수 있도록 설계해야만 소프트웨어 시스템을 쉽게 변경</span></strong>할 수 있다.</li><li>소프트웨어의 개체의 <strong><span class="has-inline-color has-vivid-cyan-blue-color">행위는 확장할 수 있어야 하지만, 이때 개체를 변경해서는 안된다.</span></strong>  예) 재무 재표를 표시해주는 웹페이지에 동일한 결과를 엑셀로 출력하는 기능 확장 시 원래 코드는 얼마나 수정해야 할까? 이상적인 변경량은 0이다.&nbsp;재무 데이터를 검사한 후 보고서용 데이터를 생성한 다음 필요에 따라 두 가지 보고서 생성 절차 중 하나를 거쳐 적절히 포매팅한다. 이때 두가지 책임 중 하나에 변경이 발생하더라도 다른 하나는 변경되지 않도록 소스코드 의존성도 확실히 조직화해야 한다. 처리과정을 클래스로 분리하고 이들 클래스를 컴포넌트 단위로 구분해야 한다.</li><li>서로 다른 목적으로 변경되는 요소를 적절하게 분리하고(SRP : 단일 책임원칙) 이들 요소 사이의 의존성을 체계화 함으로써(DIP : 의존성역전원칙) 변경량을 최소화할 수 있다.</li><li><strong><span class="has-inline-color has-vivid-cyan-blue-color">A컴포넌트에서 발생한 변경으로부터 B컴포넌트를 보호하려면 반드시 A컴포넌트가 B컴포넌트에 의존</span></strong>해야 한다. 컴포넌트 계층구조를 이와 같이 조직화하면 저수준 컴포넌트에서 발생한 변경으로부터 고수준 컴포넌트를 보호할 수 있다.</li></ul>



<h3 class="wp-block-heading"><strong><span class="has-inline-color has-vivid-red-color">L</span>SP(LIskov substitution principle : 리스코프 치환 원칙)</strong></h3>



<ul class="wp-block-list"><li>상호 대체 가능한 구성요소를 이용해 소프트웨어 시스템을 만들 수 있으려면, 이들 구성요소는 반드시 치환 가능해야 한다는 규약을 반드시 지켜야 한다. 예) 라이선스에는 퍼스널 라이선스와 비즈니스 라이선스의 두가지 하위타입이 존재한다. 퍼스널 라이선스에 비즈니스 라이선스를 치환하더라도 동일하게 동작한다. 이들 하위 타입은 모두 라이선스 타입을 치환할 수 있다.</li></ul>



<h3 class="wp-block-heading"><strong><span class="has-inline-color has-vivid-red-color">I</span>SP(interface segregation principle : 인터페이스 분리 원칙)</strong></h3>



<ul class="wp-block-list"><li> <strong><span class="has-inline-color has-vivid-cyan-blue-color">소프트웨어 설계자는 사용하지 않는 것에 의존하도록 만들지 않아야 한다</span></strong>. 예) 하나의 클래스에 여러 사용자가 각각 사용하는 메서드가 기술되었다고 할 때 다른 하나의 사용자의 메서드를 수정하면 다른 사용자의 메서드는 수정되지 않았음에도 다시 컴파일돼야 한다. 이때는 인터페이스를 분리하여 각각의 의존성이 영향을 받지 않도록 해야 한다.</li><li>정적 타입 언어는 소스에&nbsp;타입 선언을 하기 때문에 소스 코드 의존성이 발생하고 재컴파일 또는 재배포가 강제되는 상황이 무조건 초래된다.</li><li>필요이상으로 많은것을 포함하는 모듈에 의존하는 것은 위험한 일이다.</li></ul>



<h3 class="wp-block-heading"><strong><span class="has-inline-color has-vivid-red-color">D</span>IP(dependency inversion principle : 의존성 역전 원칙)</strong></h3>



<ul class="wp-block-list"><li>고수준 정책을 구현하는 코드는 저수준 세부사항을 구현하는 코드에 절대로 의존해서는 안된다. <strong><span class="has-inline-color has-vivid-cyan-blue-color">유연성이 극대화된 시스템이란 소스코드 의존성이 추상(abstract, interface)에 의존하며 구체화(concretion)에는 의존하지 않는 시스템</span></strong>이다.</li><li>변동성이 큰 구체 클래스를 참조하지 말고 대신 추상 인터페이스를 참조하도록 구현한다. 변동성이 큰 구체 클래스로부터 파생하거나 구체 함수를 오버라이드 해서는 안된다. 예) UserService라는 구체 클래스가 있다. 해당 클래스는 페이스북 유저가 참조할 수도 있고 구글 유저가 참조할 수도 있다. 이런것을 고려하여 인터페이스를 만들고 참조하는 쪽에서는 변경사항이 없도록 해야 한다. 버전 1을 기반으로 버전 2를 만든다고 할 때 동일한 구체 클래스내에 오버라이드 하거나 클래스를 상속하면 의존성이 커진다. 역시 인터페이스로 만들고 구체 클래스는 두개로 나누어 의존성을 분리하는 것이 좋다.</li></ul>
<p>The post <a href="https://www.daddyprogrammer.org/post/10820/clean-architecture-design-principles/">Clean architecture 3부 – 설계 원칙(Design principles)</a> appeared first on <a href="https://www.daddyprogrammer.org">아빠프로그래머의 좌충우돌 개발하기!</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.daddyprogrammer.org/post/10820/clean-architecture-design-principles/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
		
		<series:name><![CDATA[Clean Architecture(클린아키텍처)]]></series:name>
	</item>
		<item>
		<title>Clean architecture 2부 &#8211; programming-paradigm</title>
		<link>https://www.daddyprogrammer.org/post/10417/clean-architecture-programming-paradigm/</link>
					<comments>https://www.daddyprogrammer.org/post/10417/clean-architecture-programming-paradigm/#comments</comments>
		
		<dc:creator><![CDATA[happydaddy]]></dc:creator>
		<pubDate>Fri, 24 Apr 2020 14:33:39 +0000</pubDate>
				<category><![CDATA[Book]]></category>
		<category><![CDATA[Architecture]]></category>
		<category><![CDATA[Clean architecture]]></category>
		<guid isPermaLink="false">http://3.36.120.4/?p=10417</guid>

					<description><![CDATA[<p>3장. 패러다임 개요 패러다임은 프로그래밍을 하는 방법으로, 대체로 언어에는 독립적인 개념이다. 패러다임은 어떤 프로그래밍 구조를 사용할지 그리고 언제 이 구조를 사용해야 하는지를 결정한다. 각 패러다임은 부정적인 의도를 가지는 일종의 추가적인 규칙을 부여한다. 즉 패러다임은 무엇을 해야 할지 말하기보다는 무엇을 해서는 안되는지 말해준다. 이 장에서는 세 가지 패러다임인 구조적 프로그래밍(structured programming), 객체지향 프로그래밍(object-oriented programming), 함수형 프로그래밍(functional [&#8230;]</p>
<p>The post <a href="https://www.daddyprogrammer.org/post/10417/clean-architecture-programming-paradigm/">Clean architecture 2부 &#8211; programming-paradigm</a> appeared first on <a href="https://www.daddyprogrammer.org">아빠프로그래머의 좌충우돌 개발하기!</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">3장. 패러다임 개요 </h2>



<p class="wp-block-paragraph">패러다임은 프로그래밍을 하는 방법으로, 대체로 언어에는 독립적인 개념이다. 패러다임은 어떤 프로그래밍 구조를 사용할지 그리고 언제 이 구조를 사용해야 하는지를 결정한다. 각 패러다임은 부정적인 의도를 가지는 일종의 추가적인 규칙을 부여한다. 즉 패러다임은 무엇을 해야 할지 말하기보다는 무엇을 해서는 안되는지 말해준다.</p>



<p class="wp-block-paragraph">이 장에서는 세 가지 패러다임인 구조적 프로그래밍(structured programming), 객체지향 프로그래밍(object-oriented programming), 함수형 프로그래밍(functional programming)에 대해서 설명한다.</p>



<h3 class="wp-block-heading">구조적 프로그래밍 </h3>



<p class="wp-block-paragraph">최초로 적용된 패러다임. (최초로 만들어진 패러다임은 아님) <br>1968년 에츠허르 비버 데이크 스트라(Edsger Wybe Dijkstra)가 발견</p>



<ul class="wp-block-list"><li>무분별한 점프(goto)는 프로그램 구조에 해롭다는 사실을 제시함.</li><li>이러한 점프들을 If/then/else와 do/while/until과 같이 더 익숙한 구조로 대체하였다.</li></ul>



<p class="wp-block-paragraph">제어 흐름의 직접적인 전환에 대해 규칙을 부과한다. <br>=&gt; goto를 앗아갔다.</p>



<h3 class="wp-block-heading">객체지향 프로그래밍 </h3>



<p class="wp-block-paragraph">두 번째로 적용된 패러다임. 구조적 프로그래밍보다 2년 앞선 1966년 올레 요한달과 크리스텐 니가드에 의해 등장.</p>



<ul class="wp-block-list"><li>알골 언어의 함수 호출 스택 프레임을 힙으로 옮기면, 함수 호출이 반환된 이후에도 함수에서 선언된 지역변수가 오랫동안 유지될 수 있음을 발견<ul><li>이러한 함수가 클래스의 생성자가 됨</li><li>지역변수는 인스턴스 변수</li><li>중첩 함수는 메서드가 됨</li></ul></li></ul>



<p class="wp-block-paragraph">함수 포인터를 특정 규칙에 따라 사용하는 과정을 통해 필연적으로 다형성이 등장하게 되었다. 제어 흐름의 간접적인 전환에 대해 규칙을 부과한다. <br>=&gt; 함수 포인터를 앗아갔다.</p>



<h3 class="wp-block-heading">함수형 프로그래밍</h3>



<p class="wp-block-paragraph">최근에 들어서야 겨우 도입되기 시작했지만. 세 패러다임중 가장 먼저 만들어졌다. 알란조 처치는 앨런 튜링이 똑같이 흥미를 가졌던 어떤 수학적 문제를 해결하는 과정에서 람다 계산법을 발명했는데, 함수형 프로그래밍은 이러한 연구 결과에 직접적인 영향을 받아 만들어졌다.</p>



<p class="wp-block-paragraph">1958년 존 매카시가 만든 LISP 언어의 근간이 되는 개념이 이 람다 계산법이다. <br>람다 계산법의 기초가 되는 개념은 불변성으로, 심벌의 값이 변경되지 않는다는 개념이다.<br>함수형 언어에는 할당 문이 전혀 없다는 뜻이기도 하다. 대다수의 함수형 언어가 변수 값을 변경할 수 있는 방법을 제공하기는 하지만, 굉장히 까다로운 조건 아래에서만 가능하다. <br>할당 문에 대해 규칙을 부과한다. <br>=&gt; 할당 문을 앗아갔다.</p>



<h3 class="wp-block-heading">생각할 거리</h3>



<p class="wp-block-paragraph">각 패러다임은 프로그래머에게서 권한을 박탈한다.</p>



<ul class="wp-block-list"><li>어느 패러다임도 새로운 권한을 부여하지 않는다.</li><li>각 패러다임은 무엇을 해야 할지보다는 무엇을 해서는 안 되는지를 말해준다.<ul><li>세 가지 패러다임은 각각 우리에게서 goto문, 함수 포인터, 할당 문을 앗아간다.</li></ul></li></ul>



<p class="wp-block-paragraph">1958년~1968년에 걸친 10년 동안 패러다임이 만들어졌고 이 패러다임은 지금까지 이어져오고 있고 이후 새로 등장한 패러다임은 전혀 없다.</p>



<h3 class="wp-block-heading">결론</h3>



<p class="wp-block-paragraph">패러다임의 역사로부터 얻을 수 있는 이러한 교훈은 아키텍처와 어떤 관계가 있는가?</p>



<ul class="wp-block-list"><li>모두 다 관계가 있다.</li><li>우리는 아키텍처 경계를 넘나들기 위한 메커니즘으로 다형성을 이용한다.</li><li>우리는 함수형 프로그래밍을 이용하여 데이터의 위치와 접근 방법에 대해 규칙을 부과한다.</li><li>우리는 모듈의 기반 알고리즘으로 구조적 프로그래밍을 사용한다.</li></ul>



<p class="wp-block-paragraph">세 가지 패러다임과 아키텍처의 세 가지 큰 관심사(함수, 컴포넌트 분리, 데이터 관리)가 어떻게 서로 연관되는지 주목하자.</p>



<h2 class="wp-block-heading">4장. 구조적 프로그래밍</h2>



<ul class="wp-block-list"><li>데이크 스트라<ul><li>데이크 스트라 알고리즘(최단 경로 알고리즘)</li><li>1930년 로테르담 출신, 수많은 업적을 남긴 구조적 프로그램의 선구자</li><li>1948년 우수한 성적으로 고등학교 졸업</li><li>1952년 21살의 나이로 네덜란드 최초의 프로그래머로 암스테르담 수학센터에 취업</li></ul></li></ul>



<p class="wp-block-paragraph">데이크 스트라가 활동하던 시절에는 프로그래머라는 직업이 없었고 사회에서 인정해 주지도 않아 이론 물리학자라는 직업으로 활동하였다. 진공관 시대의 컴퓨터는 매우 거대하고 쉽게 손상되며 느린 데다가 결과마저 믿을 수 없어 극도로 제한적으로만 사용되었다. 입력은 종이테이프나 천공카드와 같은 물리적인 형태를 띄었고 수정, 컴파일, 테스트를 반복하는 일은 최소 몇시간에서 며칠이 걸렸다. </p>



<h3 class="wp-block-heading">데이크 스트라가 하려던 것들</h3>



<h4 class="wp-block-heading">증명</h4>



<p class="wp-block-paragraph">초기에 인식한 문제는 프로그래밍은 어렵고, 프로그래머는 프로그래밍을 잘하지 못한다는 사실이었다. 아주 작은 세부사항이라도 간과하면 프로그램이 동작하는 것처럼 보이더라도 결국 예상외의 방식으로 실패하곤 했다.<br>데이크 스트라는 수학적인 원리를 이용하여 이 문제를 해결하려 했다. 공리, 정리, 따름정리, 보조 정리로 구성되는 유클리드 계층구조를 만들어 증명하려고 했지만 끝내 증명은 이루어지지 않았다. 다만 이 연구에서 goto 문장이 모듈을 더 작은 단위로 재귀적으로 분해하는 과정에 방해가 되는 경우가 많다는 사실을 발견했다.</p>



<p class="wp-block-paragraph">=&gt;&gt;&nbsp;공리는 증명 없이 참으로 받아들이는 명제를 뜻한다. 유클리드 기하학에서 &#8220;두 점이 주어졌을 때, 두 점을 지나는 직선이 단 하나 존재한다&#8221;는 명제 역시 증명할 수 없기에 공리라고 부른다, 정리는 증명이라는 과정을 통해 참이라는 것이 밝혀진 명제다. 이러한 정리를 증명하는 데 필요한 정리를 보조 정리로 부르며, 정리를 통해 자연스럽게 도출되는 정리를 따름 정리라고 부른다. 데이크스트라는 프로그램을 증명하는 이러한 계층구조를 만들고자 했다.</p>



<h4 class="wp-block-heading">해로운성명서</h4>



<p class="wp-block-paragraph">1968년 데이크 스트라는 goto문의 해로움에 대한 내용의 성명서를 발표했고 10년 이상 찬반의 비판과 논란의 여지가 있었지만 결국 데이크스트라가 승리하였다. 그 후 대부분의 언어에서 goto문은 사라졌다. 모든 프로그래밍은 순차 , 분기, 반복이라는 세 가지 구조만으로 표현할 수 있다. 현재의 우리 모두는 구조적 프로그래머이며, 여기에 선택의 여지가 없다. 제어 흐름을 제약 없이 직접 전환할 수 있는 선택권 자체를 언어에서 제공하지 않기 때문이다. 과거에는 goto문을 통해 그것이 가능했지만, 대다수의 현대적 컴퓨터 언어는 goto 문장을 포함하지 않는다.</p>



<h4 class="wp-block-heading">과학이 구출하다</h4>



<p class="wp-block-paragraph">무엇이 올바른지를 입증할 때 사용하는 전략에는 수학적인 증명만이 있는 것은 아니다. 과학은 수학과는 근본적으로 다른데 과학 이론은 그 올바름을 절대 증명할 수 없기 때문이다.<br>예를 들면 만유인력의 법칙이 옳다고 증명할 수 없다. 이들 법칙을 소수점 이하 많은 자리의 정확도로 측정할 수는 있지만 수학적으로 증명할 수 없다. 실험을 아무리 많이 수행하더라도, 언젠가는 다른 실험을 통해 만유인력의 법칙이 잘못되었음이 밝혀질 가능성은 항상 열려있다.<br>즉 과학적 방법은 반증은 가능하지만 증명은 불가능하다. 과학은 서술된 내용이 사실임을 증명하는 방식이 아니라 서술이 틀렸음을 증명하는 방식으로 동작한다. 각고의 노력으로도 반례를 들 수 없는 서술이 있다면 목표에 부합할 만큼은 참이라고 본다. 결론적으로 수학은 증명 가능한 서술이 참임을 입증하는 원리로 볼 수 있고, 과학은 증명 가능한 서술이 거짓임을 입증하는 원리라고 볼 수 있다.</p>



<h4 class="wp-block-heading">테스트</h4>



<p class="wp-block-paragraph">데이크스트라는 &#8220;테스트는 버그가 있음을 보여줄 뿐, 버그가 없음을 보여줄 순 없다&#8221;고 말한 적이 있다. 다시 말해 프로그램이 잘못되었음을 테스트를 통해 증명할 수는 있지만, 프로그램이 맞다고 증명할 수는 없다. 즉 테스트에 충분한 노력을 들였다면 테스트가 보장할 수 있는 것은 프로그램이 목표에 부합할 만큼은 충분히 참이라고 여길 수 있게 해 주는 것이 전부이다.<br>-&gt; 소프트 웨어 개발이 수학적인 구조를 다루는 듯 보이더라도, 수학적인 시도가 아니라 오히려 과학과 같다. 최선을 다하더라도 올바르지 않음을 증명하는데 실패함으로써 올바름을 보여주기 때문이다.(TDD)</p>



<h4 class="wp-block-heading">결론</h4>



<ul class="wp-block-list"><li>구조적 프로그래밍은 프로그램을 증명 가능한 세부 기능 집합으로 재귀적으로 분해할 것을 강요한다. 그리고 나서 테스트를 통해 증명 가능한 세부 기능들이 거짓인지를 증명하려고 시도한다.</li><li>구조적 프로그래밍이 오늘날까지 가치 있는 이유는 프로그래밍에서 반증 가능한 단위를 만들어 낼 수 있는 바로 이 능력 때문이다.</li><li>가장 작은 기능부터 가장 큰 컴포넌트에 이르기까지 모든 수준에서 소프트웨어는 과학과 같고, 반증 가능성에 의해 주도된다.</li><li>때문에 소프트웨어 아키텍트는 모듈, 컴포넌트, 서비스가 쉽게 반증 가능하도록 만들기 위해 분주히 노력해야 한다.</li><li>이를 위해 구조적 프로그래밍과 유사한 제한적인 규칙들을 받아들여 활용해야 한다.</li></ul>



<h2 class="wp-block-heading">5장. 객체지향 프로그래밍 </h2>



<p class="wp-block-paragraph">좋은 아키텍처를 만드는 일은 객체지향의 설계 원칙을 이해하고 응용하는데서 출발한다. </p>



<p class="wp-block-paragraph">&#8216;데이터와 함수의 조합&#8217;, &#8216;실제 세계를 모델링하는 새로운 방법&#8217; 등 객체지향을 정의하는 몇 가지 대답이 있지만 정의가 모호하다. 객체지향의 본질을 들여다보기 위해서는 캡슐화, 상속, 다형성 이 3가지 요소를 적절히 조합하거나 최소한 세 가지 요소를 반드시 지원해야 한다고 말한다.</p>



<h3 class="wp-block-heading">캡슐화</h3>



<p class="wp-block-paragraph">객체지향에서 캡슐화를 언급하는 이유는 데이터와 함수를 효과적으로 캡슐화하는 방법을 객체지향 언어가 제공하기 때문이다. 캡슐화를 통해 응집력 있게 구성된 집단을 서로 구분하여 일부 데이터는 은닉되고 일부 함수만이 외부에 노출되도록 한다. </p>



<p class="wp-block-paragraph">그런데 객체지향을 통해서만 함수, 변수의 은닉이 용이하다라고 알려져 있지만 객체지향이 아닌 C언어에서도 header를 통해 완벽한 캡슐화가 가능하므로 캡슐화가 객체지향만의 특성으로 설명하기에는 부족하다. 그 예로 아래의 코드를 보면 Point 스트럭처는 double 타입의 x,y 멤버 변수를 가지고 있지만 외부에서 접근이나 인지할 방법이 없다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// point.h

struct Point; 
struct Point* makePoint(double x, double y);  
double distance (struct Point *p1, struct Point *p2)    
</pre>



<p class="wp-block-paragraph">// point.h 를 사용하는 쪽에서는 struct Point의 멤버는 접근할 수 없다. 사용자는  makePoint()함수와 distance()함수를 호출할 수는 있지만, Point구조체의 데이터 구조와 함수가 어떻게 구현되었는지에 대해서는 조금도 알지 못한다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// point.c
#include "point.h"
#include &lt;stdih.h>
#include &lt;math.h>

struct Point {
    double x, y;    // 헤더에 정의되지 않은 Point의 멤버변수는 외부 접근이 불가하다.
}

struct Point* makepoint(double x, double y) {
    struct Point* p = malloc(sizeof(struct Point));
    p->x = x;
    p->y = y;
    return p;
}

double distance(struct Point* p1, struct Point* p2) {
    double dx = p1->x - p1->x;
    double dy = p1->y - p2->y;
}</pre>



<p class="wp-block-paragraph">하지만 객체지향인 C++이 나오면서 C가 제공하던 완전한 캡슐화가 깨지게 되었다. C++컴파일러는 기술적인 이유로 클래스의 멤버 변수를 해당 클래스의 헤더 파일에 선언할 것을 요구했다. </p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// point.h

class Point {
public:
    Point(double x, double y);
    double distance(const Point&amp; p) const;

private:
    double x;
    double y;
};</pre>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// point.cc
#include "point.h"
#include &lt;math.h>

Point::Point(double x, double y)
: x(x), y(y)
{}

double Point::distance(const Point&amp; p) const {
    double dx = x-p.x;
    double dy = y-p.y;
    return sqrt(dx*dx + dy*dy);
}</pre>



<p class="wp-block-paragraph">point.h 헤더 파일을 사용하는 측에서는 멤버 변수인 x와 y를 알게 된다. 물론 멤버 변수에 접근하는 것을 컴파일러가 막기는 하지만 사용자 입장에서는 멤버 변수의 존재가 인지 가능하게 되고, 멤버 변수의 이름이 바뀐다면 point.cc파일은 다시 컴파일돼야 한다. 즉 캡슐화가 깨진 것이다. <br>언어에 public, private, protected 등의 접근 키워드를 도입하여 불완전한 캡슐화를 보완하기는 했지만 컴파일러가 헤더 파일에서 멤버 변수를 볼 수 있어야 했기 때문에 조치한 임시방편일 뿐이다.</p>



<p class="wp-block-paragraph">자바와 C#에 이르러서는 헤더와 구현체로 분리하는 방식을 버렸고 이로 인해 캡슐화는 더욱 훼손되었으며 이들 언어에서는 클래스 선언과 정의를 구분하는 게 아예 불가능하게 되었다. 이와 같은 이유로 객체지향이 강력한 캡슐화에 의존한다는 정의는 성립하기 힘들다. 실제로 많은 객체지향 언어가 캡슐화를 거의 강제하지 않는다.</p>



<h3 class="wp-block-heading">상속</h3>



<p class="wp-block-paragraph">상속이란 어떤 변수와 함수를 하나의 유효 범위로 묶어서 재정의 하는 것이다. 하지만 상속도 객체지향 언어가 있기 훨씬 이전에도 C프로그래머는 언어의 도움 없이 손수 이러한 방식을 구현할 수 있었다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// namedPoint.h

struct NamePoint;

struct NamedPoint* makeNamedPoint(double x, double y, char* name);
void setName(struct NamedPoint* np, char* name);
char* getName(struct NamedPoint* np);</pre>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// namedPoint.c

#include "namedPoint.h"
#include &lt;stdlib.h>

// c1
struct NamedPoint {
    double x, y;
    char* name;
};

// c2
struct NamedPoint* makeNamedPoint(double x, double y, char* name) {
    p->x = x;
    p->y = y;
    p->name = name;
    return p;
}

void setName(struct NamedPoint* np, char* name) {
    np->name = name;
}

char* getName(struct NamedPoint* np) {
    return np->name;
}</pre>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">// main.c

#include "point.h"  // m1
#include "namedPoint.h"
#include &lt;studio.h>

int main(int ac, char** av) {
    struct NamedPoint* origin = makeNamedPoint(0.0, 0.0, "origin"); // m2
    struct NamedPoint* upperRight = makeNamedPoint(1.0, 1.0, "upperRight"); // m3

    // m4
    printf("distance=%f\n", 
        distance(
            (struct Point*) origin,
            (struct Point*) upperRight)
        );
}</pre>



<p class="wp-block-paragraph">NamedPoint 타입의 객체를 Point 클래스에 선언된 distance 함수에 전달하여 실행하는 형태로 보이는데 이는 NamedPoint와 Point에 정의된 멤버 변수의 순서가 동일하기 때문에 가능하다.<br>결국 NamePoint가&nbsp;<code>Point를 상속받은 형태처럼 보이는 구조</code>가 되며 객체지향 이전부터 상속이 사용되어온 방식이라는 의미가 된다.<br>하지만 어디까지나 상속처럼 보이는 방식이고 사용이 용이하지 않으며 다중 상속을 구현하려면 복잡도가 더 올라간다.<br>또한 distance 함수가 Point타입을 인자로 받기 때문에 업 캐스팅을 해야 했고 객체지향에서는 이 과정이 암묵적으로 이뤄진다.</p>



<p class="wp-block-paragraph">객체 지향 언어가 완전히 새로운 개념을 만들지는 못했지만 데이터 구조에 가면을 씌우는 일을 상당히 편리한 방식으로 제공했다고 볼 수는 있다.</p>



<h3 class="wp-block-heading">다형성</h3>



<p class="wp-block-paragraph">객체지향 언어가 있기전에 다형성을 표현하는 언어가 있었던가? 아래의 코드는 간단한 복사 프로그램으로 c 값이 존재하는 동안 putchar를 실행하는 프로그램이다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">#include &lt;stdio.h>

void copy() {
    int c;
    while ((c=getchar()) != EOF)    // getchar() 값이 존재하는 동안
        putchar(c); // putchar()를 실행한다
}</pre>



<p class="wp-block-paragraph">getchar() 함수는 STDIN에서 문자를 읽고 putchar() 함수는 STDOUT으로 문자를 쓴다.<br>getchar()와 putchar()의 행위가 STDIN 과 STDOUT 타입에 의존하므로 다형적이라고 말할 수 있다.</p>



<p class="wp-block-paragraph">다음은 표준함수를 재정의하여 플러그인 형태로 구현하고 사용하는 예를 보여준다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">struct FILE {
    void (*open)(cahr* name, int mode);
    void (*close)();
    int (*read)();
    void (*read)(char);
    void (*seek)(long index, int mode);
}
</pre>



<p class="wp-block-paragraph">Unix 운영체제의 경우 모든 입출력 장치는 다음과 같은 다섯가지의 표준함수를 제공할 것을 요구한다.<br>&#8220;열기<sub>open</sub>, 닫기<sub>close</sub>, 읽기<sub>read</sub>, 쓰기<sub>write</sub>, 탐색<sub>seek</sub>&#8220;<br>위 코드의 FILE 구조체는 이 다섯 함수를 가리키는 포인터를 담고 있다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">#include "file.h"

void open(char* name, int mode) {/*...*/};
void close() {/*...*/};
int read() {int c;/*...*/ return c;};
void write(char c) {/*...*/};
void seek(long index, int mode) {/*...*/}

struct FILE console = {open, close, read, write, seek};
</pre>



<p class="wp-block-paragraph">STDIN을 FILE*로 선언하면, STDIN은 콘솔 데이터 구조를 가리키므로  getchar()는 아래와 같은 방식으로 구현할 수 있다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">extern struct FILE* STDIN;

int getchar() {
    return STDIN->read();
}
</pre>



<p class="wp-block-paragraph">getchar()는 STDIN으로 참조되는 FILE 데이터 구조의 read 포인터가 가리키는 함수를 단순히 호출할 뿐이다.</p>



<p class="wp-block-paragraph">이처럼 단순한 기법이 모든 객체지향이 지닌 다형성의 근간이 되며 함수를 가리키는 포인터를 응용한 것을 다형성이라고 정의한다.이런 형태의 다형성은 폰 노이만 아키텍처가 구현된 이래로 사용이 가능했지만 함수 포인터를 초기화해야 하며 모든 함수는 이 포인터를 통해 호출해야 한다는 관례가 생기며 이를 어길 경우 버그가 발생하고 보수가 어렵다는 단점이 있었다. 하지만 객체지향에서는 이런 관례를 없애주며, 실수하지 않고 적용 부담이 적으면서 능력은 강력한 기능을 사용할 수 있게 되었다.</p>



<p class="wp-block-paragraph">객체지향 언어를 사용하면 다형성은 대수롭지 않게 사용할 수 있으며, 위와 같은 이유로 객체지향은 제어 흐름을 간접적으로 전환하는 규칙을 부과한다 라고 결론지을 수 있다.</p>



<h4 class="wp-block-heading">다형성이 가진 힘</h4>



<ul class="wp-block-list"><li>다형성이 뭐가 그렇게 좋은가?</li><li>위의 예에서 새로운 입출력 장치가 생긴다면 프로그램에는 어떠한 변화가 생기는가?</li><li>새로운 장비에서도 복사 프로그램이 동작하도록 만들려면 소스를 어떻게 수정해야 하는가? 아무런 변경도 필요치 않다.</li><li>위에서 작성한&nbsp;<a href="https://github.com/2beans/CleanArchitecture/blob/master/ch5.md#%EB%8B%A4%ED%98%95%EC%84%B1">copy()</a>&nbsp;함수가 입출력 드라이버의 소스코드에 의존하지 않기 때문에 입출력 드라이버가 FILE에 정의된 표준 함수를 구현한다면 copy() 함수는 재사용이 가능해진다. 즉 드라이버가 플러그인의 형태가 되고 copy() 함수는 장치 독립적이라는 의미가 된다. 이런 형태의 플러그인 아키텍처는 등장 이후 거의 모든 운영체제에서 구현되었으나 함수를 가리키는 포인터를 사용하는 것이 위험하기 때문에 대다수의 프로그래머에게 수용되지 못하였는데 객체지향의 등장으로 위험도가 낮아져 수용이 가능해졌다.</li></ul>



<h4 class="wp-block-heading"><a href="https://github.com/2beans/CleanArchitecture/blob/master/ch5.md#%EC%9D%98%EC%A1%B4%EC%84%B1-%EC%97%AD%EC%A0%84"></a>의존성 역전</h4>



<p class="wp-block-paragraph">고수준 함수(참조하는 쪽)가 저수준 함수(참조당하는 쪽)를 사용하기 위해 include, import, using 등의 구문으로 참조할 클래스를 지정한다. 이로 인해 제어 흐름이 저수준에서 고수준으로 의존하게 되는 구조가 발생한다.</p>



<p class="wp-block-paragraph">그림 5.2에는 F() 함수를 가진 인터페이스와 F() 함수가 구현된 ML1 클래스 인터페이스를 통해 간접적으로 ML1의 F() 함수를 호출하는 HL1 클래스의 도식이 있다.</p>



<figure class="wp-block-image size-large is-resized"><img fetchpriority="high" decoding="async" src="http://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc.jpg" alt="" class="wp-image-13378" width="768" height="277" srcset="https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc.jpg 1024w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-768x277.jpg 768w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-150x54.jpg 150w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-300x108.jpg 300w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-696x251.jpg 696w" sizes="(max-width: 768px) 100vw, 768px" /></figure>



<ul class="wp-block-list"><li>ML1과 I 인터페이스 사이의 의존성은 제어 흐름과 반대인 형태로 되어있고 이를 의존성 역전이라고 부른다.</li><li>객체지향은 다형성을 안전하고 편하게 제공하므로 소스 코드 의존성을 어디에서든 적용 가능하게 해 준다. 이로 인해 의존성 흐름의 제어가 완전히 가능해진다.</li><li>이러한 접근법을 사용한다면 객체지향 언어로 개발된 시스템을 다루는 소프트웨어 아키텍트는 시스템의 소스코드 의존성 전부에 대해 방향을 결정할 수 있는 절대적인 권한을 갖게 된다. 이것이 힘이며 바로 객체지향이 제공하는 힘이다. 그리고 객체지향이 지향하는 바이다.</li></ul>



<p class="wp-block-paragraph">이러한 힘으로 무엇을 할수 있나?</p>



<p class="wp-block-paragraph">업무 규칙이 데이터베이스와 사용자 인터페이스 UI에 의존하는 대신에, 시스템의 소스코드 의존성을 반대로 배치하여 데이터베이스와 UI가 업무규칙(비즈니스 로직)에 의존하게 만들 수 있다.</p>



<figure class="wp-block-image size-large is-resized"><img decoding="async" src="http://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-2.jpg" alt="" class="wp-image-13380" width="768" height="187" srcset="https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-2.jpg 1024w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-2-768x187.jpg 768w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-2-150x36.jpg 150w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-2-300x73.jpg 300w, https://www.daddyprogrammer.org/wp-content/uploads/2020/08/ioc-2-696x169.jpg 696w" sizes="(max-width: 768px) 100vw, 768px" /></figure>



<p class="wp-block-paragraph">그림 5.3의 업무 규칙은 고정되고 독립적인 형태가 되고 UI와 DB가 플러그인이 된다. 업무 규칙에서 UI나 DB를 호출하지 않게 된다. 따라서 업무규칙, UI, DB는 각각 분리된 컴포넌트로 컴파일할 수 있고 별도로 배포가 가능해진다. 이로 인해 각 모듈을 독립적으로 개발할 수 있고 개발 독립성을 확보할 수 있게 된다.</p>



<h3 class="wp-block-heading"><a href="https://github.com/2beans/CleanArchitecture/blob/master/ch5.md#%EA%B2%B0%EB%A1%A0"></a>결론</h3>



<ul class="wp-block-list"><li>객체지향이란<ul><li>다형성을 이용하여 전체 시스템의 소스 코드 의존성 제어 권한을 확보한다.</li><li>플러그인 아키텍처를 구성할 수 있게 되어 고수준 정책을 포함하는 모듈을 저수준의 세부사항을 포함하는 모듈로부터 독립성을 보장할 수 있다.(개발 독립성)</li><li>저수준의 세부사항은 중요도가 낮은 플러그인 모듈로 만들 수 있고 고수준의 정책을 포함하는 모듈과 별개로 개발 배포할 수 있다.(배포 독립성)</li></ul></li></ul>



<h3 class="wp-block-heading">6장. 함수형 프로그래밍</h3>



<p class="wp-block-paragraph">함수형 프로그래밍 개념은 프로그래밍 그 자체보다 앞서 등장했다. 이 패러다임에서 핵심이 되는 기반은 람다 계산법으로 알란조 처치가 1930년대에 발명했다.</p>



<p class="wp-block-paragraph">25까지의 정수의 제곱을 출력하는 예</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">public class Squint {
    public static void main(String args[]) {
        for(int i=0; i&lt;25; i++)
            System.out.println(i*i);
    }
}</pre>



<p class="wp-block-paragraph">클로저라는 함수형 언어로 다음과 같이 구현 가능하다.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">(println (take 25 (map ( fn [x] (* x x)) (range))))</pre>



<ul class="wp-block-list"><li>println, take, map, range는 모두 함수다. 리스프에서는 함수를 괄호안에 넣는 방식으로 호출한다.</li><li>(range) : range 함수 0부터 시작해 끝이 없는 정수리스트를 반환한다.</li><li>fn [x] (* x x)) : 익명 함수로, 곱셈 함수를 호출하면서 입력 인자를 두번 전달한다. 즉 입력의 제곱을 계산한다.</li><li>(take 25) : 앞서 제곱된 항목 25개로 구성된 새로운 리스트를 반환한다.</li><li>(println) : 앞서 25개의 정수에 대한 제곱값으로 구성된 리스트를 입력으로 받아 값을 출력한다.</li></ul>



<p class="wp-block-paragraph">Java 프로그램은 가변 변수(mutable variable)을 사용(반복문을 제어하는 i)하는데 가변 변수는 프로그램 실행중에 상태가 변할 수 있다. 클로저 프로그램에서는 이러한 가변 변수가 전혀 없다. 클로저에서 x와 같은 변수는 한번 초기화 되면 절대로 변하지 않는다. 즉 함수형 언어에서 변수는 변경되지 않는다.</p>



<h4 class="wp-block-heading">불변성과 아키텍처</h4>



<p class="wp-block-paragraph">아키텍처를 고려할 때 변수의 가변성이 중요한데, 경합 조건(race condition), 교착상태(dead lock), 동시 업데이트(concurrent update) 문제가 모두 가변 변수로 인해 발생하기 때문이다.</p>



<p class="wp-block-paragraph">즉, 동시성 애플리케이션에서 마주치는 모든 문제, 즉 다수의 스레드와 프로세스를 사용하는 애플리케이션에서 마주치는 모든 문제는 가변 변수가 없다면 절대로 생기지 않는다.</p>



<p class="wp-block-paragraph">아키텍트는 동시성 문제에 지대한 관심을 가져야 하며, 설계한 시스템이 다수의 스레드와 프로세스에서 문제없이 돌아갈 수 있도록 변수의 불변성이 실현 가능한지 반드시 확인해 봐야 한다.</p>



<h4 class="wp-block-heading">가변성의 분리</h4>



<p class="wp-block-paragraph">불변성과 관련한 주요한 타협 중의 하나는 애플리케이션, 또는 내부의 서비스를 가변 컴포넌트와 불변 컴포넌트로 분리하는 것이다. 불변 컴포넌트에서는 순수하게 함수형 방식으로만 작업이 처리되며, 어떤 가변 변수도 사용되지 않는다.</p>



<p class="wp-block-paragraph">불변 컴포넌트는 하나이상의 순수 함수형 컴포넌트가 아닌 다른 가변 컴포넌트와 서로 통신한다.</p>



<p class="wp-block-paragraph">상태 변경은 동시성 문제를 노출시키므로, 트랜잭션 메모리와 같은 방식을 통해 메모리의 변수를 처리한다. 즉 트랜잭션을 사용하거나 재시도 기법을 통해 변수를 보호한다.</p>



<p class="wp-block-paragraph">애플리케이션을 제대로 구조화하려면 변수를 변경하는 컴포넌트와 변경하지 않는 컴포넌트를 분리하고, 이렇게 분리하려면 가변 변수들을 보호하는 적절한 수단을 동원해 뒷받침해야 한다.</p>



<p class="wp-block-paragraph">현명한 아키텍트라면 가능한 한 많은 처리를 불변 컴포넌트로 옮겨야 하고, 가변 컴포넌트에서는 가능한 한 많은 코드를 빼내야 한다.</p>



<h4 class="wp-block-heading">이벤트 소싱</h4>



<p class="wp-block-paragraph">이벤트 소싱은 상태가 아닌 트랜잭션을 저장하자는 전략이다. 상태가 필요해지면 단순히 상태의 시작점부터 모든 트랜잭션을 처리한다.</p>



<p class="wp-block-paragraph">이 전략에는 데이터 저장공간이 많이 필요하다. 현대 시대에 데이터 저장소는 급격하게 증가하여 수 테라바이트도 적다고 여기는 시대이므로 저장공간을 충분히 확보할 수 있다.</p>



<p class="wp-block-paragraph">중요한 점은 데이터 저장소에서 삭제되거나 변경되는 것이 하나도 없다는 사실이다.</p>



<p class="wp-block-paragraph">결과적으로 애플리케이션은 CRUD가 아니라 그저 CR만 수행한다. 데이터 저장소에서 변경과 삭제가 전혀 발생하지 않으므로 동시 업데이트 문제 또한 일어나지 않는다. 저장 공간과 처리 능력이 충분하면 애플리케이션이 완전한 불변성을 갖도록 만들 수 있고, 따라서 완전한 함수형으로 만들 수 있다.</p>



<p class="wp-block-paragraph">=&gt; 소스코드 버전 관리 시스템이 이러한 방식으로 동작한다.</p>



<p class="wp-block-paragraph">요약</p>



<ul class="wp-block-list"><li>구조적 프로그래밍은 제어흐름의 직접적인 전환에 부과되는 규율이다.</li><li>객체지향 프로그래밍은 제어흐름의 간접적인 전환에 부과되는 규율이다.</li><li>함수형 프로그래밍은 변수 할당에 부과되는 규율이다.</li></ul>



<p class="wp-block-paragraph">세 패러다임 모두 무언가를 앗아간다. 각 패러다임은 우리가 코드를 작성하는 방식의 형태를 한정시킨다. 지난 반세기 동안 우리가 배운것은 해서는 안되는 것에 대해서다. 이러한 사실에 기반해볼때 소프트웨어는 급격히 발전하는 기술이 아니라는 사실을 알수 있다. 1946년 앨런 튜링이 최초의 코드를 작성할 때 사용한 소프트웨어 규칙과 지금의 소프트웨어 규칙은 조금도 다르지 않다. 도구는 달라졌고 하드웨어도 변했지만, 소프트웨어 핵심은 여전히 그대로다.</p>
<p>The post <a href="https://www.daddyprogrammer.org/post/10417/clean-architecture-programming-paradigm/">Clean architecture 2부 &#8211; programming-paradigm</a> appeared first on <a href="https://www.daddyprogrammer.org">아빠프로그래머의 좌충우돌 개발하기!</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.daddyprogrammer.org/post/10417/clean-architecture-programming-paradigm/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
		
		<series:name><![CDATA[Clean Architecture(클린아키텍처)]]></series:name>
	</item>
		<item>
		<title>Clean architecture 1부 &#8211; Intro</title>
		<link>https://www.daddyprogrammer.org/post/10214/clean-architecture/</link>
					<comments>https://www.daddyprogrammer.org/post/10214/clean-architecture/#comments</comments>
		
		<dc:creator><![CDATA[happydaddy]]></dc:creator>
		<pubDate>Sat, 18 Apr 2020 13:21:33 +0000</pubDate>
				<category><![CDATA[Book]]></category>
		<category><![CDATA[Architecture]]></category>
		<category><![CDATA[Clean architecture]]></category>
		<guid isPermaLink="false">http://3.36.120.4/?p=10214</guid>

					<description><![CDATA[<p>저자소개 로버트C 마틴 “밥 아저씨(Uncle Bob)”로 불리기도 한다. 1970년부터 프로그래머로 활동했다. 전 세계 콘퍼런스에서 호평받는 연사이며, 《클린 코드》, 《UML 실전에서는 이것만 쓴다》, 《클린 코더》, 《클린 소프트웨어》의 저자다. ‘엉클 밥 컨설팅(Uncle Bob Consulting, LLC)’의 창립자이자 ‘클린 코더(Clean Coders, LLC)’의 공동 창립자다. 또한 ‘애자일 얼라이언스(Agile Alliance)’의 초대 회장과 《The C++ Report》의 편집장을 지냈으며 ‘오브젝트 멘토(Object Mentor)’의 공동 [&#8230;]</p>
<p>The post <a href="https://www.daddyprogrammer.org/post/10214/clean-architecture/">Clean architecture 1부 &#8211; Intro</a> appeared first on <a href="https://www.daddyprogrammer.org">아빠프로그래머의 좌충우돌 개발하기!</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">저자소개</h2>



<h3 class="wp-block-heading">로버트C 마틴</h3>



<figure class="wp-block-image size-large is-resized"><img decoding="async" src="http://www.daddyprogrammer.org/wp-content/uploads/2020/06/로버트C마틴.jpeg" alt="" class="wp-image-10681" width="235" height="161" srcset="https://www.daddyprogrammer.org/wp-content/uploads/2020/06/로버트C마틴.jpeg 235w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/로버트C마틴-150x103.jpeg 150w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/로버트C마틴-218x150.jpeg 218w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/로버트C마틴-100x70.jpeg 100w" sizes="(max-width: 235px) 100vw, 235px" /></figure>



<p class="wp-block-paragraph">“밥 아저씨(Uncle Bob)”로 불리기도 한다. 1970년부터 프로그래머로 활동했다. 전 세계 콘퍼런스에서 호평받는 연사이며, 《클린 코드》, 《UML 실전에서는 이것만 쓴다》, 《클린 코더》, 《클린 소프트웨어》의 저자다. ‘엉클 밥 컨설팅(Uncle Bob Consulting, LLC)’의 창립자이자 ‘클린 코더(Clean Coders, LLC)’의 공동 창립자다. 또한 ‘애자일 얼라이언스(Agile Alliance)’의 초대 회장과 《The C++ Report》의 편집장을 지냈으며 ‘오브젝트 멘토(Object Mentor)’의 공동 창립자이자 리더다.</p>



<figure class="wp-block-image size-large is-resized"><img loading="lazy" decoding="async" src="http://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음.jpeg" alt="" class="wp-image-10682" width="600" height="600" srcset="https://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음.jpeg 800w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음-300x300.jpeg 300w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음-768x768.jpeg 768w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음-150x150.jpeg 150w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음-696x696.jpeg 696w, https://www.daddyprogrammer.org/wp-content/uploads/2020/06/저서모음-420x420.jpeg 420w" sizes="auto, (max-width: 600px) 100vw, 600px" /></figure>



<h3 class="wp-block-heading">개요</h3>



<p class="wp-block-paragraph"><span style="text-decoration: underline;"><strong>클린아키텍처</strong></span>에서는 소프트웨어 아키텍트가 해내야 할 일과 그 일을 해내기 위한 규율과 실천법을 설명하고 있다. 기능, 구성요소 분리, 데이터 관리를 위한 소프트웨어 설계 핵심 원칙을 배우고, 프로그래밍 패러다임이 규율을 강제하기 위해 개발자의 자유를 어떻게 제약하는지 알아본다. 또한, 웹, 데이터베이스, 리치 클라이언트, 콘솔, 임베디드 애플리케이션의 고수준 구조를 최적화하고, 아키텍처가 잘못되는 이유와 잘못된 결과가 나오지 않게 예방하거나 고치는 방법에 대하여 설명한다.</p>



<h3 class="wp-block-heading">변함없는 프로그래밍 규칙</h3>



<p class="wp-block-paragraph">새로운 언어, 새로운 프레임워크의 등장에도 불구 앨런 튜링이 최초로 기계어 코드를 작성한 1946년 이후 규칙은 달라지지 않았다. 언어가 발전하고 도구가 환상적으로 좋아졌지만 코드는 여전히 순차, 분기, 반복 등의 집합체일 뿐이다. 소프트웨어 아키텍처의 규칙이란 프로그램의 구성요소를 정렬하고 조립하는 방법에 관한 규칙이다. 그리고 이 구성요소가 보편적이며 변하지 않았으므로, 이들을 정렬하는 규칙 역시도 보편적이며 변한 게 없다. 이 책은 세월이 흘러도 변치않는 규칙에 관한 것이다.</p>



<h4 class="wp-block-heading">1-1장. <strong>설계와 아키텍처</strong></h4>



<p class="wp-block-paragraph">프로그램을 동작하게 만드는 데는 엄청난 수준의 지식과 기술을 필요로하지 않는다. 프로그램을 동작하게 만드는 건 그리 어려운 일이 아니기 때문이다. 그러나 프로그램을 제대로 만들어내는것은 전혀 다르다. 소프트웨어를 제대로 만들려면 적정 수준의 지식과 기술을 겸비하고 사고력과 통찰력을 갖춰야 한다. 하지만 대다수의 프로그래머는 시간을 들여 이러한 능력을 개발하지 않는다.</p>



<p class="wp-block-paragraph">소프트웨어를 제대로 만들면&#8230;</p>



<ul class="wp-block-list"><li>소수의 프로그래머 만으로 프로그램이 지속적으로 동작하도록 만들 수 있다.</li><li>거대한 요구사항 문서와 이슈가 수없이 등록된 이슈 추적 시스템이 필요없다.</li><li>아주 적은 인력만으로 새로운 기술을 추가하거나 유지보수 할수 있고, 변경은 단순해지고 빠르게 반영할 수 있다.</li><li>최소한의 노력으로 기능과 유연성을 최대화 할 수 있다. 즉 작은 사무실에서 휴일없이 일해야 하는 프로그래머가 없어도 된다.</li></ul>



<p class="wp-block-paragraph">내가 만든 시스템 되돌아 보기</p>



<ul class="wp-block-list"><li>서로 강하게 연관되어있고 복잡하게 결합되어서 아주 사소한 변경에도 오래걸릴 뿐만 아니라 수정에도 큰 위험을 감수해야 하지는 않는가?</li><li>잘못된 코드와 끔찍한 설계로 인해 방해를 받지는 않는가? </li><li>시스템의 설계가 팀의 사기를 떨어뜨리거나 고객의 신뢰를 잃고 관리자의 인내심을 시험하는 부정적인 영향을 끼치지 않았나? </li><li>형편없는 소프트웨어 구조로 인해 실패한 적은 없나? 프로그래밍 지옥을 경험하지 않았나?</li></ul>



<p class="wp-block-paragraph">대부분의 개발자들은  훌륭한 소프트웨어 설계를 바탕으로 작업하면서 즐거움을 느끼기보다는 형편없는 소프트웨어 설계와 맞서 싸우는 일을 훨씬 더 자주 맞닥뜨리게 된다.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>소프트웨어 아키텍처의 목표는 필요한 시스템을 만들고 유지 보수하는데 투입되는 인력을 최소화하는데 있다.</p><p></p></blockquote>



<h4 class="wp-block-heading">설계와 아키텍처란?</h4>



<p class="wp-block-paragraph">아키텍처는 저수준의 세부사항과는 분리된 ‘고수준의 무언가’를 가리킬 때가 많다. 그에반해 설계는 저수준의 세부 구조 또는 결정사항을 의미할 때가 많다.</p>



<p class="wp-block-paragraph">아키텍트 입장에서 저수준의 세부사항과 고수준의 구조를 분리해서 생각하는 것은 무의미하다.&nbsp;두 가지 사항은 모두 개별로는 존재할 수 없고 실제로 구분 짓는 경계도 뚜렷하지 않기 때문이다. 다만 고수준에서 저수준으로 향하는 의사결정의 연속성만이 있을 뿐이다.</p>



<h4 class="wp-block-heading">설계 품질을 재는 척도</h4>



<p class="wp-block-paragraph">고객의 요구를 만족시키는데 드는 비용이 낮고 시스템의 수명이 다할 때까지 낮게 유지할 수 있으면 좋은 설계이다. 하지만 새로운 기능을 출시할 때마다 비용이 증가한다면 나쁜 설계다.</p>



<h4 class="wp-block-heading">사례1</h4>



<p class="wp-block-paragraph">지속적으로 엔지니어수가 늘어나는 회사는 겉으로는 굉장히 성공을 이룬 것처럼 보인다. 하지만 깊게 들여다 봤을 때 동일한 기간의 생산성이 낮아지고 출시할 때마다 발생하는 개인 당 비용이 점점 늘어나 충원으로 이어지는 것이라면 회사는 성장을 멈췄거나 완전히 망하는 길고 가고 있다는 신호이다.</p>



<h4 class="wp-block-heading">엉망진창이 되어가는 신호</h4>



<p class="wp-block-paragraph">개발자의 생산성은 100%에서 시작했지만 새로운 제품을 출시할 때마다 생산성이 하락한다. 네 번째 출시에 다다르면 확실히 생산성은 거의 바닥을 치고 결국에는 0으로 수렴한다. 개발자 입장에서 이러한 현상은 지독한 절망감을 안겨주는데 모두가 열심히 일하고 있기 때문이다. 전력을 기울이지 않는 개발자는 없다.</p>



<p class="wp-block-paragraph">개발자는 노력을 하고 잔업을 하고 헌신함에도 불구 더 이상 진척이 없는 상황에 처하게 된다. 개발자의 노력은 기능 개발보다는 엉망이 된 상황에 대처하는데 소모되기 시작한다. 심지어 사소한 기능을 추가하는 일도 그저 엉망이 된 코드를 이곳에서 저곳으로 다시 다음 곳으로 이동하는 반복 작업으로 변질된다. 결국 개발자들이 쏟은 노력의 가치는 결국 보잘것없는 것이 된다.</p>



<h4 class="wp-block-heading">경영자의 딜레마</h4>



<p class="wp-block-paragraph">개발이 늦어지니 점점 더 많은 인력을 투입하게 되며 월별 인건비가 계속 상승하는 것을 경험할 수 있다. 더구나 마지막 출시에는 많은 돈을 들이고도 얻은 게 거의 없는 상태가 된다.</p>



<h4 class="wp-block-heading">무엇이 잘못되었는가? </h4>



<p class="wp-block-paragraph">생산성이 믿을 수없이 낮아진 원인은 무엇인가. 개발자에게 고함치는 일 외에 경영자는 무슨 일을 할 수 있을 것인가?</p>



<h4 class="wp-block-heading">토끼와 거북이 이야기</h4>



<p class="wp-block-paragraph"><strong>교훈</strong></p>



<p class="wp-block-paragraph">&#8211; 느려도 꾸준하면 이긴다. <br>&#8211; 발 빠른 자가 경주에 이기는 것도 아니며, 힘센 자가 싸움에서 이기는 것도 아니다. 급할수록 돌아가라</p>



<h5 class="wp-block-heading">지나친 과신이 가진 어리석음</h5>



<p class="wp-block-paragraph">현대의 개발자도 토끼와 유사한 과신을 드러낸다. 다만 현실의 개발자는 잠을 자지 않고 뼈 빠지게 일한다. 그러나 그들의 뇌는 잠에 취해있다. 훌륭하고 깔끔하게 잘 설계된 코드가 중요하다는 사실을 알고 있는 그 뇌가 잠자고 있다.</p>



<h5 class="wp-block-heading">개발자가 속는 더 잘못된 거짓말1</h5>



<p class="wp-block-paragraph">“코드는 나중에 정리하면 돼, 당장은 시장에 출시하는 게 먼저야”라는 흔한 거짓말에 속는다. 이렇게 속아 넘어간 개발자는 나중에 코드를 정리하는 경우는 한 번도 없는데, 왜냐하면 시장의 압박은 절대로 수 그러 들지 않기 때문이다.(말 그대로 일이 많다) 경쟁자보다 앞서 가려면 가능한 한 빠르게 달려야 하기 때문이다.</p>



<p class="wp-block-paragraph">토끼가 자신의 빠르기를 과신한 것처럼, 개발자도 생산성을 유지할 수 있다고 능력을 과신한다. 하지만 좋지 않은 코드가 서서히 쌓이면 개발자 생산성은 점차 낮아지고, 코드가 엉망이 되는 추세는 절때 멈추거나 수그러들지 않는다.</p>



<h5 class="wp-block-heading">개발자가 속는 더 잘못된 거짓말2</h5>



<p class="wp-block-paragraph">개발자가 속는 더 잘못된 거짓말은 지저분한 코드를 작성하면 단기간에는 빠르게 갈 수 있고, 장기적으로 볼 때만 생산성이 낮아진다는 견해다. 엉망으로 만들면 깔끔하게 유지할 때보다 항상 더 느리다.</p>



<h5 class="wp-block-heading">제이스 고먼의 테스트</h5>



<p class="wp-block-paragraph"><strong>일주일간의 테스트. 간단한 프로그램을 작성하고 완성하는데 걸리는 시간을 측정</strong></p>



<ul class="wp-block-list"><li>TDD를 적용하지 않은 채 1,3,5일에 작성</li><li>TDD를 적용한 채 2,4,6일에 작성</li><li>날이 갈수록 TDD를 적용한 날이 적용 안 한 날 보다 10%빠르게 작업이 완성이 되었다.</li><li>더구나 TDD를 적용하고 가장 느렸던 날이 TDD를 적용하지 않고 가장 빨랐던 날보다도 빨랐다</li></ul>



<h3 class="wp-block-heading">결론</h3>



<p class="wp-block-paragraph">빨리 가는 유일한 방법은 제대로 가는 것이다.</p>



<p class="wp-block-paragraph">생산성이 감소되고 비용이 증가하는 현상을 되돌릴 수 있는 유일한 방법은 개발자로 하여금 토끼처럼 과신하려는 믿음을 버리고, 만들어낸 엉망진창인 코드를 개발자가 책임지도록 하는 것뿐이다.</p>



<p class="wp-block-paragraph">개발자의 잘못된 생각 &#8211; 처음부터 다시 시작하여 전체 시스템을 재 설계하는 것이 해답이다. </p>



<p class="wp-block-paragraph">이것조차 토끼의 말과 다름없다. 엉망으로 내몰았던 그 과신이 경주를 다시 시작한다면 더 나은 코드를 만들 수 있다고 말하는 것이다. 현실은 장밋빛과는 거리가 멀다. 자신을 과신한다면 재설계하더라도 원래의 프로젝트와 똑같이 엉망으로 내몰릴 것이다.</p>



<h5 class="wp-block-heading">개발조직이 할수 있는 최고의 선택지 </h5>



<p class="wp-block-paragraph">조직에 스며든 과신을 인지하여 방지하고 소프트웨어 아키텍처의 품질을 심각하게 고민하기 시작하는 것이다. 심각하게 고민하려면 좋은 소프트웨어 아키텍처가 무엇인지 이해해야 한다.</p>



<h3 class="wp-block-heading">1-2장. 두가지 가치에 대한 이야기</h3>



<p class="wp-block-paragraph">소프트웨어 시스템은 이해관계자에게 행위와 아키텍처라는 서로 다른 두 가지 가치를 제공한다. </p>



<h4 class="wp-block-heading">행위</h4>



<p class="wp-block-paragraph">프로그래머는 이해관계자가 수익을 창출하거나 비용을 절약할 수 있도록 하기 위해 기능 명세서나 요구사항 문서를 구체화할 수 있도록 돕는다. 그리고 이러한 요구사항을 만족하도록 코드를 작성한다. 요구사항에 위배되면 프로그래머는 디버거를 열고 문제를 고친다. 많은 프로그래머가 이러한 활동이 자신이 해야 할 일의 전부라고 생각한다. 요구사항을 기계에 구현하고 버그를 수정하는 일이 자신의 직업이라고 믿는다.</p>



<h4 class="wp-block-heading">아키텍처</h4>



<p class="wp-block-paragraph">소프트웨어는 부드러운 제품이라는 단어의 합성어이다. 소프트웨어는 부드러움을 지니도록 만들어졌고, 소프트웨어를 만든 이유는 기계의 행위를 쉽게 변경할 수 있도록 하기 위해서다. 소프트웨어가 가진 본연의 목적을 추구하려면, 부드러워야 한다. 다시 말해 변경하기 쉬어야 한다. 이해관계자가 기능에 대한 생각을 바꾸면 이러한 변경사항을 간단하고 쉽게 적용할 수 있어야 한다.</p>



<p class="wp-block-paragraph">이해관계자는 비슷한 일련의 변경사항을 제시할 뿐이지만, 개발자 입장에서는 복잡도가 지속적으로 증가하는 퍼즐판 위에서 계속해서 퍼즐을 맞추라는 지시를 하는 것처럼 느껴진다. 따라서 새로운 요청사항이 발생할 때마다 이전의 변경사항을 적용하는 것보다 조금 더 힘들어진다. 아키텍처가 특정 형태를 다른 형태보다 선호하면 할수록 , 새로운 기능을 이 구조에 맞추는 게 더 힘들어진다. 따라서 아키텍처는 형태에 독립적이어야 하고 그럴수록 더 실용적이다.</p>



<h4 class="wp-block-heading">더 높은 가치</h4>



<p class="wp-block-paragraph">행위인가 아키텍처인가? 둘 중 어느 것의 가치가 더 높은가? 소프트웨어 시스템을 동작하도록 만드는 것이 더 중요한가? 아니면 소프트웨어 시스템을 더 쉽게 변경할 수 있도록 하는 것이 더 중요한가?</p>



<p class="wp-block-paragraph">완벽하게 동작하지만 수정이 불가능한 프로그램은 요구사항이 변경될 때 동작하지 않게 되고 거의 쓸모없는 프로그램이 된다. 동작은 하지 않지만 변경이 가능한 시스템은 돌아가게 만들고 변경사항이 발생하더라도 여전히 동작하도록 유지보수할 수 있다.</p>



<p class="wp-block-paragraph">수정이 불가능한 시스템은 존재하지 않지만 변경에 드는 비용이 변경으로 창출되는 비용보다 초과될 경우 수정이 현실적으로 불가능한 상황에 놓이게 된다. 추 후 업무자의 변경 요청에 비용이 너무 커서 적용이 힘들다고 하면 변경이 불가능한 상태까지 시스템을 방치했다며 화를 낼 것이다.</p>



<p class="wp-block-paragraph">소프트웨어의 가치인 행위는 긴급하지만 매번 높은 중요도를 가지진 않는다. 소프트웨어의 두 번째 가치인 아키텍처는 중요하지만 즉각적인 긴급성을 요하는 경우는 거의 없다.</p>



<p class="wp-block-paragraph">아이젠하워 미국 대통령이 고안한 중요성과 긴급성에 대한 메트릭스</p>



<p class="wp-block-paragraph">1. 긴급하고 중요한<br>2. 긴급하지는 않지만 중요한<br>3. 긴급하지만 중요하지 않은<br>4. 긴급하지도 않고 중요하지도 않은</p>



<p class="wp-block-paragraph">아키텍처, 즉 중요한 일은 이 항목의 가장 높은 두 순위를 차지하는 반면 행위는 첫 번째와 세 번째에 위치한다는 점을 주목하자.</p>



<p class="wp-block-paragraph">업무관리자와 개발자가 저지르는 가장 큰 실수는 3번째 내용을 첫 번째로 격상하는 것이다. 긴급하지만 중요하지 않은 기능과 진짜 긴급하면서 중요한 기능을 구분하지 못한다. 업무관리자는 보통 아키텍처의 중요성을 평가할 만한 능력을 지니고 있지 않기 때문에 개발자는 딜레마에 빠진다.</p>



<h4 class="wp-block-heading">아키텍처를 위해 투쟁하라.</h4>



<p class="wp-block-paragraph">효율적인 소프트웨어 개발팀은 뻔뻔함을 무릅쓰고 다른 이해관계자들과 동등하게 논쟁해야 한다. 소프트웨어 개발자는 소프트웨어를 안전하게 보호해야 할 책임이 있으며 또 하나의 이해관계자에 속하므로 이러한 투쟁은 역할이며 책무 중 하나이다. </p>



<p class="wp-block-paragraph">만약 당신이 소프트웨어 아키텍트라면 이러한 도전은 2배로 중요해진다. 시스템이 제공하는 특성이나 기능보다는 시스템의 구조에 더 중점을 둬야 한다.</p>



<p class="wp-block-paragraph">아키텍트는 이러한 특성이나 기능을 개발하기 쉽고 간편하게 수정할 수 있으며 확장하기 쉬운 아키텍처를 만들어야 한다. 아키텍처가 후순위가 되면 개발하는 비용이 상승하고 전체 시스템에 변경을 가하는 일이 현실적으로 불가능해진다. 이러한 상황이 발생하도록 용납했다면 소프트 웨어 개발팀이 스스로 옳다고 믿는 가치를 위해 충분히 투쟁하지 않았다는 뜻이다.</p>
<p>The post <a href="https://www.daddyprogrammer.org/post/10214/clean-architecture/">Clean architecture 1부 &#8211; Intro</a> appeared first on <a href="https://www.daddyprogrammer.org">아빠프로그래머의 좌충우돌 개발하기!</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.daddyprogrammer.org/post/10214/clean-architecture/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
		
		<series:name><![CDATA[Clean Architecture(클린아키텍처)]]></series:name>
	</item>
	</channel>
</rss>
