추가 적립 안내

『소프트웨어 장인』에 이은 또 한 권의 ‘로버트 C. 마틴 시리즈’ 베스트셀러!
70년 동안 개발자들에게 검증 받은 개발 방법론과 주옥 같은 팁들을 한 권으로 총 정리!

'좋은 소프트웨어 설계를 하라'는 말에 명확한 답과 방법을 떠올릴 수 있는가? 개발은 명확한 답이 없는 문제를 경험, 직관, 시행착오를 겪으며 점점 만족스러운 설계로 발전시키는 과정이다. 이 과정에서 더 뛰어난 사람들에게 배우기도 하고, 배운 것을 다시 조언해 주기도 한다. 이 책에서는 오랫동안 시도하고 개선한 끝에 검증된 방법들, 그러나 체계적으로 정리되지 않아 흩어져 있던 수많은 답과 방법들을 모아 일관되고 효율적인 방식으로 제시했다. 코드를 복잡하지 않게, 지속 가능하게, 유지/보수하기 쉽게, 인간이 이해할 수 있게 작성할 수 있는 방법과 아이디어들을 이 한 권으로 정리해보자.

읽기 쉬운 코드가 좋은 코드다.
내 손과 내 머리로, 복잡한 코드와 프로젝트를 통제하라!

여러분은 코드를 어떻게 관리하고 있는가? 다른 사람이 더 좋은 코드를 작성하는 방법을 물어보면 뭐라고 조언해주는가? 대부분 여러분보다 더 뛰어난 사람들에게 배운 지식과 아이디어를 떠올릴 것이다. 세상에는 수많은 뛰어난 사람들이 이미 생각했고 고안해낸 좋은 방법들이 흩어져 있다. 이 책은 그러한 지식과 지혜를 한데 모아 한 권으로 응축시켰다.
그리고 응축된 지혜를 매우 실용적이고 효과적으로 전달하고자 했다. 본문의 설명과 개념이 실제로 코드를 어떻게 변화시키고 진화시키는지 레스토랑 예약 시스템을 구현하는 예제를 통해 자세히 보여주고, 이를 통해 프로젝트를 시작부터 끝까지 경험하면서 현대 소프트웨어 엔지니어링의 좋은 관행을 복습하고 더 나은 코드를 작성하는 방법, 복잡하고 유지보수할 수 없는 코드를 개선하는 방법을 배울 수 있게 안배했다.

[옮긴이의 한마디]
어느 정도 이상의 규모를 가진 코드를 다루다 보면 나중에 항상 문제가 되는 부분이 있습니다. 작성된 코드는 점점 유지보수하기 어려워지고, 점점 낡은 코드가 되다가 어느 순간 그 누구도 건드리기 어려운, 엔지니어의 생명력을 길게 만들어주는 코드가 된다는 것이죠. 이건 코드가 사유화된다는 의미로도 볼 수 있을 것입니다. 공동 작업의 결과물이자 우리가 진행한 작업의 가장 최종적인 산출물이 말이죠.
처음 이 책에 대한 번역을 제안받았던 그때가 생각납니다. 회사를 옮긴 후 해석하기 어려운 레거시 코드와 씨름을 하고 있었고, 알 수 없는 판단들의 근거를 찾아내기 위해서 분투하고 있었습니다. 다행히 회사에는 클린 코드의 생각에 동조하는 동료가 많았고(물론 동의하지 않는 사람도 있었고), 어떻게 하면 조금 더 좋은 코드를 만들 수 있을지 고민하는 사람들이 있었습니다.
저는 이 책을 코드라는 산출물을 다뤄야 하는 많은 엔지니어와 매니저들에게 권하고 싶습니다. 코드라는 궁극적인 산출물을 어떻게 인식하고, 어떻게 관리해야 할 것인지, 그리고 코딩이라는 작업을 어떤 관점에서 바라봐야 할 것인지에 대해서 대한 이야기도 충분하게 하고 있다고 봅니다.

