Go 언어의 기본 개념부터 동시성, 네트워크, 머신러닝, 고급 데이터 구조에 이르기까지 방대한 주제를 실습 예제와 함께 소개한다. 1판의 내용 중 도커와 쿠버네티스, 깃, 웹어셈블리, JSON, gRPC 등을 보강했으며, 머신러닝 관련 내용을 새롭게 추가했다. 이 책을 통해 Go 언어의 기초뿐만 아니라, 실전에서 활용할 수 있는 다양한 기술을 배울 수 있다. Go 언어를 제대로 배우고 싶다면 이 책은 전문가 수준에 이르기 위한 필독서다.
★ 이 책의 구성 ★

1장, 'Go와 OS'에서는 Go 언어의 역사와 장점부터 소개한다. 그런 다음 godoc 유틸리티를 설명하고, Go 프로그램을 컴파일하고 실행하는 방법을 소개한다. 이어서 화면에 출력하는 방법과 사용자로부터 입력받는 방법, 프로그램에서 커맨드라인 인수를 처리하는 방법, 로그 파일을 다루는 방법 등을 소개한다. 마지막으로 Go 언어에서 굉장히 중요한 역할을 하는 에러 처리 기법을 소개한다.
2장, 'Go 내부'에서는 Go 언어의 가비지 컬렉터의 개념과 작동 원리를 소개한다. 그런 다음 unsafe 패키지, Go 프로그램에서 C 코드를 호출하는 방법, C 프로그램에서 Go 코드를 호출하는 방법을 살펴본다. 이어서 defer 키워드를 사용하는 방법, strace(1)과 dtrace(1) 유틸리티 사용법을 소개한다. Go 환경의 정보를 조회하는 방법, Go 어셈블러를 사용하는 방법, Go에서 웹어셈블리를 생성하는 방법도 설명한다.
3장, '기본 타입'에서는 Go 언어에서 제공하는 다양한 데이터 타입을 소개한다. 이 과정에서 배열, 슬라이스, 맵뿐만 아니라 포인터, 상수, 루프, 날짜와 시간을 다루는 방법을 살펴본다.
4장, '합성 타입 사용'에서는 먼저 구조체의 개념과 struct 키워드를 소개한 후 튜플, 스트링, 룬, 바이트 슬라이스, 스트링 리터럴 등을 살펴본다. 나머지 부분은 정규 표현식과 패턴 매칭, switch문, strings 패키지, math/big 패키지, 키-값 스토어를 구현하는 방법, XML과 JSON 파일을 다루는 방법을 소개한다.
5장, '데이터 구조로 Go 코드 개선'에서는 Go 언어에서 제공하는 구조체만으로는 부족해서 데이터 구조를 직접 정의하는 방법을 소개한다. 이 과정에서 이진트리, 연결 리스트, 해시 테이블, 스택, 큐를 구현하는 방법과 각각의 장단점을 살펴본다. 또한 표준 Go 패키지인 container에서 제공하는 구조체의 사용법도 소개한다. 마지막으로 Go 언어에서 스도쿠 퍼즐을 검증하고 난수를 생성하는 방법도 알아본다.
6장, '패키지와 함수'에서는 패키지와 함수, init() 함수 사용법, 표준 Go 패키지인 syscall, text/template, html/template을 소개한다. 또한 go/scanner, go/parser, go/token과 같은 고급 패키지 사용법도 살펴본다.
7장, '리플렉션과 인터페이스'에서는 Go 언어의 고급 주제 세 가지인 리플렉션, 인터페이스, type 메서드를 소개한다. 그리고 Go에서 제공하는 객체지향 기능과 Delve를 이용해 Go 프로그램을 디버깅하는 방법도 소개한다.
8장, '유닉스 시스템에 작업 지시'에서는 Go 언어로 시스템 프로그래밍을 하는 방법을 소개한다. 이를 위해 flag 패키지로 커맨드라인 인수를 다루는 방법, 유닉스 시그널, 파일 입출력, bytes 패키지, io.Reader와 io.Writer 인터페이스를 다루는 방법, Viper와 Cobra Go 패키지를 사용하는 방법도 소개한다.
9장, 'Go 언어의 동시성: 고루틴, 채널, 파이프라인'에서는 Go 언어에서 동시성을 제공하기 위한 기능인 고루틴, 채널, 파이프라인을 소개한다. 또한 프로세스, 스레드, 고루틴의 차이점을 설명하고, sync 패키지 사용법과 Go 스케줄러 작동 방식도 소개한다.
10장, 'Go 언어의 동시성: 고급 주제'에서는 9장에 이어 고루틴과 채널을 사용하는 방법을 집중적으로 소개한다. Go 스케줄러도 깊이 있게 살펴보고 강력한 키워드인 select 사용법과 다양한 타입의 채널, 공유 메모리, 뮤텍스, sync.Mutex 타입, sync.RWMutex 타입 등도 소개한다. 10장의 마지막에서는 context 패키지, 워커 풀, 경쟁 조건 감지 방법 등도 다룬다.
11장, '코드 테스팅, 최적화, 프로파일링'에서는 코드 테스팅, 코드 최적화, 코드 프로파일링, 크로스컴파일, 문서화, 벤치마킹, 예제 함수 작성법, 도달하지 않는 코드를 찾는 방법 등을 소개한다.
12장, 'Go 언어를 이용한 네트워크 프로그래밍의 기초'에서는 net/http 패키지를 사용하는 방법과 Go 언어에서 웹 서버와 웹 클라이언트를 작성하는 방법을 소개한다. 또한 http.Response, http.Request, http.Transport 구조체와 http.NewServeMux 타입을 사용하는 방법도 살펴본다. 그리고 Go 언어로 웹 사이트를 만드는 방법도 소개한다. 또한 네트워크 인터페이스의 설정 사항을 읽고 DNS를 조회하는 방법도 소개하고, 마지막으로 gRPC를 다루는 방법도 알아본다.
13장, '네트워크 프로그래밍: 서버와 클라이언트 개발'에서는 Go 언어로 HTTPS 트래픽을 다루는 방법, UDP 및 TCP 클라이언트와 서버를 작성하는 방법, net 패키지에서 제공하는 기능을 활용하는 방법을 소개한다. 그리고 RPC 클라이언트와 서버 작성법, TCP 서버에서 동시성을 지원하도록 작성하는 방법, 원본 패킷을 읽는 방법도 소개한다.
14장, '머신러닝'에서는 분류, 클러스터링(군집화), 이상 감지, 아웃라이어, 신경망, 텐서플로와 같은 머신러닝 기법을 구현하는 방법을 소개하고, 아파치 카프카를 다루는 방법도 소개한다.

