Go (Golang)

 Go, the high-performance language from Google, is rapidly gaining traction in the machine learning world. Its speed, concurrency, and built-in features make it ideal for building efficient, scalable ML models. But where do you start?

 This book is written by a seasoned developer and machine learning expert, providing you with practical, hands-on guidance based on real-world experience. After reading this book, you'll be equipped with the knowledge and tools to create robust, performant models without sacrificing clarity or maintainability.

 What's Inside

• Hands-on projects covering various machine learning tasks, from regression and classification to image recognition and natural language processing.
• In-depth explanations of key concepts like linear algebra, tensor operations, and optimization algorithms, all tailored to the Go programming language.
• Practical tips and best practices for writing clean, efficient, and maintainable Go code for machine learning.
• Guidance on selecting the right libraries and tools for your specific needs.
• Real-world examples and case studies showcasing the power of Go in machine learning.

About the Reader

 This book is designed for programmers with some coding experience who are interested in applying Go to machine learning. Whether you're a data scientist, software engineer, or simply curious about Go's potential, this guide will empower you to create impactful ML models.

 Stop struggling with slow, complex ML frameworks. Start building efficient, scalable models with Go. Get your copy of GoLang for Machine Learning today and embark on your journey to smarter, faster AI!

 Orchestration systems like Kubernetes can seem like a black box: you deploy to the cloud and it magically handles everything you need. That might seem perfect—until something goes wrong and you don’t know how to find and fix your problems. Build an Orchestrator in Go (From Scratch) reveals the inner workings of orchestration frameworks by guiding you through creating your own.

 In Build an Orchestrator in Go (From Scratch) you will learn how to:

• Identify the components that make up any orchestration system
• Schedule containers on to worker nodes
• Start and stop containers using the Docker API
• Manage a cluster of worker nodes using a simple API
• Work with algorithms pioneered by Google’s Borg
• Demystify orchestration systems like Kubernetes and Nomad

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

 Build an Orchestrator in Go (From Scratch) explains each stage of creating an orchestrator with diagrams, step-by-step instructions, and detailed Go code samples. Don’t worry if you’re not a Go expert. The book’s code is optimized for simplicity and readability, and its key concepts are easy to implement in any language. You’ll learn the foundational principles of these frameworks, and even how to manage your orchestrator with a command line interface.

About the technology

 Orchestration frameworks like Kubernetes and Nomad radically simplify managing containerized applications. Building an orchestrator from the ground up gives you deep insight into deploying and scaling containers, clusters, pods, and other components of modern distributed systems. This book guides you step by step as you create your own orchestrator—from scratch.

About the book

 Build an Orchestrator in Go (From Scratch) gives you an inside-out perspective on orchestration frameworks and the low-level operation of distributed containerized applications. It takes you on a fascinating journey building a simple-but-useful orchestrator using the Docker API and Go SDK. As you go, you’ll get a guru-level understanding of Kubernetes, along with a pattern you can follow when you need to create your own custom orchestration solutions.

What's inside

• Schedule containers on worker nodes
• Start and stop containers using the Docker API
• Manage a cluster of worker nodes using a simple API
• Work with algorithms pioneered by Google’s Borg

About the reader

 For software engineers, operations professionals, and SREs. This book’s simple Go code is accessible to all programmers.

 Go beyond the basics of Go and build complete applications using open-source libraries or the Go programming language by Google. This book will take you deep into the memory lane of the Go language with crunchy details straight from outer space.

 The applications in this book include the framework for a 2D Go-based game, an image random generator Rest API, financial time series handling for trading, a Kubernetes operator, a Blockchain coding and more. You'll also get refreshers on Go constructs and useful code tricks to build performant projects, and develop an HTTP based cloud ready image generator.

 Each chapter will be organized in the following format: what the particular application looks like; requirements and user stories of our example program; an introduction to the Go libraries or frameworks used; and the actual implementation of the example program, including common pitfalls and their solutions.

 Go Crazy will open your eyes to a new world of practical applications for Go. After reading the book, you will be able to apply your Golang knowledge to build your own crazy projects. Free source code will be available on this book's Apress GitHub page.