고주형(백엔드 개발자 취업 준비 중, 중앙대학교 소프트웨어학부)
합리적인 근거를 기반으로 사람이 인지적으로 이해하기 쉬운 방향으로 프로그램을 만들어 가는 전반적인 과정을 체험하며 습관으로 가질 만한 여러 프랙티스를 배울 수 있게 되어 기쁩니다.

문주영(웹 프론트엔드 개발자, 스타트업)
그동안 읽기 쉬운 코드가 좋은 코드라는 말을 들어보기만 했습니다. 그리고 그 실체가 과연 어떠한 것일지 아직도 고민하며 개발합니다. 이 책은 읽기 쉬운 코드에 대해 먼저 고민해준 선배가 전하는 이야기입니다. 소프트웨어의 패러다임과 노하우를 통해 전수되는 소프트웨어 산업의 특징과 함께, 노하우의 형태로만 전수될 수 밖에 없는 복잡미묘한 테크닉을 체계적으로 정리해, 개발자가 꼭 봐야할 책입니다. 이전 책에서는 볼 수 없었던 테크닉이 될 수 밖에 없었던 이유를 이해함으로써 좋은 코드에 대한 정의와 기술을 익힐 수 있을 것입니다.

조유민(애플리케이션 개발자, 플랜잇스퀘어)
이 책은 사람의 인지적 한계를 인정하며, 이를 바탕으로 누구나 이해할 수 있는 코드를 작성하는 방법을 탐구합니다. 이러한 접근법은 개발자들이 복잡성을 효과적으로 관리하고, 지속가능한 소프트웨어를 개발하는 과정에서 인지 부담을 줄여 전체 개발 프로세스를 개선하는 데 효과적인 가이드가 될 것입니다.

양완수(17년차 백앤드 개발자, 컬리)
경험을 쌓아가면서 순간 순간의 결정에 어떠한 이유가 있다는 생각이 어렴풋하게 들었습니다. 특히 후배 개발자나 같은 동료 개발자에게 결정의 이유를 전달하는 데 있어 휴리스틱하게 느껴지는 것들이 어딘가 정리되면 참 좋겠다고 생각했습니다. 그런 면에서 이 책은 엔지니어링에서 속도를 내는 법과 속도를 지속하는 법이 종합선물세트처럼 일목요연하게 정리되어 있습니다.

이석곤(빅데이터 개발자, (주)아이알컴퍼니)
코드를 작성할 때 고려해야 할 사항들을 체계적으로 정리하고 있습니다. 특히 코드의 가독성을 높이는 방법과 유지보수하기 쉬운 코드를 작성하는 방법에 대해 자세히 다룹니다. 인상 깊었던 부분은 ‘2부 지속가능성’입니다. 기존 코드를 보강하고 새로운 문제를 해결할 수 있도록 코드를 모듈화하고, 리팩터링 및 테스트를 작성하는 방법에 대해 설명합니다. 이 책을 읽으면서 자신이 작성한 코드를 되돌아보고, 책에서 제시하는 방법들을 적용해보면 좋을 것 같습니다.

로버트 C. 마틴(Robert C. Martin)
프로그래밍은 어렵습니다. 정말 어렵습니다. 그래서 지난 70년 동안 소프트웨어를 조금이라도 쉽게 만들 수 있는 방법을 찾아 노력해왔습니다. 저자는 70년 동안 고안된 최고의 아이디어들을 모아 이 책에 한 번에 정리해냈습니다. 소프트웨어 프로젝트 하나를 예로 들어 개발하면서 각각의 단계에 도움이 되는 휴리스틱 방식과 기법을 설명하는데, 다양한 주제를 다루고 책 곳곳에 말 그대로 주옥 같은 팁들이 흩어져 있습니다. 이 팁들은 저자가 오랜 시간 쌓아온 깊은 통찰력을 보여주지요.
그러니 주의 깊게 읽어보십시오. 저자의 흠잡을 데 없는 논리를 잘 생각하면서 따라가 보세요. 여기 나온 휴리스틱 방식과 기법을 습득해 내 것으로 만들어보세요. 통찰력이 느껴지는 팁이 나오면 잠시 멈춰서 음미해보세요.