이 책은 크게 세 부분으로 나눌 수 있다. 첫 번째 부분은 Go 언어의 주요 개념을 깊이 있게 들여다본다. 이러한 개념으로는 사용자 입출력, Go 패키지 다운로드하기, Go 코드 컴파일하기, Go 코드에서 C 코드 호출하기, Go에서 웹어셈블리 생성하기, Go의 기본 타입과 합성 타입 등이 있다.
두 번째 부분은 5장, 6장, 7장으로 구성되며, 패키지와 모듈로 구성하는 방법, Go 프로젝트 설계를 비롯한 고급 기능을 다룬다.
세 번째 부분은 Go 언어에 대한 실용적인 주제를 다룬다. 8장부터 11장까지는 Go 언어를 이용한 시스템 프로그래밍, 동시성, 코드 테스팅, 최적화, 프로파일링을 다룬다. 마지막 세 장은 네트워크 프로그래밍과 머신러닝을 소개한다.
이 책은 웹어셈블리, 도커 다루기, Viper와 Cobra 패키지로 전문적인 커맨드라인 도구를 생성하는 방법, JSON과 YAML 파싱하기, 행렬 연산하기, 스도쿠 퍼즐 다루기, go/scanner와 go/token 패키지 사용법, git(1)과 깃허브 사용법, atomic 패키지, gRPC와 HTTPS를 다루는 방법 등도 소개한다.

* 이 책은 각 장에서 소개하는 개념을 담은, 작지만 완전한 형태의 예제 프로그램도 함께 제공한다. 이렇게 하면 크게 두 가지 장점이 있다. 하나는 한 가지 기법을 배우려고 복잡한 코드를 들여다볼 필요가 없다는 것이다. 다른 하나는 이 코드를 토대로 나만의 애플리케이션을 만들 수 있다는 것이다.

