cta quote button

Best Golang Books that You Should Have on Your Bookshelf

Read More

How Much Does It Cost to Hire Web Developers in Ukraine?

Our pricing is completely transparent: you pay your engineers’ salaries and a flat monthly fee for our services. No hidden charges.

Read More

1. The Go Programming Language (Addison-Wesley Professional Computing Series) (2015)

The Go Programming Language is the authoritative resource for any programmer who wants to learn Go. It shows how to write clear and idiomatic Go to solve real-world problems. The book does not assume prior knowledge of Go nor experience with any specific language, so you’ll find it accessible whether you’re most comfortable with JavaScript, Ruby, Python, Java, or C++.

  • The first chapter is a tutorial on the basic concepts of Go, introduced through programs for file I/O and text processing, simple graphics, and web clients and servers.
  • Early chapters cover the structural elements of Go programs: syntax, control flow, data types, and the organization of a program into packages, files, and functions. The examples illustrate many packages from the standard library and show how to create new ones of your own. Later chapters explain the package mechanism in more detail, and how to build, test, and maintain projects using the go tool.
  • The chapters on methods and interfaces introduce Go’s unconventional approach to object-oriented programming, in which methods can be declared on any type and interfaces are implicitly satisfied. They explain the key principles of encapsulation, composition, and substitutability using realistic examples.
  • Two chapters on concurrency present in-depth approaches to this increasingly important topic. The first, which covers the basic mechanisms of goroutines and channels, illustrates the style known as communicating sequential processes for which Go is renowned. The second covers more traditional aspects of concurrency with shared variables. These chapters provide a solid foundation for programmers encountering concurrency for the first time.
  • The final two chapters explore lower-level features of Go. One covers the art of metaprogramming using reflection. The other shows how to use the unsafe package to step outside the type system for special situations, and how to use the cgo tool to create Go bindings for C libraries.

The book features hundreds of interesting and practical examples of well-written Go code that cover the whole language, its most important packages, and a wide range of applications. Each chapter has exercises to test your understanding and explore extensions and alternatives. Source code is freely available for download from http://gopl.io/ and may be conveniently fetched, built, and installed using the go get command.

Author(s): Alan A. A. Donovan, Brian W. Kernighan

2. Go in Action (2015)

Summary

Go in Action introduces the Go language, guiding you from inquisitive developer to Go guru. The book begins by introducing the unique features and concepts of Go. Then, you’ll get hands-on experience writing real-world applications including websites and network servers, as well as techniques to manipulate and convert data at speeds that will make your friends jealous.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology

Application development can be tricky enough even when you aren’t dealing with complex systems programming problems like web-scale concurrency and real-time performance. While it’s possible to solve these common issues with additional tools and frameworks, Go handles them right out of the box, making for a more natural and productive coding experience. Developed at Google, Go powers nimble startups as well as big enterprises—companies that rely on high-performing services in their infrastructure.

About the Book

Go in Action is for any intermediate-level developer who has experience with other programming languages and wants a jump-start in learning Go or a more thorough understanding of the language and its internals. This book provides an intensive, comprehensive, and idiomatic view of Go. It focuses on the specification and implementation of the language, including topics like language syntax, Go’s type system, concurrency, channels, and testing.

What’s Inside

  • Language specification and implementation
  • Go’s type system
  • Internals of Go’s data structures
  • Testing and benchmarking

About the Reader

This book assumes you’re a working developer proficient with another language like Java, Ruby, Python, C#, or C++.

About the Authors

William Kennedy is a seasoned software developer and author of the blog GoingGo.Net. Brian Ketelsen and Erik St. Martin are the organizers of GopherCon and coauthors of the Go-based Skynet framework.

Table of Contents

  1. Introducing Go
  2. Go quick-start
  3. Packaging and tooling
  4. Arrays, slices, and maps
  5. Go’s type system
  6. Concurrency
  7. Concurrency patterns
  8. Standard library
  9. Testing and benchmarking

Author(s): William Kennedy, Brian Ketelsen

3. Go in Practice: Includes 70 Techniques (2016)

Summary

Go in Practice guides you through 70 real-world techniques in key areas like package management, microservice communication, and more. Following a cookbook-style Problem/Solution/Discussion format, this practical handbook builds on the foundational concepts of the Go language and introduces specific strategies you can use in your day-to-day applications.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology

Go may be the perfect systems language. Built with simplicity, concurrency, and modern applications in mind, Go provides the core tool set for rapidly building web, cloud, and systems applications. If you know a language like Java or C#, it’s easy to get started with Go; the trick is finding the practical dirt-under-the-fingernails techniques that you need to build production-ready code.

About the Book