이 책을 읽는 분들은 좋지 않은 소프트웨어 개발 프로젝트 때문에 고통받거나, 유지보수할 수 없는 코드를 경험한 적이 있을 겁니다. 그리고 이를 개선하고 싶어 한다고 생각할 겁니다. 프로그래머에서 소프트웨어 엔지니어로 거듭나려면 어떻게 해야 할까요? 이 책이 여러분을 엔지니어로의 길로 인도하기를 바랍니다.
소프트웨어 개발은 역사가 오래되지 않았기 때문에, 우리가 아직 이해하지 못하는 부분이 많다고 생각합니다. 하지만 모든 것을 알아낼 때까지 기다릴 수는 없죠. 우리는 실험을 통해 배웁니다. 이 책에 담긴 활동과 방법론은 저보다 앞선 많은 위대한 사람들에게 영감을 받았습니다. 이 책의 프랙티스(practice)들은 저와 제가 가르쳤던 많은 사람들에게 효과가 있었습니다. 여러분에게도 도움이 되기를 바라며, 더 좋은 방법을 찾는 데 영감을 준다면 좋겠습니다.

1부 속도를 높여봅시다

1장 예술인가? 과학인가?
__1.1 집 짓기 비유
____1.1.1 프로젝트라고 생각해서 발생하는 문제
____1.1.2 단계가 있다고 생각해서 발생하는 문제
____1.1.3 의존성의 차이
__1.2 정원 가꾸기 비유
____1.2.1 무엇이 정원을 키워주나요?
__1.3 공학으로 나아가기
____1.3.1 소프트웨어를 기술로 바라보는 관점
____1.3.2 휴리스틱 방식
____1.3.3 소프트웨어 공학의 초기 개념
____1.3.4 소프트웨어 공학으로 나아가기
__1.4 결론

2장 체크리스트
__2.1 기억 보조 수단
__2.2 새로운 코드베이스를 위한 체크리스트
____2.2.1 깃을 사용할 것
____2.2.2 빌드를 자동화할 것
____2.2.3 모든 오류 메시지를 켜둘 것
__2.3 기존 코드베이스를 위한 체크리스트
____2.3.1 점진적 개선
____2.3.2 조직 문화를 바꾸는 전략
__2.4 결론

3장 복잡성을 잘 다루는 법
__3.1 목적
____3.1.1 지속가능성
____3.1.2 가치
__3.2 프로그래밍이 어려운 이유
____3.2.1 두뇌에 비유하는 것
____3.2.2 코드는 작성하는 것보다 읽는 경우가 더 많다
____3.2.3 가독성
____3.2.4 지적인 작업
__3.3 소프트웨어 공학으로 나아가기
____3.3.1 컴퓨터 과학과의 관계
____3.3.2 인간 친화적인 코드
__3.4 결론

4장 수직 슬라이스
__4.1 동작하는 소프트웨어에서 시작하기
____4.1.1 데이터 수신에서 데이터 보존까지
____4.1.2 가장 간단한 수직 슬라이스
__4.2 동작하는 골격
____4.2.1 특성화 테스트
____4.2.2 준비-행동-어설트(AAA 패턴)
____4.2.3 정적 분석 조절
__4.3 외부 접근 개발
____4.3.1 JSON 수신
____4.3.2 예약 게시
____4.3.3 유닛 테스트
____4.3.4 DTO와 도메인 모델
____4.3.5 가짜 객체
____4.3.6 저장소 인터페이스
____4.3.7 저장소 생성
____4.3.8 의존성 구성
__4.4 슬라이스 완성
____4.4.1 스키마
____4.4.2 SQL 저장소
____4.4.3 데이터베이스 설정
____4.4.4 스모크 테스트 수행
____4.4.5 가짜 데이터베이스를 사용한 경계 테스트
__4.5 결론

