프로그래밍 언어 디자인에 관한 최고의 책! Dragon Book보다 재미있다!
OOP와 함수형 프로그래밍을 모두 지원하는, 현대 프로그래밍 언어의 실용적 구현!

매일 사용하고 있는 프로그래밍 언어가 어떻게 설계되고 구현되는지 알고 싶은가? 프로그래밍 언어가 어떻게 작동하고, 바이트 코드로 컴파일되고, 가상 머신에서 실행되는지에 관심이 있는가? 프로그래밍 언어가 어떻게 구축되었는지 더 깊이 이해해서 더 강력하고 유능한 소프트웨어 개발자가 되고 싶은가? 그렇다면 이 책은 당신을 위한 것이다. 이 책은 모든 기능을 갖춘 효율적인 스크립팅 언어를 구현하기 위해 알아야 할 모든 것을 담고 있다.
로버트 나이스트롬은 이 책에서 자신이 디자인한 작은 동적 언어인 Lox에 대해 두 가지 인터프리터를 구축한다. 첫 번째, 제이록스(jlox)는 Java 기반 인터프리터로 스캐닝, 재귀 하강을 사용한 표현식 구문 분석, 표현식, 제어 흐름, 함수 및 클로저, 클래스 및 상속을 평가한다. 아무것도 없는 밑바닥부터 시작하여 각 장의 주제를 구현해내는 모든 코드를 작성, 수정, 추가하며 설명한다.
두 번째, 씨록스(clox)는 C 기반으로 추상 구문 트리를 따라가는 느린 인터프리터 대신 스택 기반 가상 머신을 개발하며 관련 이론과 실제로 고려해야 할 사항을 다룬다. 위 두 가지를 구현하면서 비슷한 주제에 다르게 접근한다. 예를 들어 제이록스에서는 Java의 HashMap을 사용하여 식별자를 관리하고 Java의 가비지 수집에 의존했다면, 씨록스에서는 해시 테이블과 가비지 수집기를 직접 구현한다. 새로운 프로그래밍 언어를 구축하는 쉽지 않은 길을 위해, 책 전반에 걸쳐 복잡한 주제를 쉽게 이해할 수 있도록 세심하게 설명하고, 코드 역시 명확하고 따라하기 쉽게 넣고자 했다.

[목 차]

1부 | 환영한다!

1장 들어가기
__1.1 왜 이런 걸 배우는가?
____1.1.1 미니 언어는 곳곳에 있다
____1.1.2 언어는 훌륭한 연습이다
____1.1.3 한 가지 더
__1.2 이 책의 구성
____1.2.1 코드
____1.2.2 스니펫
____1.2.3 어사이드
____1.2.4 연습 문제
____1.2.5 디자인 노트
__1.3 첫 번째 인터프리터
__1.4 두 번째 인터프리터
연습 문제
디자인 노트 | 언어 이름 짓기

2장 인터프리터 원정대
__2.1 언어의 구성 요소
____2.1.1 스캐닝
____2.1.2 파싱
____2.1.3 정적 분석
____2.1.4 중간 표현
____2.1.5 최적화
____2.1.6 코드 생성
____2.1.7 가상 머신
____2.1.8 런타임
__2.2 지름길과 대체 경로
____2.2.1 싱글 패스 컴파일러
____2.2.2 트리 탐색 인터프리터
____2.2.3 트랜스파일러
____2.2.4 JIT 컴파일
__2.3 컴파일러와 인터프리터
__2.4 여행을 떠나자!
연습 문제