* 이 책에서는 컨테이너와 도커의 중요성을 반영해 도커 이미지에서 사용하는 Go 실행 파일 예제도 다양하게 제공한다. 도커 이미지는 서버 소프트웨어를 배포하는 데 뛰어난 수단을 제공하기 때문이다.

1장. Go와 OS

__Go 언어의 역사
__Go 현황
__Go 언어의 장점
____Go 언어는 완벽한가?
______전처리기란?
____godoc 유틸리티
__Go 코드 컴파일
__Go 코드 실행
__Go 언어의 두 가지 규칙
____사용할 패키지만 임포트
____중괄호 작성 방식
__Go 패키지 다운로드
__유닉스 stdin, stdout, stderr
__화면에 출력
__표준 출력 사용
__사용자 입력받기
____:\u003d와 \u003d
____표준 입력으로 읽기
____커맨드라인 인수 다루기
__에러 출력 방법
__로그 파일 작성
____로그 수준
____로그 종류
____로그 서버
____로그 파일로 정보를 보내는 Go 프로그램
____log.Fatal()
____log.Panic()
____커스텀 로그 파일 작성
____로그 항목에 줄번호 출력
__Go 언어에서 에러 처리
____error 데이터 타입
____에러 처리
__도커 사용
__참고 자료
__연습문제
__요약

2장. Go 내부

__Go 컴파일러
__가비지 컬렉션
____삼색 알고리즘
____Go 언어에서 가비지 컬렉터의 구체적인 작동 방식
____가비지 컬렉터에서 주의해야 할 맵과 슬라이스 연산
______슬라이스 사용
______맵에 포인터 사용
______맵에 포인터가 아닌 값 사용
______맵 나누기
______예제 성능 비교
____언세이프 코드
____unsafe 패키지
____unsafe 패키지에 대한 또 다른 예제
____Go에서 C 코드 호출
____같은 파일에 작성한 C 코드 호출
____다른 파일에 작성한 C 코드 호출
____C 코드
____Go 코드
____Go 코드와 C 코드 합치기
__C 코드에서 Go 함수 호출
____Go 패키지
____C 코드
__defer 키워드
____로깅에 defer 사용
__panic 함수와 recover 함수
____panic 함수만 사용
__두 가지 유용한 유닉스 유틸리티
____strace
____dtrace
__Go 환경 파악
__go env 명령
__Go 어셈블러
__노드 트리
__go build에 대해 좀 더 살펴보기
__웹어셈블리 코드 생성
____웹어셈블리의 간단한 소개
____웹어셈블리가 중요한 이유
____Go와 웹어셈블리
____웹어셈블리 생성 방법
____생성된 웹어셈블리 코드 사용
__Go 프로그래밍 관련 팁
__참고 자료
__연습문제
__요약

3장. 기본 타입

__숫자 타입
____정수
____부동소수점 수
____복소수
____Go 2의 숫자 리터럴
__Go 루프
____for 루프
____while 루프
____range 키워드
____Go의 다양한 루프문
__Go 배열
____다차원 배열
____Go 배열의 단점
__Go 슬라이스
____슬라이스에 대한 기본 연산
____슬라이스는 자동으로 확장된다
____바이트 슬라이스
____copy() 함수
____다차원 슬라이스
____다차원 슬라이스 예제
____sort.Slice()로 슬라이스 정렬
____슬라이스에 배열 추가
__맵
____nil 맵에 저장
____맵을 사용해야 할 때
__Go 상수
____상수 생성자 iota
__Go 포인터
____포인터를 사용하는 이유
__날짜와 시간
____시간 처리
____시간 파싱
____날짜 처리
____날짜 파싱
____날짜와 시간 포맷 변경
__실행 시간 측정
____Go 가비지 컬렉터 실행 시간 측정
__참고 자료
__연습문제
__요약

4장. 합성 타입 사용