5장 캡슐화하기
__5.1 데이터 저장하기
____5.1.1 변환 우선순위 전제
____5.1.2 매개변수를 이용하는 테스트
____5.1.3 DTO를 도메인 모델로 복사하기
__5.2 검증
____5.2.1 날짜가 잘못 입력된 경우
____5.2.2 빨강-초록-리팩터
____5.2.3 자연수
____5.2.4 포스텔의 법칙
__5.3 변하지 않는 값 보호하기
____5.3.1 항상 유효한 상태
__5.4 결론

6장 다각화하기
__6.1 단기 기억과 장기 기억
____6.1.1 레거시 코드와 메모리
__6.2 용량
____6.2.1 초과 예약
____6.2.2 악마의 변호인
____6.2.3 기존 예약 다루기
____6.2.4 악마의 변호인 vs. 빨강-초록-리팩터
____6.2.5 테스트는 언제 충분하다고 할 수 있을까?
__6.3 결론

7장 분해하기
__7.1 코드의 부패
____7.1.1 임계값
____7.1.2 순환 복잡도
____7.1.3 80/24 규칙
__7.2 머리에 잘 들어오는 코드
____7.2.1 육각꽃
____7.2.2 응집
____7.2.3 기능 편애
____7.2.4 바꾸는 과정에서 잃는 것들
____7.2.5 유효성 검사 대신 분석하라
____7.2.6 프랙탈 구조
____7.2.7 변수 세기
__7.3 결론

8장 API 설계
__8.1 설계의 원칙
____8.1.1 행동 유도성
____8.1.2 포카요케
____8.1.3 읽는 사람을 위한 코드 작성
____8.1.4 주석보다 중요한, 잘 지은 이름
____8.1.5 X로 이름 바꾸기
____8.1.6 명령과 쿼리의 분리
____8.1.7 정보 전달 단계
__8.2 API 설계 예제
____8.2.1 지배인
____8.2.2 캡슐화된 객체와의 상호작용
____8.2.3 구현의 자세한 부분
__8.3 결론

9장 팀워크
__9.1 깃
____9.1.1 커밋 메시지
____9.1.2 지속적 통합
____9.1.3 조금씩 커밋하기
__9.2 코드의 공동 소유
____9.2.1 짝 프로그래밍
____9.2.2 몹 프로그래밍
____9.2.3 코드 리뷰 대기 시간
____9.2.4 큰 변경 사항 거부하기
____9.2.5 코드 리뷰
____9.2.6 풀 리퀘스트
__9.3 결론

2부 지속가능성

10장 코드를 보강해봅시다
__10.1 기능 플래그
____10.1.1 캘린더 플래그
__10.2 스트랭글러 패턴
____10.2.1 메서드 수준의 스트랭글러
____10.2.2 클래스 수준의 스트랭글러
__10.3 버전 관리하기
____10.3.1 미리 경고하기
__10.4 결론

11장 유닛 테스트 편집하기
__11.1 유닛 테스트 리팩터링하기
____11.1.1 안전망 변경하기
____11.1.2 새로운 테스트 코드 추가하기
____11.1.3 테스트와 프로덕션 코드에 대한 리팩터링 분리하기
__11.2 테스트 실패 참조하기
__11.3 결론

12장 문제 해결하기
__12.1 이해하기
____12.1.1 과학적인 방법
____12.1.2 단순화
____12.1.3 고무 오리 디버깅
__12.2 결함
____12.2.1 결함을 테스트로 재현하기
____12.2.2 느린 테스트
____12.2.3 비결정적 결함
__12.3 이분법
____12.3.1 깃에서 이분법 방식 사용하기
__12.4 결론

13장 관심사의 분리
__13.1 조합
____13.1.1 중첩 조합
____13.1.2 순차적 조합
____13.1.3 참조 투명성
__13.2 횡단 관심사
____13.2.1 로그 남기기
____13.2.2 데코레이터
____13.2.3 무엇을 로그로 남길까?
__13.3 결론

14장 리듬
__14.1 개인적인 리듬
____14.1.1 타임 박싱
____14.1.2 휴식 취하기
____14.1.3 시간을 계획적으로 사용하기
____14.1.4 자판 외우기
__14.2 팀의 리듬
____14.2.1 주기적으로 의존성 갱신하기
____14.2.2 다른 작업 일정 잡기
____14.2.3 콘웨이의 법칙
__14.3 결론