3장 록스 언어
__3.1 안녕, 록스
__3.2 하이레벨 언어
____3.2.1 동적 타이핑
____3.2.2 자동 메모리 관리
__3.3 데이터 타입
__3.4 표현식
____3.4.1 산술
____3.4.2 비교와 동등성
____3.4.3 논리 연산자
____3.4.4 우선순위와 그룹핑
__3.5 문장
__3.6 변수
__3.7 제어 흐름
__3.8 함수
____3.8.1 클로저
__3.9 클래스
____3.9.1 객체 지향 언어를 추구해야 할 이유가 있을까?
____3.9.2 록스는 왜 객체 지향 언어로 만들었나?
____3.9.3 클래스냐 프로토타입이냐
____3.9.4 록스의 클래스
____3.9.5 인스턴스화 및 초기화
____3.9.6 상속
__3.10 표준 라이브러리
연습 문제
디자인 노트 | 표현식과 문장

2부 | 트리 탐색 인터프리터

4장 스캐닝
__4.1 인터프리터 프레임워크
____4.1.1 에러 처리
__4.2 렉심과 토큰
____4.2.1 토큰 타입
____4.2.2 리터럴 값
____4.2.3 위치 정보
__4.3 정규 언어와 표현식
__4.4 스캐너 클래스
__4.5 렉심 식별하기
____4.5.1 렉시컬 에러 090
____4.5.2 연산자 091
__4.6 길이가 긴 렉심
____4.6.1 문자열 리터럴
____4.6.2 숫자 리터럴
__4.7 예약어와 식별자
연습 문제
디자인 노트 | 암묵적 세미콜론

5장 코드 표현
__5.1 컨텍스트 자유 문법
____5.1.1 문법 규칙
____5.1.2 표기법 개선
____5.1.3 록스 표현식 문법
__5.2 구문 트리 구현
____5.2.1 무지향성 객체
____5.2.2 트리 메타프로그래밍
__5.3 트리 다루기
____5.3.1 표현식 문제
____5.3.2 비지터 패턴
____5.3.3 표현식에 비지터를 적용
__5.4 (적당히) 예쁜 출력기
연습 문제

6장 표현식 파싱
__6.1 모호함과 파싱 게임
__6.2 재귀 하향 파싱
____6.2.1 파서 클래스
__6.3 구문 에러
____6.3.1 패닉 모드 에러 복구
____6.3.2 패닉 모드 진입
____6.3.3 재귀 하향 파서 동기화
__6.4 파서 연결
연습 문제
디자인 노트 | 로직 vs 역사

7장 표현식 평가
__7.1 값을 표현하기
__7.2 표현식 평가
____7.2.1 리터럴 평가
____7.2.2 괄호 평가
____7.2.3 단항식 평가
____7.2.4 참과 거짓
____7.2.5 이항 연산자 평가
__7.3 런타임 에러
____7.3.1 런타임 에러 감지
__7.4 인터프리터 연결
____7.4.1 런타임 에러 리포팅
____7.4.2 인터프리터 실행
연습 문제
디자인 노트 | 정적 타이핑과 동적 타이핑

8장 문장과 상태
__8.1 문장
____8.1.1 문장 구문 트리
____8.1.2 문장 파싱
____8.1.3 문장 실행
__8.2 글로벌 변수
____8.2.1 변수 구문
____8.2.2 변수 파싱
__8.3 환경
____8.3.1 글로벌 변수의 인터프리팅
__8.4 할당
____8.4.1 할당 구문
____8.4.2 할당 시맨틱
__8.5 스코프
____8.5.1 중첩과 섀도잉
____8.5.2 블록 구문과 시맨틱
연습 문제
디자인 노트 | 암묵적 변수 선언

9장 제어 흐름
__9.1 튜링 기계(개요)
__9.2 조건부 실행
__9.3 논리 연산자
__9.4 while 루프
__9.5 for 루프
____9.5.1 디슈가링
연습 문제
디자인 노트 | 구문 슈가 범벅

10장 함수
__10.1 함수 호출
____10.1.1 최대 인수 개수
____10.1.2 함수 호출 인터프리팅
____10.1.3 호출 타입 에러
____10.1.4 애리티 체크
__10.2 네이티브 함수
____10.2.1 시간 측정
__10.3 함수 선언
__10.4 함수 객체
____10.4.1 함수 선언 인터프리팅
__10.5 리턴문
____10.5.1 호출에서 리턴
__10.6 로컬 함수와 클로저
연습 문제