__합성 타입
__구조체
____구조체에 대한 포인터
____new 키워드 사용
__튜플
__정규 표현식과 패턴 매칭
____정규 표현식에 관련된 몇 가지 이론
____간단한 예제
____좀 더 어려운 예제
____IPv4 주소 매칭
__스트링
____룬이란?
____unicode 패키지
____strings 패키지
__switch문
__파이 값 정확하게 계산
__Go 언어로 키-값 스토어 구현
__Go와 JSON
____JSON 데이터 읽기
____JSON 데이터 저장
____Marshal()과 Unmarshal()
____JSON 데이터 파싱
____Go와 XML
____XML 읽기
____XML 출력 커스터마이즈
__Go와 YAML 포맷
__참고 자료
__연습문제
__요약

5장. 데이터 구조로 Go 코드 개선

__그래프와 노드
__알고리즘 복잡도
__Go 언어에서의 이진트리
____Go 언어로 이진트리 구현
____이진트리의 장점
__해시 테이블
____Go 언어로 해시 테이블 구현
____검색 기능 구현
____해시 테이블의 장점
__연결 리스트
____연결 리스트 구현
____연결 리스트의 장점
__이중 연결 리스트
____이중 연결 리스트 구현
__이중 연결 리스트의 장점
____Go에서의 큐
__큐 구현
__Go에서의 스택
____스택 구현
__container 패키지
____container/heap 사용법
____container/list 사용법
____container/ring 사용법
__난수 생성
____무작위 스트링 생성
__보안에 안전한 유사 난수 생성
__행렬 계산
____행렬 덧셈과 뺄셈
____행렬 곱셈
____행렬 나눗셈
______배열의 크기를 알아내는 방법
__수도쿠 퍼즐 풀기
__참고 자료
__연습문제
__요약

6장. 패키지와 함수

__Go 패키지
__Go 언어의 함수
____익명 함수
____여러 값을 리턴하는 함수
____함수의 리턴 값에도 이름을 붙일 수 있다
____포인터를 매개변수로 받는 함수
____포인터를 리턴하는 함수
____함수를 리턴하는 함수
____함수를 매개변수로 받는 함수
____가변 인수 함수
__Go 패키지 직접 만들기
____Go 패키지 컴파일
____사설 변수와 함수
____init() 함수
__Go 모듈
____Go 모듈 생성과 사용
______버전 v1.0.0 생성
______버전 v1.0.0 사용
______v1.1.0 생성
______v1.1.0 버전 사용
______v2.0.0 버전 생성
______v2.0.0 버전 사용
______v2.1.0 생성
______v2.1.0 버전 사용
____Go 모듈을 두 가지 버전으로 사용
____Go 모듈이 저장되는 위치
____go mod vendor 명령
__Go 패키지를 잘 만드는 방법
__syscall 패키지
____fmt.Println()의 내부 실행 과정
__go/scanner, go/parser, go/token 패키지
____go/ast 패키지
____go/scanner 패키지
____go/parser 패키지
____현실적인 예제
____스트링 길이를 입력받아 변수 이름 검색
__텍스트와 HTML 템플릿
____텍스트 출력 생성
____HTML 출력
__기본적인 SQLite3 명령
__참고 자료
__연습문제
__요약

7장. 리플렉션과 인터페이스

__타입 메서드
__인터페이스
____타입 어써션
__인터페이스 직접 작성
____Go 인터페이스 사용
____인터페이스와 데이터 타입에 대한 switch문 작성법
__리플렉션
____리플렉션에 대한 간단한 예제
____리플렉션에 대한 좀 더 복잡한 예제
____리플렉션의 단점 세 가지
____reflectwalk 라이브러리
__Go에서의 객체지향 프로그래밍
__깃과 깃허브
____깃 사용법
______git status
______git pull
______git commit
______git push
______브랜치 작업
______파일 다루기
______.gitignore 파일
______git diff
______태그 다루기
______git cherry-pick
__Delve로 디버깅
____디버깅 예
__참고 자료
__연습문제
__요약

8장. 유닉스 시스템에 작업 지시

