When it comes to systems and application programming, choosing a programming language from a wide range of modern languages and environments is often challenging. Effective compilation, efficient execution, and effortless programming are three criteria that are not readily available in most mainstream languages. For this reason, Go, an open-source programming language, is fast gaining popularity among programmers. Programmers embrace Go to combine the ease of programming provided by an interpreted, dynamically-typed language with the efficiency and safety of a statically-typed, compiled language. Programmers harness the potential of Go programming with its built-in concurrency model, robust standard library, and support for networked and multicore computing, making programming incredibly modern and unbelievably fast. In the Go Programming Essentials journey, you will first explore the core principles of Go programming in the first track. The second track of the journey transitions towards working with Go's advanced programming features. In the third and final track, you will learn how to create web applications and web services using Go standard libraries.
In this track of the Go Programming Essentials journey, the focus will be on the core principles of Go programming, such as basic programming, functions & object orientation, and error & file handling.
In this track of the Go Programming Essentials journey, the focus will be on Go’s advanced programming features, such as the libraries or packages supported by the language, data handling capabilities, efficient solutions for concurrency issues, and testing techniques.
Go is a language that attempts to combine the ease of programming of an interpreted, dynamically typed language with the efficiency, maintainability and safety of a statically typed, compiled language. In this course, you'll explore the history of Go, why it was developed and how it is used across specific domains in the real world. Next, you'll discover the differentiating features of Go, and how Go differs from other programming languages. You'll also explore the real world uses of Go, and the pros and cons. You'll then explore the Go Playground web service to vet, compile, link, and run programs inside a sandbox Finally, you'll learn to configure a Go development environment, installing a code editor and the Go tools on a local development machine.
Go leverages some of the best features from other languages focusing on a simple, concise program structure and syntax. Go's relatively short learning curve means developers can start developing right away. In this course, you'll explore Go program structure and syntax and the various data types supported by Go. Next, you'll examine various approaches utilized in Go for developing program logic. You'll learn how to declare and initialize variables and constants and explore the specific operators used with different data types. You'll move on to learn how to work with complex data types and how to write code to control the flow of programs by leveraging looping and branching. Lastly, you'll learn how to manipulate and manage strings with various string functions available in Go.
Go is a statically-typed, multi-paradigm programming language supporting functional and procedural programming, and while Go is not an object oriented programming language out of the box, it does provide types and methods that can conveniently be used to emulate object oriented programming. In this course, you'll explore how to define and write functions and you'll learn how functions can be declared with receivers to create methods in Go. You'll explore how pointers and pointer variables are used in Go and you'll learn how to experiment with structs as objects and interfaces that explicitly define the relationship between objects. You'll explore how data types in Go can have state and behavior associated with them, and lastly, you'll explore how a lightweight form of object orientation is achieved in Go.
Go has a unique approach to error handling, treating errors as values that can be passed around and manipulated just like any other values. The language also provides several packages and built-ins in the standard library for working with file systems and performing I/O operations. In this course, you'll explore how errors are handled in Go using error values. You'll learn how to handle errors by importing and using package errors and work with custom error types. You'll examine how to implement Go's defer statement along with the built-in panic and recover functions to handle and recover from real-time errors. Finally, you'll learn about file input and output and how to perform basic I/O operations on files and directories.
Final Exam: Go Foundation for Beginners will test your knowledge and application of the topics presented throughout the Go Foundation for Beginners track of the Skillsoft Aspire Go Programming Essentials Journey.
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.
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.
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.
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.
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.
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.
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.
Final Exam: Advanced Programming in Go will test your knowledge and application of the topics presented throughout the Advanced Programming in Go track of the Skillsoft Aspire Go Programming Essentials Journey.
The Go Programming Language, also known as Golang, offers a powerful development environment for building web applications. Statically typed and similar to C in its syntax, Go offers structural type, memory safety, and garbage collection, and has become a popular choice for web development. In this course, you'll learn the basics of web development with Go, including the way web applications work, how HTTP factors into web development, web architectures, and the structure of web applications. You'll explore web development with Go and how web applications work. Next, you'll learn about the role of HTTP in web development, including how to create HTTP requests and generate HTTP responses. Then, you'll examine web architectures and how web applications are structured, including the purpose of multiplexing and http.Handler wrappers. Finally, you'll learn about the Go template package and how to create a basic structured web application using Go.
In the Go programming language (also known as Golang), the net/http library is used for creating web servers that receive requests and send responses. In this course, you'll learn how to create a Go web server. First, you'll explore the Go net/http package and how to create a basic Go web server, including how to serve files using HTTP. You'll also examine how to work with Go handlers, including working with multiple handlers and chaining handlers. Finally, you'll learn about ServeMux and DefaultServeMux and how to implement routing using the httprouter library.
POST requests are typically served up as HTML forms. In the Go programming language, you can handle forms using a number of functions. In this course, you will learn how to work with HTML forms and how to use ResponseWriter. First, you'll explore the concept of HTML forms and how HTTP POST requests are handled. Then you'll examine the Go ResponseWriter package and how to work with it. Finally, you'll learn about response headers in Go and how to with JSON output.
In web application development, HTML is frequently combined with data from template engines using handlers. In the Go programming language, templates are utilized along with other actions and commands to display content. In this course, you'll learn about Go templates and functions and how to use them in the creation of web applications. First, you'll explore templates in Go and template engines, as well as how to parse and execute templates. Next, you'll examine actions in Go and how to implement them. You'll also learn about Go arguments, flags, variables, and pipelines. Finally, you'll learn about Go functions and how to use them.
In web application development, data storage is utilized in a number of ways, including in memory, in files, and in relational databases. In the Go Programming Language (also known as Golang), data storage can be used persistently to improve performance. In this course, you will learn about data storage in Go and how to utilize it in the creation of web applications. First, you will learn about data storage in Go and template engines, including the purpose of persistent storage and how implement in-memory storage using structs. Then you will learn about the concept of working with gobs and SQL and how to store and retrieve data from a SQL database. Finally, you will learn about SQL mappers and how to utilize them in Go.
In web application development, web services are used to provide functionality to applications. In the Go programming language, you can use existing web services or create your own. In this course, you'll learn about web services in Go and how to implement them. First, you'll explore web services, including SOAP and RESTful web services and how they compare to each other. Then you'll learn how to implement web services and how to work with XML and JSON files. Finally, you'll examine how to create a RESTful web service using Go.