15장 유력한 용의자
__15.1 성능
____15.1.1 과거의 유산
____15.1.2 명료성
__15.2 보안
____15.2.1 STRIDE 위협 모델
____15.2.2 스푸핑
____15.2.3 변조
____15.2.4 거부
____15.2.5 정보 노출
____15.2.6 서비스 거부
____15.2.7 권한 상승
__15.3 다른 기법들
____15.3.1 속성 기반 테스트
____15.3.2 행위 기반 코드 분석
__15.4 결론

16장 여행
__16.1 코드베이스 탐색하기
____16.1.1 큰 그림 보기
____16.1.2 파일 정리
____16.1.3 세부 사항 찾아보기
__16.2 아키텍처
____16.2.1 모놀리식
____16.2.2 순환 구조
__16.3 사용법
____16.3.1 테스트를 통해서 배우기
____16.3.2 테스트에 귀를 기울이자
__16.4 결론

부록 A 프랙티스 목록
__A.1 50/72 규칙
__A.2 80/24 규칙
__A.3 준비-행동-어설트
__A.4 이분법
__A.5 새로운 코드베이스를 위한 체크리스트
__A.6 명령과 쿼리의 분리
__A.7 변수 개수 세기
__A.8 순환 복잡도
__A.9 횡단 관심사에 대한 데코레이터
__A.10 악마의 변호인
__A.11 기능 플래그
__A.12 함수형 코어, 명령 셸
__A.13 정보 전달 단계
__A.14 예외 규정이 있을 때 이유 설명하기
__A.15 유효성 검사 말고 구문 분석 하기
__A.16 포스텔의 법칙
__A.17 빨강-초록-리팩터
__A.18 정기적인 의존성 업데이트
__A.19 결함을 테스트로 재현하기
__A.20 코드 리뷰
__A.21 유의적 버전 관리
__A.22 테스트와 프로덕션 코드에 대한 리팩터링 분리하기
__A.23 슬라이스
__A.24 스트랭글러
__A.25 위협 모델
__A.26 변환 우선순위 전제
__A.27 XX-주도 개발
__A.28 X로 이름 바꾸기

부록 B 참고 문헌

부록 C 예제 빌드해보기
__C.1 예제 파일 관련 정보
__C.2 윈도우 환경에서 빌드하는 방법
__C.3 리눅스/WLS 환경에서 컴파일하는 방법
__C.4 끝내면서

찾아보기

[옮긴이의 한마디]
어느 정도 이상의 규모를 가진 코드를 다루다 보면 나중에 항상 문제가 되는 부분이 있습니다. 작성된 코드는 점점 유지보수하기 어려워지고, 점점 낡은 코드가 되다가 어느 순간 그 누구도 건드리기 어려운, 엔지니어의 생명력을 길게 만들어주는 코드가 된다는 것이죠. 이건 코드가 사유화된다는 의미로도 볼 수 있을 것입니다. 공동 작업의 결과물이자 우리가 진행한 작업의 가장 최종적인 산출물이 말이죠.
처음 이 책에 대한 번역을 제안받았던 그때가 생각납니다. 회사를 옮긴 후 해석하기 어려운 레거시 코드와 씨름을 하고 있었고, 알 수 없는 판단들의 근거를 찾아내기 위해서 분투하고 있었습니다. 다행히 회사에는 클린 코드의 생각에 동조하는 동료가 많았고(물론 동의하지 않는 사람도 있었고), 어떻게 하면 조금 더 좋은 코드를 만들 수 있을지 고민하는 사람들이 있었습니다.
저는 이 책을 코드라는 산출물을 다뤄야 하는 많은 엔지니어와 매니저들에게 권하고 싶습니다. 코드라는 궁극적인 산출물을 어떻게 인식하고, 어떻게 관리해야 할 것인지, 그리고 코딩이라는 작업을 어떤 관점에서 바라봐야 할 것인지에 대해서 대한 이야기도 충분하게 하고 있다고 봅니다.