__유닉스 프로세스
__flag 패키지
__viper 패키지
____viper를 사용하는 간단한 예
____flag 사용 코드를 viper 사용 코드로 변경
____JSON 설정 파일 읽기
____YAML 설정 파일 읽기
__cobra 패키지
____간단한 cobra 예제
____명령 앨리어스 생성
__io.Reader와 io.Writer 인터페이스
____버퍼를 이용한 파일 입출력과 버퍼를 이용하지 않는 파일 입출력
__bufio 패키지
__텍스트 파일 읽기
____텍스트 파일을 한 줄씩 읽기
____텍스트 파일을 한 단어씩 읽기
____텍스트 파일을 한 문자씩 읽기
____/dev/random 읽기
__파일에서 원하는 만큼 읽기
__바이너리 포맷의 장점
__CSV 파일 읽기
__파일에 쓰기
__디스크에 데이터를 읽거나 쓰기
__strings 패키지 다시 보기
__bytes 패키지
__파일 접근 권한
__유닉스 시그널 처리
____두 가지 시그널 처리
____모든 종류의 시그널 처리
__Go에서의 유닉스 파이프
____Go 언어로 cat(1) 유틸리티 구현
__syscall.PtraceRegs
__시스템 콜 추적
__유저 ID와 그룹 ID
__도커 API와 Go
__참고 자료
__연습문제
__요약

9장. Go 언어의 동시성: 고루틴, 채널, 파이프라인

__프로세스, 스레드, 고루틴
____Go 스케줄러
____동시성과 병렬성
__고루틴
____고루틴 생성 방법
____고루틴 여러 개 생성
__고루틴을 마칠 때까지 기다리기
____Add()와 Done()의 호출 횟수가 일치하지 않은 경우
__채널
____채널에 데이터 쓰기
____채널에서 데이터 읽기
____닫힌 채널에서 받기
____함수 매개변수로 지정한 채널
__파이프라인
__경쟁 상태
__Go와 Rust의 동시성 모델 비교
__Go와 Erlang의 동시성 모델 비교
__참고 자료
__연습문제
__요약

10장. Go 언어의 동시성: 고급 주제

__Go 스케줄러 다시 보기
____GOMAXPROCS 환경 변수
__select 키워드
__고루틴 만료시키기
____고루틴을 만료시키기 위한 첫 번째 기법
____고루틴을 만료시키기 위한 두 번째 방법
__Go 채널 다시 보기
____시그널 채널
____버퍼 채널
____nil 채널
____채널에 대한 채널
____고루틴의 실행 순서 지정
____고루틴을 사용하면 안 되는 경우
__공유 메모리와 공유 변수
____sync.Mutex
______뮤텍스를 언락하는 것을 까먹은 경우
____sync.RWMutex
____atomic 패키지
____고루틴으로 메모리 공유
__go문 다시 보기
__경쟁 상태 발견
__context 패키지
____context 패키지를 이용한 좀 더 복잡한 예제
____context 패키지의 또 다른 예
____워커 풀
__참고 자료
__연습문제
__요약

11장. 코드 테스팅, 최적화, 프로파일링

__최적화
__Go 코드 최적화
__Go 코드 프로파일링
____표준 Go 패키지 net/http/pprof
____간단한 프로파일링 예제
____좀 더 편리한 외부 패키지로 프로파일링
____Go 프로파일러의 웹 인터페이스
______웹 인터페이스를 이용한 프로파일링 예제
______그래피즈 간략 소개
__go tool trace 유틸리티
__Go 코드 테스트
____기존 코드에 대한 테스트 코드 작성
____코드 커버리지 테스트
__데이터베이스 백엔드를 갖춘 HTTP 서버 테스트
____testing/quick 패키지
______테스트 실행이 너무 오래 걸리거나 끝나지 않는 경우
__Go 코드 벤치마킹
__간단한 벤치마킹 예제
____잘못 작성한 벤치마크 함수의 예
__쓰기 버퍼 벤치마킹
__실행되지 않는 코드 찾기
__크로스컴파일
__예제 함수 만들기
__Go 코드를 머신 코드로 변환
____Go에서 어셈블리 사용
__문서 생성
__도커 이미지 사용법
__참고 자료
__연습문제
__요약

12장. Go 언어를 이용한 네트워크 프로그래밍의 기초