11장 리졸빙과 바인딩
__11.1 정적 스코프
____11.1.1 스코프와 가변 환경
____11.1.2 영속적 환경
__11.2 시맨틱 분석
____11.2.1 변수 레졸루션 패스
__11.3 리졸버 클래스
____11.3.1 블록 리졸빙
____11.3.2 변수 선언 리졸빙
____11.3.3 변수식 리졸빙
____11.3.4 할당식 리졸빙
____11.3.5 함수 선언 리졸빙
____11.3.6 기타 구문 트리 노드의 리졸빙
__11.4 리졸브된 변수의 인터프리팅
____11.4.1 리졸브된 변수 액세스
____11.4.2 리졸브된 변수 할당
____11.4.3 리졸버 실행
__11.5 레졸루션 에러
____11.5.1 잘못된 리턴 에러
연습 문제

12장 클래스
__12.1 OOP와 클래스
__12.2 클래스 선언
__12.3 인스턴스 생성
__12.4 인스턴스 프로퍼티
____12.4.1 겟 표현식
____12.4.2 셋 표현식
__12.5 클래스 메서드
__12.6 this
____12.6.1 잘못된 this 용례
__12.7 생성자와 초기자
____12.7.1 init() 직접 호출
____12.7.2 init()에서 리턴
연습 문제
디자인 노트 | 프로토타입과 파워

13장 상속
__13.1 수퍼클래스와 서브클래스
__13.2 메서드 상속
__13.3 수퍼클래스 메서드 호출
____13.3.1 구문
____13.3.2 시맨틱
____13.3.3 잘못된 super 용례
__13.4 마무리
연습 문제

3부 | 바이트코드 가상 머신

14장 바이트코드 청크
__14.1 바이트코드란?
____14.1.1 AST 탐색의 문제점은?
____14.1.2 그냥 네이티브 코드로 컴파일하면?
____14.1.3 바이트코드란?
__14.2 시작하기
__14.3 명령어 청크
____14.3.1 동적 명령어 배열
__14.4 청크 디셈블링
__14.5 상수
____14.5.1 값 표현
____14.5.2 값 배열
____14.5.3 상수 명령어
__14.6 줄 정보
____14.6.1 줄 정보 디셈블링
연습 문제
디자인 노트 | 개발 중인 언어를 테스트

15장 가상 머신
__15.1 명령어 실행 머신
____15.1.1 명령어 실행
____15.1.2 실행 추적
__15.2 값 스택 조작기
____15.2.1 VM의 스택
____15.2.2 스택 트레이스
__15.3 산술 계산기
____15.3.1 이항 연산자
연습 문제
디자인 노트 | 레지스터 기반의 바이트코드

16장 온 디맨드 스캐닝
__16.1 인터프리터 시동 걸기
____16.1.1 컴파일 파이프라인 열기
____16.1.2 스캐너의 스캐닝
__16.2 한 번에 토큰 하나씩
____16.2.1 토큰 스캐닝
__16.3 록스의 렉시컬 문법
____16.3.1 공백 문자
____16.3.2 주석
____16.3.3 리터럴 토큰
__16.4 식별자와 키워드
____16.4.1 트라이와 상태 기계
연습 문제

17장 표현식 컴파일
__17.1 싱글 패스 컴파일
__17.2 토큰 파싱
____17.2.1 구문 에러 처리
__17.3 바이트코드 내보내기
__17.4 전위식 파싱
____17.4.1 토큰 파서
____17.4.2 괄호로 그룹핑
____17.4.3 단항 음수화
__17.5 중위식 파싱
__17.6 프랫 파서
____17.6.1 우선순위에 따라 파싱
__17.7 청크 덤프
연습 문제
디자인 노트 | 파싱은 파싱일 뿐