What You'll Learn

• Compile and inline other programming languages, including GPU coding.
• Handle Kubernetes clusters via your own operator
• Write Go to code against Ethereum based block chains.
• Write intelligent bot code to get you rich and famous.

Who This Book Is For

Go programmers both experienced and novice.

 Shipping Go is a hands-on guide to shipping Go-based software. Author Joel Holmes shows you the easy way to set up development pipelines, fully illustrated with practical examples in the powerful Go language. You’ll put continuous delivery and continuous integration into action, and discover instantly useful guidance on automating your team’s build and reacting with agility to customer demands. Your new pipelines will ferry your projects through production and deployment, and also improve your testing, code quality, and production applications.

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

About the Technology

 An effective software delivery pipeline automates all stages, from initial design, through development, deployment, and ultimately the usage experience that feeds back into new features and releases. Go embraces the best practices of Continuous Delivery, and adds a few language-specific tools and twists of its own.

About the Book

 Shipping Go shows you how to build Go-specific software development pipelines. You’ll have a basic CI/CD process up and running by the time you finish Chapter 3, along with an iterative process for designing, releasing, and revising your applications. Then, you’ll systematically upgrade your pipeline to support containerization, integration testing, semantic versioning, and automated deployment. A set of handy appendices help you translate these valuable practices to Kotlin, Python, and JavaScript applications.

What’s Inside

• Create a development pipeline that turns feedback into features
• Automatically validate code before it is deployed
• Serverless, container-based, and server-based deployments
• Scale your deployment in a cost-effective way

About the Reader

 For Go developers.

 Golang holds significance because of its emphasis on simplicity, readability, impressive performance, and built-in support for concurrency. If you want to elevate your Golang programming skills and become a more proficient developer, then this book is for you.

 “Golang for Jobseekers” starts by providing a comprehensive introduction to Go, covering its syntax, fundamental concepts, and unique features that make it an efficient language for development. It delves deeply into data structures and algorithms, equipping you with techniques to optimize your code and solve complex problems with elegance and speed. Furthermore, the book explores the art of building robust RESTful API applications in Go. It teaches you industry best practices and architectural patterns for creating scalable, secure, and maintainable APIs. The book then takes you through a step-by-step journey from development to production, demonstrating how to deploy Go applications in different environments, ranging from virtual machines to containers on Kubernetes. Lastly, it helps you understand essential concepts like monitoring and logging, enabling you to ensure the performance and health of your applications in real-world scenarios.

 By the end of the book, you will be equipped to confidently showcase your expertise during interviews, giving you a competitive edge in the job market.

What you will learn

• Gain proficiency in data structures and algorithms using Golang.
• Learn how to develop a RESTful API application using Golang.
• Acquire the knowledge and skills required to deploy an application to a virtual machine.
• Explore the process of deploying an application in a containerized environment.
• Understand the essential concepts and practices for making applications "production ready”.

Who this book is for

 Ideal for newcomers to the industry, this book explores the entire journey of application development, from concept to production-ready deployment.

 Лучший способ улучшить код – понять и исправить ошибки, сделанные при его написании. В этой уникальной книге проанализированы 100 типичных ошибок и неэффективных приемов в Go-приложениях.

 Вы научитесь писать идиоматичный и выразительный код на Go, разберете десятки интересных примеров и сценариев и поймете, как обнаружить ошибки и потенциальные ошибки в своих приложениях. Чтобы вам было удобнее работать с книгой, автор разделил методы предотвращения ошибок на несколько категорий, начиная от типов данных и работы со строками и заканчивая конкурентным программированием и тестированием.

Для опытных Go-разработчиков, хорошо знакомых с синтаксисом языка.

 With technological advancements, fast markets, and higher complexity of systems, software engineers tend to skip the uncomfortable topic of software efficiency. However, tactical, observability-driven performance optimizations are vital for every product to save money and ensure business success.

 With this book, any engineer can learn how to approach software efficiency effectively, professionally, and without stress. Author Bartłomiej Płotka provides the tools and knowledge required to make your systems faster and less resource-hungry. Efficient Go guides you in achieving better day-to-day efficiency using Go. In addition, most content is language-agnostic, allowing you to bring small but effective habits to your programming or product management cycles.