Go in Practice guides you through dozens of real-world techniques in key areas. Following a cookbook-style Problem/Solution/Discussion format, this practical handbook builds on the foundational concepts of the Go language and introduces specific strategies you can use in your day-to-day applications. You’ll learn techniques for building web services, using Go in the cloud, testing and debugging, routing, network applications, and much more. After finishing this book, you will be ready to build sophisticated cloud-native Go applications.

What’s Inside

  • Dozens of specific, practical Golang techniques
  • Using Go for devops and cloudops
  • Writing RESTful web services and microservices
  • Practical web dev techniques

About the Reader

Written for experienced developers who have already started exploring Go and want to use it effectively in a production setting.

About the Authors

Matt Farina is a software architect at Deis. Matt Butcher is a Principal Engineer in the Advanced Technology Group at Hewlett Packard Enterprise. They are both authors, speakers, and regular open source contributors.

Table of Contents

    PART 1 – BACKGROUND AND FUNDAMENTALS

  1. Getting into Go
  2. A solid foundation
  3. Concurrency in Go
  4. PART 2 – WELL-ROUNDED APPLICATIONS

  5. Handling errors and panic
  6. Debugging and testing
  7. PART 3 – AN INTERFACE FOR YOUR APPLICATIONS

  8. HTML and email template patterns
  9. Serving and receiving assets and forms
  10. Working with web services
  11. PART 4 – TAKING YOUR APPLICATIONS TO THE CLOUD

  12. Using the cloud
  13. Communication between cloud services
  14. Reflection and code generation

Author(s): Matt Butcher, Matt Farina

4. Concurrency in Go: Tools and Techniques for Developers (2017)

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

Author(s): Katherine Cox-Buday

5. Introducing Go: Build Reliable, Scalable Programs (2016)

Perfect for beginners familiar with programming basics, this hands-on guide provides an easy introduction to Go, the general-purpose programming language from Google. Author Caleb Doxsey covers the language’s core features with step-by-step instructions and exercises in each chapter to help you practice what you learn.

Go is a general-purpose programming language with a clean syntax and advanced features, including concurrency. This book provides the one-on-one support you need to get started with the language, with short, easily digestible chapters that build on one another. By the time you finish this book, not only will you be able to write real Go programs, you’ll be ready to tackle advanced techniques.

  • Jump into Go basics, including data types, variables, and control structures
  • Learn complex types, such as slices, functions, structs, and interfaces
  • Explore Go’s core library and learn how to create your own package
  • Write tests for your code by using the language’s go test program
  • Learn how to run programs concurrently with goroutines and channels
  • Get suggestions to help you master the craft of programming

Author(s): Caleb Doxsey

6. Building Microservices: Designing Fine-Grained Systems (2015)

Distributed systems have become more fine-grained in the past 10 years, shifting from code-heavy monolithic applications to smaller, self-contained microservices. But developing these systems brings its own set of headaches. With lots of examples and practical advice, this book takes a holistic view of the topics that system architects and administrators must consider when building, managing, and evolving microservice architectures.

Microservice technologies are moving quickly. Author Sam Newman provides you with a firm grounding in the concepts while diving into current solutions for modeling, integrating, testing, deploying, and monitoring your own autonomous services. You’ll follow a fictional company throughout the book to learn how building a microservice architecture affects a single domain.

  • Discover how microservices allow you to align your system design with your organization’s goals
  • Learn options for integrating a service with the rest of your system
  • Take an incremental approach when splitting monolithic codebases
  • Deploy individual microservices through continuous integration
  • Examine the complexities of testing and monitoring distributed services
  • Manage security with user-to-service and service-to-service models
  • Understand the challenges of scaling microservice architectures

Author(s): Sam Newman

7. Go in 24 Hours, Sams Teach Yourself: Next Generation Systems Programming with Golang (2017)

In just 24 sessions of one hour or less, Sams Teach Yourself Go in 24 Hours will help new and experienced programmers build software that’s simpler, more reliable, and far more scalable. This book’s straightforward, step-by-step approach guides you from setting up your environment through testing and deploying powerful solutions. Using practical examples, expert Go developer George Ornbo walks you through Go’s fundamental constructs, demonstrates its breakthrough features for concurrent and network programming, and illuminates Go’s powerful new idioms. Every lesson builds on what you’ve already learned, giving you a rock-solid foundation for real-world success.

 

Step-by-step instructions carefully walk you through the most common Go programming tasks and techniques

Quizzes and exercises help you test your knowledge and stretch your skills

Practical, hands-on examples show you how to apply what you learn

Notes and Tips point out shortcuts, solutions, and problems to avoid

Two bonus chapters available online: Hour 25, “Creating a RESTful JSON API,” and Hour 26 “Creating a TCP Chat Server”

 