18장 값 타입
__18.1 태그 있는 공용체
__18.2 록스의 값과 C의 값
__18.3 동적 타입 숫자
____18.3.1 단항 부정과 런타임 에러
____18.3.2 이항 산술 연산자
__18.4 두 가지 새로운 타입
____18.4.1 논리 not과 거짓
____18.4.2 동등/비교 연산자
연습 문제

19장 문자열
__19.1 값과 객체
__19.2 구조체 상속
__19.3 문자열
__19.4 문자열 연산
____19.4.1 문자열 연결
__19.5 객체 해제
연습 문제
디자인 노트 | 문자열 인코딩

20장 해시 테이블
__20.1 버킷 배열
____20.1.1 로드 팩터 및 래핑된 키
__20.2 충돌 해결
____20.2.1 개별 체이닝
____20.2.2 오픈 어드레싱
__20.3 해시 함수
__20.4 해시 테이블
____20.4.1 문자열 해싱
____20.4.2 엔트리 삽입
____20.4.3 할당 및 크기 조정
____20.4.4 값 조회
____20.4.5 엔트리 삭제
____20.4.6 툼스톤 개수 세기
__20.5 문자열 인터닝
연습 문제

21장 글로벌 변수
__21.1 문장
____21.1.1 print 문
____21.1.2 표현문
____21.1.3 에러 동기화
__21.2 변수 선언
__21.3 변수 읽기
__21.4 할당
연습 문제

22장 로컬 변수
__22.1 로컬 변수 표현
__22.2 블록문
__22.3 로컬 변수 선언
__22.4 로컬 변수 사용
____22.4.1 로컬 변수 해석
____22.4.2 다른 스코프 엣지 케이스
연습 문제

23장 진격과 후퇴
__23.1 if 문
____23.1.1 else 절
__23.2 논리 연산자
____23.2.1 논리 or 연산자
__23.3 while 문
__23.4 for 문
____23.4.1 초기자 절
____23.4.2 조건절
____23.4.3 증분절
연습 문제
디자인 노트 | goto가 그렇게 해로울까?

24장 호출과 함수
__24.1 함수 객체
__24.2 함수 객체로 컴파일
____24.2.1 컴파일 타임에 함수 생성
__24.3 호출 프레임
____24.3.1 로컬 변수 할당
____24.3.2 리턴 주소
____24.3.3 호출 스택
__24.4 함수 선언
____24.4.1 컴파일러 스택
____24.4.2 함수 매개변수
__24.5 함수 호출
____24.5.1 인수를 매개변수에 바인딩
____24.5.2 런타임 에러 체크
____24.5.3 스택 트레이스 출력
____24.5.4 함수에서 리턴
__24.6 리턴문
__24.7 네이티브 함수
연습 문제

25장 클로저
__25.1 클로저 객체
____25.1.1 클로저 객체로 컴파일
____25.1.2 함수 선언 해석
__25.2 업밸류
____25.2.1 업밸류 컴파일
____25.2.2 업밸류 플랫화
__25.3 업밸류 객체
____25.3.1 클로저에서의 업밸류
__25.4 클로즈드 업밸류
____25.4.1 값과 변수
____25.4.2 업밸류 클로징
____25.4.3 오픈 업밸류 추적
____25.4.4 런타임에 업밸류 클로징
연습 문제
디자인 노트 | 루프 변수 클로징

26장 가비지 수집
__26.1 도달성
__26.2 마크-스윕 가비지 수집
____26.2.1 가비지 수집
____26.2.2 디버그 로깅
__26.3 루트 마킹
____26.3.1 불분명한 루트
__26.4 객체 참조 추적
____26.4.1 색 추상화
____26.4.2 회색 객체 워크리스트
____26.4.3 회색 객체 처리
__26.5 미사용 객체 스위핑
____26.5.1 약한 참조와 문자열 풀
__26.6 수집은 언제 하나?
____26.6.1 레이턴시와 스루풋
____26.6.2 자동 조정 힙
__26.7 가비지 수집 버그
____26.7.1 상수 테이블에 추가
____26.7.2 문자열 인터닝
____26.7.3 문자열 연결
연습 문제
디자인 노트 | 세대별 수집기