This book shows you how to:

• Clarify and negotiate efficiency goals
• Optimize efficiency on various levels
• Use common resources like CPU and memory effectively
• Assess efficiency using observability signals like metrics, logging, tracing, and (continuous) profiling via open source projects like Prometheus, Jaeger, and Parca
• Apply tools like go test, pprof, benchstat, and k6 to create reliable micro and macro benchmarks
• Efficiently use Go and its features like slices, generics, goroutines, allocation semantics, garbage collection, and more!

 This book covers the key benefits and common issues of microservices, helping you understand the problems microservice architecture helps to solve, the issues it usually introduces, and the ways to tackle them. You’ll start by learning about the importance of using the right principles and standards in order to achieve the key benefits of microservice architecture. The following chapters will explain why the Go programming language is one of the most popular languages for microservice development and lay down the foundations for the next chapters of the book. You’ll explore the foundational aspects of Go microservice development including service scaffolding, service discovery, data serialization, synchronous and asynchronous communication, deployment, and testing. After covering the development aspects, you’ll progress to maintenance and reliability topics. The last part focuses on more advanced topics of Go microservice development including system reliability, observability, maintainability, and scalability. In this part, you’ll dive into the best practices and examples which illustrate how to apply the key ideas to existing applications, using the services scaffolded in the previous part as examples. By the end of this book, you’ll have gained hands-on experience with everything you need to develop scalable, reliable and performant microservices using Go.

 Go is the new systems programming language for Linux and Unix systems. It is also the language in which some of the most prominent cloud-level systems have been written, such as Docker. Where C programmers used to rule, Go programmers are in demand to write highly optimized systems programming code.

 Created by some of the original designers of C and Unix, Go expands the systems programmers toolkit and adds a mature, clear programming language. Traditional system applications become easier to write since pointers are not relevant and garbage collection has taken away the most problematic area for low-level systems code: memory management.

 This book opens up the world of high-performance Unix system applications to the beginning Go programmer. It does not get stuck on single systems or even system types, but tries to expand the original teachings from Unix system level programming to all types of servers, the cloud, and the web.

What you will learn

• Explore the Go language from the standpoint of a developer conversant with Unix, Linux, and so on
• Understand Goroutines, the lightweight threads used for systems and concurrent applications
• Learn how to translate Unix and Linux systems code in C to Golang code
• How to write fast and lightweight server code
• Dive into concurrency with Go
• Write low-level networking code

About the Author

 Mihalis Tsoukalos is a Unix administrator, programmer, DBA, and mathematician, who enjoys writing technical books and articles and learning new things. He has written more than 250 technical articles for many magazines including Sys Admin, MacTech, Linux User and Developer, USENIX ;login:, Linux Format, and Linux Journal. His research interests include databases, operating systems, Statistics, and machine learning.

 He is also the technical editor for MongoDB in Action, Second Edition, published by Manning.

 Вам уже знакомы основы языка Go? В таком случае эта книга для вас. Михалис Цукалос продемонстрирует возможности языка, даст понятные и простые объяснения, приведет примеры и предложит эффективные паттерны программирования.

 Изучая нюансы Go, вы освоите типы и структуры данных языка, а также работу с пакетами, конкурентность, сетевое программирование, устройство компиляторов, оптимизацию и многое другое. Закрепить новые знания помогут материалы и упражнения в конце каждой главы.

 Уникальным материалом станет глава о машинном обучении на языке Go, в которой вы пройдёте от основополагающих статистических приемов до регрессии и кластеризации. Вы изучите классификацию, нейронные сети и приёмы выявления аномалий. Из прикладных разделов вы узнаете: как использовать Go с Docker и Kubernetes, Git, WebAssembly, JSON и др.

 Go (or Golang) is a statically typed programming language developed at Google. Known for its vast standard library, it also provides features such as garbage collection, type safety, dynamic-typing capabilities, and additional built-in types. This book will serve as a reference while implementing Go features to build your own applications.

 This Go cookbook helps you put into practice the advanced concepts and libraries that Golang offers. The recipes in the book follow best practices such as documentation, testing, and vendoring with Go modules, as well as performing clean abstractions using interfaces. You'll learn how code works and the common pitfalls to watch out for. The book covers basic type and error handling, and then moves on to explore applications, such as websites, command-line tools, and filesystems, that interact with users. You'll even get to grips with parallelism, distributed systems, and performance tuning.

 By the end of the book, you'll be able to use open source code and concepts in Go programming to build enterprise-class applications without any hassle.

