Download This PDF Book :Concurrency in Go: Tools and Techniques for Developers 1st Edition by Katherine Cox-Buday, for free.
Concurrency can be notoriously difficult to get right, but fortunately, the Go open source programming language makes working with concurrency tractable and even easy.
If you’re a developer familiar with Go, this practical book demonstrates best practices and patterns to help you incorporate concurrency into your systems.
Author Katherine Cox-Buday takes you step-by-step through the process. You’ll understand how Go chooses to model concurrency, what issues arise from this model, and how you can compose primitives within this model to solve problems.
Learn the skills and tooling you need to confidently write and implement concurrent systems of any size.
Understand how Go addresses fundamental problems that make concurrency difficult to do correctly
Learn the key differences between concurrency and parallelism
Dig into the syntax of Go’s memory synchronization primitives
Form patterns with these primitives to write maintainable concurrent code
Compose patterns into a series of practices that enable you to write large, distributed systems that scale
Learn the sophistication behind goroutines and how Go’s runtime stitches everything together
About the Author
Katherine is a computer scientist currently working at Simple. Her hobbies include software engineering, creative writing, Go (igo, baduk, weiquei), and music, all of which she pursues intermittently and with various levels of dedication.
CONTENTS:
Who Should Read This Book
This book is meant for developers who have some experience with Go; I make no attempt to explain the basic syntax of the language. Knowledge of how concurrency is presented in other languages is useful, but not necessary.
By the end of this book we will have discussed the entire stack of Go concurrency concerns: common concurrency pitfalls, motivation behind the design of Go’s concurrency, the basic syntax of Go’s concurrency primitives, common concurrency patterns, patterns of patterns, and various tooling that will help you along the way.
Because of the breadth of topics we’ll cover, this book will be useful to various cross-sections of people. The next section will help you navigate this book depending on what needs you have.
Navigating This Book
When I read technical books, I usually hop around to the areas that pique my interest. Or, if I’m trying to ramp up on a new technology for work, I frantically skim for the bits that are immediately relevant to my work. Whatever your use case is, here’s a roadmap for the book with the hopes that it help guide you to where you need to be!
Chapter 1, An Introduction to Concurrency.
This chapter will give you a broad historical perspective on why concurrency is an important concept, and also discuss some of the fundamental problems that make concurrency difficult to get correct. It also briefly touches on how Go helps ease some of this burden.
If you have a working knowledge of concurrency or just want to get to the technical aspects of how to use Go’s concurrency primitives, it’s safe to skip this chapter.
Chapter 2, Modeling Your Code: Communicating Sequential Processes.
This chapter deals with some of the motivational factors that contributed to Go’s design. This will help give you some context for conversations with others in the Go community and help to frame your understanding of why things work the way they do in the language.
Chapter 3, Go’s Concurrency Building Blocks.
Here we’ll start to dig into the syntax of Go’s concurrency primitives. We’ll also cover the sync package, which is responsible for handling Go’s memory access synchronization. If you haven’t used concurrency within Go before and are looking to hop right in, this is the place to start.
Interspersed with the basics of writing concurrent code in Go are comparisons of concepts to other languages and concurrency models. Strictly speaking, it’s not necessary to understand these things, but these concepts help you to achieve a complete understanding on concurrency in Go.
Chapter 4, Concurrency Patterns in Go.
In this chapter, we begin to look at how Go’s concurrency primitives are composed together to form useful patterns. These patterns will both help us solve problems and avoid issues that can come up when combining concurrency primitives.
If you’ve already been writing some concurrent code in Go, this chapter should still prove useful.
Chapter 5, Concurrency at Scale.
In this chapter, we take the patterns we have learned and compose these into larger patterns commonly employed in larger programs, services, and distributed systems.
Chapter 6, Goroutines and the Go Runtime.
This chapter describes how the Go runtime handles scheduling goroutines. This is for those of you who want to understand the internals of Go’s runtime.
Appendix.
The appendix simply enumerates various tools and commands that can help make writing and debugging concurrent programs easier.
About The Book:
Publisher : O'Reilly Media; 1st edition (July 19, 2017)
Language : English
Pages: 238
File : PDF,5 MB
Free Download the Book: Concurrency in Go: Tools and Techniques for Developers
PS: Share the link with your friends
If the Download link is not working, kindly drop a comment below, so we'll update the download link for you.
Happy downloading!