27장 클래스와 인스턴스
__27.1 클래스 객체
__27.2 클래스 선언
__27.3 클래스 인스턴스
__27.4 겟/셋 표현식
____27.4.1 게터/세터 표현식 해석
연습 문제

28장 메서드와 초기자
__28.1 메서드 선언
____28.1.1 메서드 표현
____28.1.2 메서드 선언 컴파일
____28.1.3 메서드 선언 실행
__28.2 메서드 참조
____28.2.1 바운드 메서드
____28.2.2 메서드 액세스
____28.2.3 메서드 호출
__28.3 this
____28.3.1 this 오용 사례
__28.4 인스턴스 초기자
____28.4.1 초기자 호출
____28.4.2 초기자 리턴값
____28.4.3 잘못된 초기자 리턴
__28.5 호출 최적화
____28.5.1 필드 호출
연습 문제
디자인 노트 | 참신성 예산

29장 메서드와 초기자
__29.1 메서드 상속
____29.1.1 상속 실행
____29.1.2 이상한 수퍼클래스
__29.2 수퍼클래스 저장
____29.2.1 수퍼클래스의 로컬 변수
__29.3 수퍼 호출
____29.3.1 수퍼 액세스 실행
____29.3.2 수퍼 호출을 더 빠르게
__29.4 완전한 가상 머신
연습 문제

30장 최적화
__30.1 성능 측정
____30.1.1 벤치마크
____30.1.2 프로파일링
__30.2 해시 테이블 프로빙을 더 빠르게
____30.2.1 느린 키 래핑
__30.3 NaN 박싱
____30.3.1 숫자는 무엇이고, 숫자가 아닌 것은 무엇인가?
____30.3.2 조건부 지원
____30.3.3 숫자
____30.3.4 nil과 true/false
____30.3.5 객체
____30.3.6 Value 함수
____30.3.7 성능 평가
__30.4 다음 도착지는?
연습 문제

4부 | 부록

A1장 록스의 전체 문법
__A1.1 구문 문법
____A1.1.1 선언
____A1.1.2 문장
____A1.1.3 표현식
____A1.1.4 유틸리티 규칙
__A1.2 렉시컬 문법

A2장 제이록스의 AST 생성기로 만든 자바 클래스 목록
__A2.1 표현식
____A2.1.1 할당 표현식
____A2.1.2 이항 표현식
____A2.1.3 호출 표현식
____A2.1.4 겟 표현식
____A2.1.5 그룹핑 표현식
____A2.1.6 리터럴 표현식
____A2.1.7 논리 표현식
____A2.1.8 셋 표현식
____A2.1.9 super 표현식
____A2.1.10 this 표현식
____A2.1.11 단항 표현식
____A2.1.12 변수 표현식
__A2.2 문장
____A2.2.1 블록문
____A2.2.2 클래스 문장
____A2.2.3 표현문
____A2.2.4 함수 문장
____A2.2.5 If 문
____A2.2.6 print 문
____A2.2.7 return 문
____A2.2.8 변수 문장
____A2.2.9 while 문

B장 예제 코드 실습 안내 by 옮긴이
____B.1.1 시스템 요구 사항
____B.1.2 압축 파일 해제
____B.1.3 환경 변수(PATH)에 컴파일러 경로 추가
____B.1.4 개발 환경(Eclipse) 실행
____B.1.5 맺음말

찾아보기

온전한 인터프리터를 통째로 구현하라!
더 강력하고 유능한 프로그래머로 거듭날 것이다.