__net/http, net, http.RoundTripper
____http.Response 타입
____http.Request 타입
____http.Transport 타입
__TCP/IP
__IPv4와 IPv6
__nc(1) 커맨드라인 유틸리티
__네트워크 인터페이스에서 설정 읽기
__DNS 룩업
____도메인의 NS 레코드 조회
____도메인에 대한 MX 레코드 조회
__Go 언어로 웹 서버 만들기
____atomic 패키지 사용
____HTTP 서버 프로파일링
____Go 언어로 웹 사이트 만들기
__HTTP 트레이싱
____HTTP 핸들러 테스트
__Go 언어로 웹 클라이언트 생성
____좀 더 기능이 풍부한 웹 클라이언트 만들기
__HTTP 연결 타임아웃 지정
____SetDeadline에 대한 상세한 사항
____타임아웃 주기를 서버 측에 설정
____또 다른 타임아웃 기법
__와이어샤크와 티샤크
__gRPC
____인터페이스 정의 파일 정의
____gRPC 클라이언트
____gRPC 서버
__참고 자료
__연습문제
__요약

13장. 네트워크 프로그래밍: 서버와 클라이언트 개발

__HTTPS 트래픽 다루기
____인증서 생성
____HTTPS 클라이언트
____간단한 HTTPS 서버
____TLS 서버와 클라이언트 개발
__표준 Go 패키지 net
__TCP 클라이언트
____TCP 클라이언트를 약간 변형한 버전
__TCP 서버
____TCP 서버를 약간 변형한 버전
__UDP 클라이언트
__UDP 서버 구현
__동시성을 지원하는 TCP 서버
____동시성을 지원하는 TCP 서버의 또 다른 버전
__TCP/IP 서버를 구동하는 도커 이미지 생성
__원격 프로시저 호출(RPC)
____RPC 클라이언트
____RPC 서버
__로우레벨 네트워크 프로그래밍
____원본 상태의 ICMP 패킷 수집
__참고 자료
__연습문제
__요약

14장. 머신러닝

__간단한 통계적 특성 계산
__회귀
____선형 회귀
____선형 회귀 구현
____선 그래프 그리기
__분류
__군집
__이상 감지
__신경망
__아웃라이어 분석
__텐서플로
__카프카
__참고 자료
__연습문제
__요약
__마무리하며

★ 지은이의 말 ★

지금 읽고 있는 책은 뛰어난 Go 언어 개발자가 되게 도와주기 위한 책이다.
2판에는 Go 언어로 머신러닝을 구현하는 방법과 Viper, Cobra Go 패키지, gRPC, 도커 이미지 다루기, YAML 파일 다루기, go/scanner와 go/token 패키지 사용법, 웹어셈블리 코드 생성하기를 비롯해서 1판에는 없던 내용이 새롭게 추가됐다.
Go 프로그래밍 언어는 미래의 고성능 시스템용 언어다. 흔히 고랭(Golang)이라고도 부르는데, 공식 명칭은 아니다. 이 책은 선풍적인 인기를 얻은 초판을 개선해서 생산성 높은 고급 Go 프로그래머로 성장하는 데 도움을 주고자 집필했다. 이 책에서는 Go 언어를 실전에서 활용하는 방법을 제시한다. Go 언어의 기초를 아는 독자라면 이 책의 예제 및 패턴과 명쾌한 설명으로 Go의 능력을 더욱 키우고 현업에 적용할 수 있을 것이다. Go 언어에서의 타입과 구조체, 패키지, 동시성, 네트워크 프로그래밍, 컴파일러 설계, 최적화를 비롯한 깊이 있는 주제를 다양하게 다룬다. 각 장마다 연습문제와 참고 자료를 제공해 새로 배운 내용을 확실히 다질 수 있다.

★ 옮긴이의 말 ★

초판 번역을 한 지 불과 2년이 안 된 지금, 급격히 성장한 Go 언어와 생태계가 놀랍습니다. C, C++, Java, Python을 비롯한 주요 언어의 각자 주력 분야를 제외한 나머지 영역을 Go가 하나둘씩 빼가는 느낌입니다. 그래서 이 책처럼 다양한 주제를 실습 예제 위주로 훑어보면 흥미를 유지하면서 꾸준히 Go 언어를 익히기에 좋은 것 같습니다.
이번 번역도 예전 책과 마찬가지로 빠른 이해와 의미 전달에 우선순위를 뒀습니다. 변화의 속도에 발맞추기가 중요한 만큼 빠른 이해를 위해 의도적으로 음차 표기를 선택한 용어도 많습니다. 그래서 독자 입장에서 아쉬운 부분은 얼마든지 나올 수 있다는 점에 대해 미리 양해를 구합니다.