What you will learn

• Work with third-party Go projects and modify them for your use
• Write Go code using modern best practices
• Manage your dependencies with the new Go module system
• Solve common problems encountered when dealing with backend systems or DevOps
• Explore the Go standard library and its uses
• Test, profile, and fine-tune Go applications

Who this book is for

 If you're a web developer, programmer, or enterprise developer looking for quick solutions to common and not-so-common problems in Go programming, this book is for you. Basic knowledge of the Go language is assumed.

 This is the sequel to Writing An Interpreter In Go. We're picking up right where we left off and write a compiler and a virtual machine for Monkey.

 Runnable and tested code front and center, built from the ground up, step by step — just like before. But this time, we're going to define bytecode, compile Monkey and execute it in our very own virtual machine. It's the next step in Monkey's evolution. It's the sequel to … a programming language.

 Writing A Compiler In Go is the sequel to Writing An Interpreter In Go.

 It starts right where the first one stopped, with a fully-working, fully-tested Monkey interpreter in hand, connecting both books seamlessly, ready to build a compiler and a virtual machine for Monkey. In this book, we use the codebase (included in the book!) from the first part and extend it. We take the lexer, the parser, the AST, the REPL and the object system and use them to build a new, faster implementation of Monkey, right next to the tree-walking evaluator we built in the first book.

 The approach is unchanged, too. Working, tested code is the focus, we build everything from scratch, do baby steps, write tests firsts, use no 3rd-party-libraries and see and understand how all the pieces fit together.It's a continuation in prose and in code. Do you need to read the first part before this one? If you're okay with treating the code from the first book as black box, then no. But that's not what these books are about; they're about opening up black boxes, looking inside and shining a light. You'll have the best understanding of where we're going in this book, if you know where we started.

Learn how to write a compiler and a virtual machine

 Our main goal in in this book is to evolve Monkey. We change its architecture and turn it into a bytecode compiler and virtual machine.We'll take the lexer, the parser, the AST and the object system we wrote in the first book and use them to build our own Monkey compiler and virtual machine … from scratch! We'll build them side-by-side so that we'll always have a running system we can steadily evolve.What we end up with is not only much closer to the programming languages we use every day, giving us a better understanding of how they work, but also 3x faster. And that's without explicitly aiming for performance.

Here's what we'll do:

• We define our own bytecode instructions, specifying their operands and their encoding. Along the way, we also build a mini-disassembler for them.
• We write a compiler that takes in a Monkey AST and turns it into bytecode by emitting instructions
• At the same time we build a stack-based virtual machine that executes the bytecode in its main loop

 We'll learn a lot about computers, how they work, what machine code and opcodes are, what the stack is and how to work with stack pointers and frame pointers, what it means to define a calling convention, and much more.

We also

• build a symbol table and a constant pool
• do stack arithmetic
• generate jump instructions
• build frames into our VM to execute functions with local bindings and arguments!
• add built-in functions to the VM
• get real closures working in the virtual machine and learn why closure-compilation is so tricky

 In this book we will create a programming language together. We'll start with 0 lines of code and end up with a fully working interpreter for the Monkey programming language.

 Step by step. From tokens to output. All code shown and included. Fully tested.

Buy this book to learn:

• How to build an interpreter for a C-like programming language from scratch
• What a lexer, a parser and an Abstract Syntax Tree (AST) are and how to build your own
• What closures are and how and why they work
• What the Pratt parsing technique and a recursive descent parser is
• What others talk about when they talk about built-in data structures
• What REPL stands for and how to build one