첫 번째 인터프리터: 제이록스
제이록스(jlox)는 자바로 개발한다. 프로그래밍 언어의 근본적인 개념과 작동 원리를 정확하게 이해하고 올바르게 구현하기 위해 가능한 한 가장 단순하고 깔끔한 언어 구현체를 작성한다. 처음에는 큰 그림을 그려보고 흥미진진한 주제를 하나씩 섭렵하면서 프로그래밍 언어가 내부적으로 어떻게 움직이는지 명확하게 이해할 수 있다.

두 번째 인터프리터: 씨록스
씨록스(clox)는 C 언어로, 자바가 공짜로 제공한 모든 것을 스스로 구현한다. 전체 표현식 타입별 우선 순위 테이블과 제어 흐름 문장을 준비하고 변수, 함수, 클로저, 클래스, 필드, 메서드, 상속까지 빠짐없이 구현한다. 동적 배열과 해시 테이블도 알아서 해결하고 객체를 어떻게 메모리에 나타낼지도 결정한다. 즉, 싱글 패스 바이트코드 컴파일러, 내부 명령어 집합을 처리하는 가상 머신 인터프리터, 컴팩트한 객체 표현, 힙 할당 없이 변수를 저장하는 스택, 정교한 가비지 수집기까지 완비한다. 자바 인터프리터(제이록스)가 정확성에 초점을 두었다면, C 인터프리터(씨록스)는 빠른 실행, 성능 최적화, 유용한 기능이 목표다.

누구나 프로그래밍 언어를 만들 수 있다. 내가 원하는 대로!
어떤 기분이냐 하면, 졸업할 때까지 똑같은 교복만 입다가 어느 날 원하는 옷을 입고 다닐 수 있는 학교에 진학한 기분이다. 블록에 꼭 {}를 써야 할 필요가 있나? 할당에 = 말고 다른 기호를 쓸 수 없을까? 클래스 없이 객체만 사용하면 안 될까? 다중 상속과 멀티메서드는? 정적 오버로드되는 동적인 언어는 어떨까? 프로그래밍 언어의 작동 원리를 진지하게 살펴보면서 프로그래밍 자체에 대한 이해도 한층 더 깊어진다. 마치 자동차를 운전만 하던 사람이 후드를 열고 엔진을 수리할 수 있게 되는 셈이다. 정말 재미난 경험이다! 그리고 실제로 유용하다!

작가 서문
여러분은 지금 멀고 험난한 대장정의 시작점에 있다. 이 책은 한장 한장 흥미진진한 언어의 세계로 안내할 것이다. 이 책에서는 프로그래밍 언어의 인터프리터를 직접 구현한다. 또 구현할 가치가 있는 언어를 디자인하는 방법을 차근차근 설명한다. 지금부터 완전한 기능을 갖춘 언어를 두 개의 완전한 인터프리터로 구현하는 과정을 하나씩 살펴보겠다. 여러분이 언어의 내면을 들여다보는 것은 처음이라 보고, 실행 가능하면서도 성능이 빠른, 완전한 언어 구현체를 만들기 위해 필요한 개념과 코드를 단계별로 설명할 것이다.
개인적으로 직접 실행해보면서 배우는 게 최고라고 생각한다. 추상적 개념으로 가득한 단락의 파도를 넘고 넘어 내 것으로 만들기는 어렵지만, 직접 코드를 짜서 실행하고 디버깅을 해보면 비로소 내 산 지식이 된다. 나는 여러분이 이 책을 다 읽고 나서 실제 언어가 어떻게 살아 숨 쉬는지 확실히 깨닫고, 나중에 다른 더 이론적인 책을 읽더라도 이 책에서 실습을 통해 이해한 기반을 바탕으로 개념을 마음 속에 단단히 새겼으면 좋겠다.
언어를 구현하는 일은 진정한 프로그래밍 스킬의 시험대다. 코드는 복잡하고 성능은 중요하다. 재귀, 동적 배열, 트리, 그래프, 해시 테이블의 달인이 되어야 한다. 늘 프로그래밍을 하면서 해시 테이블을 사용해왔어도 정말 해시 테이블을 완전하게 이해하고 있는 사람은 드물다. 장담컨대, 처음부터 해시 테이블을 만들어보면 확실하게 이해하게 될 것이다.

