The ecosystems of mainstream programming languages include various types of client mechanisms for interacting with common databases, including both SQL and NoSQL databases. The Go programming language is no exception. The Go ecosystem contains multiple libraries for building and using SQL and several drivers for connecting with and operating on different databases. In this course, explore how databases are accessed from Go programs. Work with databases by implementing a database driver for Go. Experiment by performing various operations and transactions on the database. Work with prepared statements. Finish up by practicing how to handle errors, null values, and unknown columns. Upon completion, you'll be able to perform several routine database operations from your Go program.

Adopting and employing best practices in software development not only mitigates virtually all levels of risk but also naturally results in high-quality, secure, and maintainable software. Consequently, professional software development organizations typically take care to observe best practices. Use this course to learn some of the most significant best practices when programming in Go. Study approaches to organizing Go code and documenting Go programs. Examine best practices related to error handling, data handling, concurrency, and testing. Then, finish off by implementing some of these best practices in a Go program. When you're done, you'll be able to leverage the benefits of a best practice approach when programming in Go.

Concurrency is a critical component of modern software, as it is capable of leveraging modern hardware advances. Concurrent applications can execute various parts of a program out of sequence while not affecting the final outcome of the program. This is often confused with parallelism, which involves running multiple programs simultaneously. In this course, you'll explore the concept of concurrency by first considering sequential programming. With that foundation, you'll dive into multi-threaded programming and learn about the differences between concurrency and parallelism. Next, you'll examine Go's concurrency model and the concurrency primitives used in Go to build concurrent applications. Finally, you'll learn about concurrency patterns used in Go programming and how performance can be improved with concurrency.

All Go programs are composed of one or more packages. Packages organize Go source code in a way that makes the code easily reusable and readable. Packages essentially allow you to take one or more source code files and compartmentalize them into a single unit. In this course, you'll explore what Go packages are and why they are used. You'll examine best practice for working with Go packages and learn about working with modules and packages. Next, you'll learn about package names and how to declare and import packages. Finally, you'll explore how to create and use custom packages and nested packages, as well as how to use the init() function in Go to initialize an application.

Go channels are constructs used by Goroutines to communicate with each other. Go channels, which can be buffered or unbuffered, are similar to pipes in that one Goroutine can send data from one side of the pipe to other Goroutines that receive the data on the other side. In this course, you'll explore how channels fit in Go's overall concurrency model. You'll learn how to implement non-blocking channel operations in Go programs and about the use of pipelines in Go. Next, you'll examine how to work with Goroutines, as well as buffered and unbuffered channels. You'll explore the range() and close() functions in the context of channels and learn how to combine channels and WaitGroups. Lastly, you'll learn how to implement a pipeline in a Go program.

Goroutines are foundational components of Go's concurrency model. Goroutines may be considered units of execution in a Go program. Goroutines are very lightweight with small stack sizes. Consequently, millions of Goroutines may be spawned at about the same time on modest hardware. In this course, you'll explore Goroutines and how they implement the packages sync and sync/atomic. You'll investigate race conditions in Goroutines and explore race conditions versus data races. Next, you'll create and work with WaitGroups, implement atomic operations and see how mutexes are used with Goroutines. Lastly, you'll create and explore how to detect and avoid race conditions in Goroutines.

Testing and debugging a program is fundamental to creating quality software. Likewise, deployment is an indispensable software development step, which must be navigated appropriately. The Go ecosystem includes several options and approaches for both testing/debugging and deploying Go programs. Use this course to learn the various testing and debugging approaches common to Go programs. Experiment by executing unit tests against Go software. Perform tests based on test coverage metrics. Learn common approaches for debugging Go programs. Lastly, examine tools and techniques for deploying Go applications both on-premises and to the Cloud and practice deploying a Go program to a cloud provider. Upon completion, you'll be able to use Go to test, debug, build, and deploy Go programs.