Why this book?

 This is the book I wanted to have a year ago. This is the book I couldn't find. I wrote this book for you and me. So why should you buy it? What's different about it, compared to other interpreter or compiler literature?

• Working code is the focus. Code is not just found in the appendix. Code is the main focus of this book.
• It's small! It has around 200 pages of which a great deal are readable, syntax-highlighted, working code.
• The code presented in the book is easy to understand, easy to extend, easy to maintain.
• No 3rd party libraries! You're not left wondering: "But how does tool X do that?" We won't use a tool X. We only use the Go standard library and write everything ourselves.
• Tests! The interpreter we build in the book is fully tested! Sometimes in TDD style, sometimes with the tests written after. You can easily run the tests to experiment with the interpreter and make changes.

This book is for you if you...

• learn by building, love to look under the hood
• love programming and to program for the sake of learning and joy!
• are interested in how your favorite, interpreted programming language works
• never took a compiler course in college
• want to get started with interpreters or compilers…
• ... but don't want to work through a theory-heavy, 800 pages, 4 pounds compiler book as a beginner
• kept screaming "show me the code!" when reading about interpreters and compilers
• always wanted to say: "Holy shit, I built a programming language!"

 Gain insights into the different challenges that can be solved using Go, with a focus on containers, Linux, security, networking, user interfaces and other relevant cloud based topics. This book reviews the necessary tools to create container-based cloud solutions with Go, a programming language that was born out of the need to address scalable, high availability cloud computing architecture needs inside Google. 

 Go, also known as Golang, has been adopted across different industries and products with many popular Open Source projects that power cloud computing technologies such as Docker and Kubernetes being written with Go. As the complexity of cloud technology increases, so does the need for people to understand how things work under-the-hood and to fix them when they’re broken. 

What You Will Learn

• Understand how the various components of a container-based system works
• Tackle complex technical issues using Go
• Integrate tools that can be used as part of your daily operational needs
• Build system-based products

Who This Book Is For 

 Developers and Engineers familiar with Go who want to know how different parts of the system work and who want to write command line tools. It will also be beneficial to programmers who already have a system-level understanding and want to use Go to build tools for existing projects and applications.

 100 Go Mistakes and How to Avoid Them puts a spotlight on common errors in Go code you might not even know you’re making. You’ll explore key areas of the language such as concurrency, testing, data structures, and more—and learn how to avoid and fix mistakes in your own projects. As you go, you’ll navigate the tricky bits of handling JSON data and HTTP services, discover best practices for Go code organization, and learn how to use slices efficiently.

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

About the technology

 Understanding mistakes is the best way to improve the quality of your code. This unique book examines 100 bugs and inefficiencies common to Go applications, along with tips and techniques to avoid making them in your own projects.

About the book

 100 Go Mistakes and How to Avoid Them shows you how to replace common programming problems in Go with idiomatic, expressive code. In it, you’ll explore dozens of interesting examples and case studies as you learn to spot mistakes that might appear in your own applications. Expert author Teiva Harsanyi organizes the error avoidance techniques into convenient categories, ranging from types and strings to concurrency and testing.

What's inside

• Identify and squash code-level bugs
• Avoid problems with application structure and design
• Perfect your data and control structures
• Optimize your code by eliminating inefficiencies

About the reader