옮긴이 서문
이 책에 수록된 두 인터프리터의 소스 코드를 여러분의 PC에서 실습하는 방법을 몇 가지 안내한다.
- 방법 1. 지은이의 깃헙 리포지터리에서 직접 git clone하여 자신이 즐겨 쓰는 IDE에서 자신이 선호하는 빌드 방법으로 환경을 구성한다.
- 방법 2. 방법 1이 조금 어렵다면, 옮긴이가 미리 장별로 예제 코드를 추출하여 재작성한 깃헙 리포지터리를 git clone하기 바란다.
- 방법 3. 초심자거나 스스로 개발 환경을 구성하기 어려운 윈도우 PC 사용자라면 부록으로 설명한 내용을 참고하기 바란다.
실습 환경 구성에 어려움을 겪는 독자들을 위해 미리 셋업이 완료된 개발 환경을 제공하였으나, 이 책의 주제가 인터프리터를 직접 만들어보는 것인 만큼 단순히 예제 코드를 실습해보는 것에 만족하지 말고, 자신이 추구하는 방향과 가장 잘 맞는 개발 환경을 스스로 구축하기 바란다. 개발 환경을 구축하는 과정에서 뜻하지 않은 오류 등 많은 난관에 부딪힐 수도 있지만, 그런 것을 해결하는 과정 역시 학습의 일부라는 사실을 잊지 말고 혼자서 적극적으로 해결하는 연습을 권장한다.

베타테스터 실습 후기
평소에 접해보지 못한 조금 다른 관점의 책입니다. 예를 들어 언어의 종류는 많지만, 사칙연산은 모두 동일하게 처리합니다. 1+1=2도 차이가 없습니다. 일반적으로 아무렇지 않게 사용하던 사칙연산 + - * / 및 연산에 대한 우선순위, 함수를 호출해서 인자값을 받기 위한 function() 구성은 어떻게 처리되는지 등 그 안의 인터프리터를 너무 당연하게 사용하고 있다는 생각이 들었습니다. 이를 하나하나 구현해나가면서, 무의식 중에 사용하던 기능을 구현하는 과정을 경험하면서 프로그래밍을 평소와 다른 관점으로 바라보게 되는 느낌이 매우 새로웠습니다.
- 박찬웅 | 개발자

클래스나 클로저 같은 요즘 언어가 가지는 필수 기능들을 구현해보고, 생각해볼 만한 엣지 케이스와 문제들이 제공되어 고민하면서 언어를 만들어가는 과정을 경험할 수 있었습니다. 실습은 어려움 없이 진행할 수 있었고, 책의 실습을 따라 한 이후에도 다양한 언어로 포팅된 리포지터리를 따라 관심 있는 언어의 구현체를 살펴보고, 새롭게 구현해보면서 체화할 수 있다는 점도 좋았습니다.
- 최용욱 | 고려대학교 컴퓨터학과, 2년 차 DX 개발자

이미 출간된, 혹은 인터넷으로 공개된 많은 컴파일러 책 중에서 가장 실용적인 책입니다. 이 책에서 다루고 있는 컴파일러 내용, 다이어그램과 코드를 이용한 설명은 매우 훌륭합니다. 특히 후반부에 다루는 가비지 콜렉션에 대한 내용은 정말 인상적이었습니다. 실제 GC의 구동 방식과 실제 구현에 대한 설명은 GC의 동작 방식을 이해하는 데 매우 좋았습니다. 실제 코드를 작성할 때 메모리 사용 및 해제 전략을 수립하는 데 큰 도움이 될 것입니다. 재미 삼아 쉽게 읽을 수 있는 책은 아닙니다. 컴파일러에 대한 배경지식도 일부 필요하고요. 하지만 책을 다 읽고 나면, 내가 작성한 코드가 어떤 식으로 처리되고 수행되는지를 이해하는 데 있어서 큰 산을 하나 넘었다 생각할 수 있을 것 같습니다.
- 윤종민 | 라인플러스, 22년 차 개발자