Learn how to…

·         Get productive quickly with Go development tools and web servers

·         Master core features, including strings, functions, structs, and methods

·         Work with types, variables, functions, and control structures

·         Make the most of Go’s arrays, slices, and maps

·         Write powerful concurrent software with Goroutines and channels

·         Handle program errors smoothly

·         Promote code reuse with packages

·         Master Go’s unique idioms for highly effective coding

·         Use regular expressions and time/date functions

·         Test and benchmark Go code

·         Write basic command-line programs, HTTP servers, and HTTP clients

·         Efficiently move Go code into production

·         Build basic TCP chat servers and JSON APIs

 

Register your book at informit.com/register for convenient access to the two bonus chapters online, downloads, updates, and/or corrections as they become available.

 

Author(s): George Ornbo

8. Cloud Native programming with Golang: Develop microservice-based high performance web apps for the cloud with Go (2017)

Discover practical techniques to build cloud-native apps that are scalable, reliable, and always available.

Key Features

  • Build well-designed and secure microservices. Enrich your microservices with continous integration and monitoring.
  • Containerize your application with Docker
  • Deploy your application to AWS. Learn how to utilize the powerful AWS services from within your application

Book Description

Cloud computing and microservices are two very important concepts in modern software architecture. They represent key skills that ambitious software engineers need to acquire in order to design and build software applications capable of performing and scaling. Go is a modern cross-platform programming language that is very powerful yet simple; it is an excellent choice for microservices and cloud applications. Go is gaining more and more popularity, and becoming a very attractive skill..

The book will take you on a journey into the world of microservices and cloud computing with the help of Go. It will start by covering the software architectural patterns of cloud applications, as well as practical concepts regarding how to scale, distribute, and deploy those applications. You will also learn how to build a JavaScript-based front-end for your application, using TypeScript and React.

From there, we dive into commercial cloud offerings by covering AWS. Finally, we conclude our book by providing some overviews of other concepts and technologies that the reader can explore to move from where the book leaves off.

What you will learn

  • Understand modern software applications architectures
  • Build secure microservices that can effectively communicate with other services
  • Get to know about event-driven architectures by diving into message queues such as Kafka, Rabbitmq, and AWS SQS.
  • Understand key modern database technologies such as MongoDB, and Amazon’s DynamoDB
  • Leverage the power of containers
  • Explore Amazon cloud services fundamentals
  • Know how to utilize the power of the Go language to access key services in the Amazon cloud such as S3, SQS, DynamoDB and more.
  • Build front-end applications using ReactJS with Go
  • Implement CD for modern applications

Who This Book Is For

This book is for developers who want to begin building secure, resilient, robust, and scalable Go applications that are cloud native. Some knowledge of the Go programming language should be sufficient.To build the front-end application, you will also need some knowledge of JavaScript programming.

Table of Contents

  1. Modern Microservice Architectures
  2. Building Microservices using Rest APIs
  3. Securing Microservices
  4. Asynchronous Microservice Architectures Using Message Queues
  5. Building a Frontend with React
  6. Deploying Your Application in Containers
  7. AWS
  8. AWS- II
  9. Continuous Delivery
  10. Monitoring
  11. Migration
  12. Where to go from here

Author(s): Mina Andrawos, Martin Helmich

9. The Go Bestiary: Bugs, gotchas and guidelines for go programmers (2017)

The Go Bestiary provides a quick guide to allow a programmer who has some experience in other languages get started quickly in Go, while being aware of the idioms to use and areas where there might be bugs lurking in their new Go code. The book presents a mix of advice for structuring your Go programs and descriptions of common mistakes to avoid, with liberal code examples, to help ease you into using the Go programming language effectively. If you’re familiar with Go but not an expert, hopefully there will also be a few interesting facts about the language you haven’t yet uncovered, and some potential bugs which you might not be aware of. You may want to skip the sections on setup and packages in this case, as they will cover familiar ground. If you’re new to Go, but experienced in other languages, you’ll find succinct descriptions of the most important differences in Go which usually trip up learners (for example declaring strings, strings vs runes, copying slices, using goroutines within a for loop), descriptions of bugs which beginners often fall prey to, and plenty of detail about unique aspects of the language like goroutines and slices. Typically Go programmers get up to speed quickly and feel productive within days or weeks, but it can be harder to assimilate the culture and be aware of the subtle problems that can occur, this book is here to help you get familiar with Go. The book covers the basics such as strings, structs, slices but also the more interesting corners of the language like implicit interfaces and channels, and contains advice as well as pointers on common problems.

Author(s): Kenneth Grant

10. Go Web Programming (2016)

Summary

Go Web Programming teaches you how to build scalable, high-performance web applications in Go using modern design principles.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