For developers proficient with Go programming and syntax.

 While Go is a multi-paradigm language that gives you the option to choose whichever paradigm works best for the particular problem you aim to solve, it supports features that enable you to apply functional principles in your code. In this book, you’ll learn about concepts central to the functional programming paradigm and how and when to apply functional programming techniques in Go. Starting with the basic concepts of functional programming, this Golang book will help you develop a deeper understanding of first-class functions. In the subsequent chapters, you’ll gain a more comprehensive view of the techniques and methods used in functional languages, such as function currying, partial application, and higher-order functions. You’ll then be able to apply functional design patterns for solving common programming challenges and explore how to apply concurrency mechanisms to functional programming. By the end of this book, you’ll be ready to improve your code bases by applying functional programming techniques in Go to write cleaner, safer, and bug-free code.

 "Mastering Go Network Automation" is a structured beginning for network administrators looking to improve network efficiency, scalability, and security. This book provides a one-stop solution for all of your network administration needs, with comprehensive coverage of automation, security, containerization, monitoring, and performance testing.

 Beginning with the fundamentals of creating a network automation lab with the EVE-NG network simulator and the Go programming language, readers will learn the step-by-step process of installing EVE-NG, followed by the importance of service mesh in automation and how it can simplify network operations.

 The book delves deeply into critical topics such as deploying ingress controllers and implementing service mesh with Linkerd. Readers will learn about container-native storage, container storage management with Docker, and automating SSL certificates, firewall configuration, and network policies.

 Monitoring and performance tuning are also covered in the book, including how to monitor container performance and automatically roll out updates.

 The book concludes with a discussion of performance testing strategies like load testing, stress testing, and scalability testing. It shows readers how to find performance bottlenecks and optimise their network with the help of tools like Vegeta and Apache JMeter through the use of real-world examples.

 In this book you will learn how to: Setting up an EVE-NG network simulator, VIM IDE, kubeadm, and a comprehensive network automation lab to improve network efficiency, scalability, and security. Configuring ports, hosts, and servers using Go scripting to streamline network automation. Writing, testing, and validating network automation scripts to ensure smooth and reliable network administration.

 Building Docker images, running containers, and managing container deployments for efficient containerization.

 Automating load balancing, firewall configuration, and Kubernetes network policies for seamless network management.

 Working with popular tools such as Puppet, Zookeeper, Traefik, Envoy, and various Go networking packages.

 Automating SSL setup, container storage, container performance monitoring, and rolling updates.

 Using powerful load testing tools like Vegeta and Apache JMeter for efficient load testing, stress testing, and scalability testing to identify and eliminate performance bottlenecks.

 Get an in-depth introduction to the Go programming language and its associated standard runtime libraries. This book is targeted towards programmers that already know the Java programming language and uses that Java knowledge to direct the learning of Go. You will get a deep understanding of the Go language and obtain a good introduction to the extensive Go standard libraries. 

 This book teaches Go through clear descriptions of Go features, contrasting them with similar Java features and via providing extensive code examples. After reading this book you will be knowledgeable enough about Go and its libraries to begin doing effective programming using the Go language.  

 Go for Java Programmers is structured more like a tutorial than a reference document. It covers key features of Go, but not every little detail as a reference might. Its goal is to get you competent enough in Go and its runtime that you can begin to effectively write Go programs.  

 What You Will Learn

• Examine the key Go Runtime libraries and how they compare to Java libraries
• See when it is appropriate to use the Go language instead of the Java language
• Read and understand programs written in Go
• Write many programs in Go
• Determine when Go is an appropriate language to develop applications in
• Discover how the Go and Java languages and development experience compare and contrast

Who This Book Is For

 Primarily existing professional Java programmers or students that already know something about Java. A basic understanding of Java is expected. Some basic programming experience with imperative languages is expected.

 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

You will start by learning what guarantees the language provides when executing parallel programs. Using numerous examples, you will see how to use this information to develop parallel algorithms that run without data races and complete successfully. You will also learn everything you need to know about several common concurrency patterns, such as worker pools, asynchronous pipelines, fan-in/fan-out, scheduling periodic or future tasks, error handling, and panics in gorutins.

 Now is the perfect time to learn the Go Programming Language. It’s one of the most in-demand languages among tech recruiters and developers love its simplicity and power. Go Programming Language For Dummies is an easy way to add this top job skill to your toolkit. Written for novice and experienced coders alike, this book traverses basic syntax, writing functions, organizing data, building packages, and interfacing with APIs. 

 Go—or GoLang, as it’s also known—has proven to be a strong choice for developers creating applications for the cloud-based world we live in. This book will put you on the path to using the language that’s created some of  today’s leading web applications, so you can steer your career where you want to Go! 

