This section briefly introduces the coverage of this book, the technical skills you'll need to get started, and the software requirements required to complete all of the included activities and exercises.
You already know you want to learn Go, and the smart way to learn anything is to learn by doing. The Go Workshop focuses on building up your practical skills so that you can develop high-performing concurrent applications, or even create Go scripts to automate repetitive daily tasks. You'll learn from real examples that lead to real results.
Throughout The Go Workshop, you'll take an engaging step-by-step approach to understand Go. You won't have to sit through any unnecessary theory. If you're short on time, you can jump into a single exercise each day, or you can spend an entire weekend learning how to test and secure your Go applications. It's your choice. Learning on your terms, you'll build up and reinforce key skills in a way that feels rewarding.
Every physical print copy of The Go Workshop unlocks access to the interactive edition. With videos detailing all exercises and activities, you'll always have a guided solution. You can also benchmark yourself against assessments, track your progress, and receive content updates. You'll even earn secure credentials that you can share and verify online upon completion. It's a premium learning experience that's included with your printed copy. To redeem it, follow the instructions located at the start of your Go book.
Fast-paced and direct, The Go Workshop is the ideal companion for Go beginners. You'll build and iterate on your code like a software developer, learning along the way. This process means that you'll find that your new skills stick, embedded as best practice. A solid foundation for the years ahead.
Chapter 1, Variables and Operators, explains how variables hold data for you temporarily. It also shows how you can use operators to make changes or make comparisons to that data.
Chapter 2, Logic and Loops, teaches you how to make your code dynamic and responsive by creating rules that must be followed based on data in variables. Loops let you repeat logic over and over again.
Chapter 3, Core Types, introduces you to the building blocks of data. You'll learn what a type is and how the core types are defined.
Chapter 4, Complex Types, explains that complex types build on core types to allow you to model real-world data using data grouping and by composing new types from the core types. You'll also look at overcoming Go's type system when needed.
Chapter 5, Functions, teaches you the basics of constructing a function. Then, we will dive into more advanced features of using functions, such as passing a function as an argument, returning a function, assigning a function to a variable, and many more interesting things you can do with functions.
Chapter 6, Errors, teaches you how to work with errors, covering topics such as declaring your own error and handling errors the Go way. You will learn what a panic is and how to recover from one.
Chapter 7, Interfaces, starts by teaching the mechanics of interfaces and then demonstrates that interfaces in Go offer polymorphism, duck typing, the ability to have empty interfaces, and the implicit implementation of an interface.
Chapter 8, Packages, demonstrates how the Go standard library organizes its code and how you can do the same for your code.
Chapter 9, Basic Debugging, teaches the fundamentals of finding bugs in our application. You will use various techniques of printing out markers in code, using values and types, and performing logging.
Chapter 10, About Time, gets you a head start in the concept of how Go manages time variables, and what features are provided for you to improve your applications, such as measuring execution time and navigating between time zones.
Chapter 11, Encoding and Decoding (JSON), teaches you the fundamentals of a JSON document, which is heavily used throughout various parts of software today, along with the great support that Go has for reading and creating JSON documents.
Chapter 12, Files and Systems, shows how Go has great support for working with files and the underlying OS. You will be working with the filesystem, learning how to create, read, and modify files on the OS. You will also see how Go can read a CSV file, a common file format used by administrators.
Chapter 13, SQL and Databases, covers the most important aspects of connecting to databases and manipulating tables, which are very common tasks nowadays, and you'll learn how to work efficiently with databases.
Chapter 14, Using the Go HTTP Client, instructs you how to use the Go standard packages to create an HTTP client and interact with REST APIs. You'll learn how to send GET requests to a server and process the response, as well as how to POST form data to a server and how to upload a file to a server.
Chapter 15, HTTP Servers, teaches you how to use the Go standard packages to create an HTTP server and build websites and REST APIs on top of it. You'll learn how to accept requests from a web form or from another program and respond in a human- or machine-readable format.
Chapter 16, Concurrent Work, demonstrates how to make use of Go's concurrency features to enable your software to perform several tasks at the same time, splitting the work across independent routines and reducing the processing time.
Chapter 17, Using Go Tools, familiarizes you with the tools that come with Go and explains how you can use them to improve your code. You'll learn how to automatically format your code with gofmt and goimports. You'll also learn how to do static analysis with go vet and how to detect race conditions using the Go race detector.
Chapter 18, Security, builds your understanding of how to identify and fix security attacks such as SQL injection and cross-site scripting. You'll learn how to use the Go standard package to implement symmetric and asymmetric encryption, and how to secure data at rest and data in transit using hashing libraries and the TLS package in Go.
Chapter 19, Special Features, lets you explore some hidden gems in Go that will make development easier. You will learn how to use build constraints to control application build behavior. You will also learn how to use the wildcard pattern with Go and how to use reflection in Go using the reflect package. This chapter will also build your understanding of how to access the runtime memory of your application using the unsafe package.
Code words in text, database table names, folder names, filenames, file extensions, path names, dummy URLs, user input, and Twitter handles are shown as follows:
"A panic() function accepts an empty interface."
Words that you see on the screen, for example, in menus or dialog boxes, also appear in the same format.
A block of code is set as follows:
type error interface {
Error()string
}
New terms and important words are shown like this: "These behaviors are collectively called method sets."
Long code snippets are truncated and the corresponding names of the code files on GitHub are placed at the top of the truncated code. The permalinks to the entire code are placed below the code snippet. It should look as follows:
main.go
6 func main() {
7 a()
8 fmt.Println("This line will now get printed from main() function")
9 }
10 func a() {
11 b("good-bye")
12 fmt.Println("Back in function a()")
13 }
The full code for this step is available at: https://packt.live/2E6j6ig
Each great journey begins with a humble step. Our upcoming adventure with Go programming is no exception. Before we can do awesome things using Go, we need to be prepared with a productive environment. In this small note, we shall see how to do that.
To be able to run all the recommended tools used in the course, it's recommended that you have:
If the system you are using is below the recommended requirements to use with Docker, you can still do the course. You have to complete an extra step to do so.
To be able to run all the tools (excluding Docker), you'll need:
Skip the steps, which explain how to install Docker. You'll need to install the MySQL server instead. You can download an installer from https://packt.live/2EQkiHe. The default options are safe to use if you are not sure which to pick. MySQL is free to install and use.
Once the course is complete, you can safely uninstall MySQL.
To be able to run all the recommended tools used in the course, it's recommended that you have:
Skip the steps, which explain how to install Docker. You'll need to install the MySQL server instead. You can download an installer from https://packt.live/2EQkiHe. The default options are safe to use if you are not sure which to pick. MySQL is free to install and use.
Once the course is complete, you can safely uninstall MySQL.
To be able to run all the recommended tools used in the course, it's recommended that you have:
To turn your Go source code into something you can run, you'll need the Go compiler. For Windows and macOS, we recommend using the installer. Alternatively, to get more control you can download precompiled binaries. You can find both at https://packt.live/2PRUGjp. The install instructions for both methods on Windows, macOS, and Linux are at https://packt.live/375DQDA. The Go compiler is free to download and use.
Go uses the version control tool Git to install extra tools and code. You can find the instructions for Windows, macOS, and Linux at https://packt.live/35ByRug. Git is free to install and use.
You need something to write your Go source code. This tool is called an editor or an Integrated Development Environment (IDE). If you already have an editor you like, you can use it with this course if you'd like to.
If you don't already have an editor, we recommend you use the free editor Visual Studio Code. You can download the installer from https://packt.live/35KD2Ek:
If you have Git installed, follow these steps:
Once done, select View from the top menu bar, then select Explorer.
You'll now need somewhere to put your Go projects. I recommend somewhere in your home directory. Avoid putting it in the Go path, which is the folder the Go compiler is installed in. If you are having problems with the modules later in the class, it may be due to this. Once you know where you want to store the projects, create a folder for them. It's essential that you can find your way back to this folder.
In Visual Studio Code, select the Open Folder button. From the dialog that opens, select the folder you just created.
package main
import (
"fmt"
)
func main() {
fmt.Println("This is a test")
}
If your computer can run it (see the Hardware and Software Requirements section), you should install Docker. Docker allows us to run things such as database servers without having to install them. Docker is free to install and use.
We only use Docker to run MySQL for the database part of the course. If you already have MySQL installed, then you can skip this part.
For macOS users, follow the instructions at https://packt.live/34VJLJD.
For Windows users, follow the instructions at https://packt.live/2EKGDG6.
Linux users, you should be able to use your built-in package manager to install Docker. Instructions for common distributions are at https://packt.live/2Mn8Cjc.
You are safe to uninstall Docker, if you wish, once the course is complete.
Download the code files from GitHub at and place them in a new folder called C:Code. Refer to these code files for the complete code bundle.https://packt.live/2ZmmZJL.
18.226.34.117