About the Technology

The Go language handles the demands of scalable, high-performance web applications by providing clean and fast compiled code, garbage collection, a simple concurrency model, and a fantastic standard library. It’s perfect for writing microservices or building scalable, maintainable systems.

About the Book

Go Web Programming teaches you how to build web applications in Go using modern design principles. You’ll learn how to implement the dependency injection design pattern for writing test doubles, use concurrency in web applications, and create and consume JSON and XML in web services. Along the way, you’ll discover how to minimize your dependence on external frameworks, and you’ll pick up valuable productivity techniques for testing and deploying your applications.

What’s Inside

  • Basics
  • Testing and benchmarking
  • Using concurrency
  • Deploying to standalone servers, PaaS, and Docker
  • Dozens of tips, tricks, and techniques

About the Reader

This book assumes you’re familiar with Go language basics and the general concepts of web development.

About the Author

Sau Sheong Chang is Managing Director of Digital Technology at Singapore Power and an active contributor to the Ruby and Go communities.

Table of Contents

    PART 1 GO AND WEB APPLICATIONS

  1. Go and web applications
  2. Go ChitChat
  3. PART 2 BASIC WEB APPLICATIONS

  4. Handling requests
  5. Processing requests
  6. Displaying content
  7. Storing data
  8. PART 3 BEING REAL

  9. Go web services
  10. Testing your application
  11. Leveraging Go concurrency
  12. Deploying Go

Author(s): Sau Sheong Chang

11. Data Structures & Algorithms In Go (2017)

“Problem Solving in Data Structures & Algorithms” is a series of books about the usage of Data Structures and Algorithms in computer programming. The book is easy to follow and is written for interview preparation point of view. In various books, the examples are solved in various languages like Go, C, C++, Java, C#, Python, VB, JavaScript and PHP.

GitHub Repositories
https://github.com/Hemant-Jain-Author

Book’s Composition
This book is designed for interviews so in Chapter 0, various preparation plans are proposed. Then in chapters 1, a brief introduction of the programming language and concept of recursion is explained. A number of problems based on recursion and array are explained.

Then in the coming chapter, we will be looking into complexity analysis. Then we will be looking into Sorting & Searching techniques.

Then will look into the various data structures and their algorithms. We will be looking into a Linked List, Stack, Queue, Trees, Heap, Hash Table and Graphs.

Then we will be looking into algorithm analysis, we will be looking into Brute Force algorithms, Greedy algorithms, Divide & Conquer algorithms, Dynamic Programming, and Backtracking.

In the end, we will be looking into System Design, which will give a systematic approach for solving the design problems in an Interview.

Table of Contents
Chapter 0: How to use this book.
Chapter 1: Introduction – Programming Overview
Chapter 2: Algorithms Analysis
Chapter 3: Approach to solve algorithm design problems
Chapter 4: Abstract Data Type
Chapter 5: Searching
Chapter 6: Sorting
Chapter 7: Linked List
Chapter 8: Stack
Chapter 9: Queue
Chapter 10: Tree
Chapter 11: Priority Queue
Chapter 12: Hash-Table
Chapter 13: Graphs
Chapter 14: String Algorithms
Chapter 15: Algorithm Design Techniques
Chapter 16: Brute Force Algorithm
Chapter 17: Greedy Algorithm
Chapter 18: Divide & Conquer
Chapter 19: Dynamic Programming
Chapter 20: Backtracking
Chapter 21: Complexity Theory
Chapter 22: Interview Strategy
Chapter 23: System Design

Author(s): Hemant Jain

12. Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems (2017)

Data is at the center of many challenges in system design today. Difficult issues need to be figured out, such as scalability, consistency, reliability, efficiency, and maintainability. In addition, we have an overwhelming variety of tools, including relational databases, NoSQL datastores, stream or batch processors, and message brokers. What are the right choices for your application? How do you make sense of all these buzzwords?

In this practical and comprehensive guide, author Martin Kleppmann helps you navigate this diverse landscape by examining the pros and cons of various technologies for processing and storing data. Software keeps changing, but the fundamental principles remain the same. With this book, software engineers and architects will learn how to apply those ideas in practice, and how to make full use of data in modern applications.

  • Peer under the hood of the systems you already use, and learn how to use and operate them more effectively
  • Make informed decisions by identifying the strengths and weaknesses of different tools
  • Navigate the trade-offs around consistency, scalability, fault tolerance, and complexity
  • Understand the distributed systems research upon which modern databases are built
  • Peek behind the scenes of major online services, and learn from their architectures

Author(s): Martin Kleppmann

Get a FREE Consultation

- Want to learn more about how we work?
- Not sure if we meet all your criteria?
- Too shy or busy to give a call?