• Learn how Go works and start writing programs and modules 
• Install and implement the most powerful third-party Go packages 
• Use Go in conjunction with web services and MySQL databases 
• Keep your codebase organized and use Go to structure data 

 With this book, you can join the growing numbers of developers using Go to create 21st century solutions. Step inside to take start writing code that puts data in users’ hands. 

 Build systems with Go Everything a Gopher must know Juan M. Tirado

 Build systems with Go by Juan M. Tirado Copyright ©2021 Independently published Cover by Juan M.Tirado Gopher Gotham image by Egon Elbre (@egonelbre) All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage or retrieval system, without the prior written permission of the copyright owner. This book has been entirely written using LATEX. EPub 3.0 conversion was done using tex4ebook: https://github.com/michal-h21/tex4ebook

 Revision History: v0.1.0: 2021-03-29 First version

PREFACE

 Welcome and thank you for reading these lines. Since I started programming in Go, I have always enjoyed its extraordinary commitment to simplicity. It is difficult to find another language that can make complex things so easily. That is the beauty of this language. Years have passed by and Go is no longer the new kid on the block, it has already become a mature language surrounded by a rich ecosystem of libraries, projects, and tools. Talking about Go is no longer talking about that fancy language that makes your life easier. Go is the gravity centre of a continuously growing ecosystem of amazing solutions maintained by a devoted community of developers. Go was originally designed to simplify the building of complex systems. However, when a developer decides to learn Go most of the learning resources simply explain the language. This book goes one step further by exploring tools, libraries, and projects from the Go ecosystem you can use to build ready-for-production systems. Everything a gopher must know in a single book. I hope you find this book useful.

WHO SHOULD READ THIS BOOK?

 This book is oriented to new Go adopters and developers with programming experience in other languages. The first part of this book covers the Go language from its basics to more advanced concepts. The second part assumes these concepts to be known by the reader and explores how to use them with other tools to build systems. If you are new to Go you can start from the beginning. However, if you have some experience you can start with the second part and revisit any basic concept if needed. Or you can simply go and check the chapters at your convenience.

 This book is written as a follow up to Let’s Go, and we’ll leverage a lot of the information and code patterns from that book again here.

 If you’ve already read and enjoyed Let’s Go, then this book should be a good fit for you and the ideal next step in your learning. If you haven’t, then I highly recommend starting with Let’s Go first — especially if you’re a newcomer to Go.

 You can read this as a standalone book, but please be aware that it is somewhat advanced — it doesn’t explain the fundamentals in detail, and some topics (like testing) don’t feature at all because they were covered heavily in the previous book. But if you’re comfortable using Go and already have a decent amount of experience behind you, then this book may also be a good fit for you. Feel free to jump straight in.

 Advance your understanding of generic data structures and algorithms and their applications using Go and the effective use of concurrency. You are invited on a journey that aims to improve your programming and problem-solving skills. This book takes you to the next step by showing how to get your programs to work efficiently as well as correctly.

 As you explore many data structures and the algorithms and applications associated with them, you'll focus on the trade-offs between speed and storage and the benefits of deploying concurrency when appropriate. This book will demonstrate the huge increases in application performance that are possible. The presentation of classic data structures and techniques of algorithm design (greedy, divide and conquer, branch-and-bound to name a few) provides an essential foundation and toolkit for problem solving. But this book goes further by presenting heuristic algorithms and their implementations for solving computationally intractable combinatoric optimization problems such as the travelling salesperson problem. Simulated annealing and genetic algorithms are among the techniques used.

 The consistent style of coding used throughout this book exploits Go’s ability to implement abstract, generic and constrained generic data types without the use of classes.  Although some familiarity with Go is assumed, this book should advance your ability to use Go to tackle server-side applications, games, machine learning, information retrieval and other application domains where speed and storage efficiency is essential.

What You'll Learn

• Explore classical data structures and algorithms aimed at making your applications run faster or require less storage
• Use the new generic features of Go to build reusable data structures
• Utilize concurrency for maximizing application performance
• See the power of heuristic algorithms for computationally intractable problems
• Enhance and improve your Go programming skills

Who This Book Is For

 Practicing Go software developers and students who wish to advance their programming and problem-solving skills and experience the excitement and see the benefits of using generic data structures and algorithms that utilize concurrency whenever possible.