처음에는 언어를 구현한다는 것이 어려울 거라고 생각했는데, 쉽고 재미있게 설명되어 있어서 좋았습니다. 책의 예제들과 설명이 매우 직관적이고 명료해서 이론적인 지식이 없어도 이해하기 쉬웠습니다. 실제로 언어를 만들어보면서 큰 성취감을 느낄 수 있었고, 실제로 동작하는 인터프리터와 컴파일러를 만드는 것이 컴퓨터 과학의 기본 원리를 더 깊이 이해하는 데 도움이 된다는 게 인상적이었습니다.
- 박광현 | (주)핀테크, 서버 개발자

제가 생각한 이 책의 장점은 이렇습니다. (1) 이야기를 풀어내듯 설명하여 부담 없이 읽을 수 있었습니다. (2) 핵심 부분에 집중할 수 있게 간결함을 추구합니다. 코드도 최대한 간결하게 갑니다. 핵심 부분에 주로 발생하는 엣지 케이스나 까다로운 문제 해결에 집중합니다. (3) 챕터별로 옮긴이가 준 예제 코드를 같이 띄워 놓고 보다 편하게 실습하며 책을 읽을 수 있었습니다. 최종 완성본이 아니라 챕터별로 컴파일 가능한 코드가 제공된다는 것이 큰 장점으로 느껴졌습니다. 내려받은 모든 파일이 잘 컴파일되어서 편하게 실습할 수 있었습니다. 간결하지만 복잡한 컴파일러 코드를 기반으로 여러 예시와 구현 의도를 설명하며 책이 진행되기 때문에 마치 지은이가 옆에서 설명하면서 같이 코딩하는 느낌이 들었습니다.
- 고주형 | 중앙대학교 소프트웨어학부, 백엔드 개발자 취업 준비 중

로버트 나이스트롬
20년 간 전문 프로그래머로 활동해왔으며, 그 중 절반 정도는 게임 분야에서 일했다. 일렉트로닉 아츠(Electronic Arts)에서 대작 '매든(Madden)'부터 '헨리 하츠워스(Henry Hatsworth)의 괴상한 모험' 같은 소규모 타이틀까지 다양한 게임을 개발했고, 이 시절 『게임 프로그래밍 패턴』(한빛미디어, 2016)을 집필했다. 개인 블로그를 방문하면 재치와 기지가 넘치는 흥미로운 그의 글을 접할 수 있다.

- 지은이 블로그: https://journal.stuffwithstuff.com
- 이 책의 블로그: https://craftinginterpreters.com

옮긴이 이일웅
자바 개발자, 소프트웨어 아키텍트로서 20년 가까이 대규모 엔터프라이즈 프로젝트에 참여해왔다. 처음에는 HTML, CGI, 자바스크립트 등 웹 기술에 푹 빠져 프로그래밍 세계에 발을 들여놓게 되었지만, 지금은 프로젝트 현장에서 백엔드 개발 프레임워크, 소프트웨어 아키텍처 설계, 그리고 개발자 기술 가이드 및 트러블슈팅 업무를 주로 수행한다. 『소프트웨어 아키텍처 101』(한빛미디어, 2021), 『마이크로서비스 패턴』(길벗, 2020), 『스프링 5 레시피』(한빛미디어, 2018) 등 20여 권의 도서를 번역하며 그간 현장에서 갈고 닦은 노하우와 지식을 동료, 선후배 기술자들과 공유하는 일에도 힘쓰고 있다.