Go is a fully compiled language from Google. Designed from the ground up to be simple and powerful, many developers find it to be a joy to program in and are impressed by how easy it is to solve many difficult programming tasks. In this course, I will take you on a survey of the Go language itself. This isn’t a theory course though. I’m going to teach you by writing code. When I introduce a concept, we’ll see some small examples that show how it works. Then, at the end of a module, we’ll use what we learn to build out a real-world application.
Michael Van Sickle is an application architect in Akron, Ohio.
He is a mechanical engineer by training and a software engineer by choice.
He is passionate about learning new programming languages and user
Data Types and Operators Hi, my name is Michael Van Sickle. Welcome back to this course where we are investigating the Go language to help you know if it is a language that you'd like to add to your arsenal. In this module, we're going to begin to introduce the elements of the Go language, by talking about various Data Types including Primitives, Constants, and Collections. We'll then introduce Arithmetic Operators and play with them for a bit. Finally, we're gonna wrap up by introducing a real world scenario that will let us apply what we've learned through this module to an application that we'll keep coming back to and enhancing through the rest of this course.
Branching and Looping Hi, this is Michael Van Sickle for Pluralsight. Welcome back to Go: Getting Started; in the last module we started to get our hands dirty by exploring basic data types and arithmetic operators. Now it's time to add in some of the most critical structures in any programming language, branches and loops. While the basics of these structures in Go, are going to be pretty familiar, we're going to find that Go has some nice enhancements that allow these constructs to be more flexible and powerful.
Functions Hello, my name is Michael Van Sickle. Welcome back to this course where we are getting started with Go. In the last module, we finished an overview of the tools required in an application to manage the execution path through a function. Now it is time to learn how to work with functions themselves. We are gonna learn how to pass data into functions, how to get data back out of them, and take a brief stop to see how Go's treatment of functions as first class citizens allows us to create anonymous functions.
Object-oriented Programming Hello, welcome back to Go: Getting Started. In the last module, we talked about functions, and how they can improve the structure of our applications by separating the logic of the application into purpose-built functions. Now it's time to introduce how Go handles use cases in which functionality and data need to work together. While many modern languages use the concept of a class to do this, Go, unsurprisingly, solves this problem in its own way. We'll start our discussion by talking about structs, which are a kind of container for arbitrary types. We'll then move on to discuss several ways that a struct can be created, and when each should be used. After that we'll move on to how to bind functions to run in the context of a struct, in other words, how to create methods. Finally, we'll end the module with a review of to use object composition to simulate traditional inheritance, and discuss why this model was selected.
Asynchronous Programming Hello, my name is Michael Van Sickle. Welcome to the bonus round. In the first modules of this course, we learned about the key constructs that are involved in creating the code the resides within a function. We then moved on to learn how functions and objects can improve the structure of our applications. Armed with that knowledge, you are set to start creating world-class applications. However, there's one really cool part of the language that you'd still be missing: how to deal with concurrency. In today's world, applications often need a way to efficiently use hardware that exposes multiple CPUs to the application. Fortunately for us, Go has primitives built into the language that make addressing this challenge much easier to manage. In this module we're gonna touch on how to call functions asynchronously using two tools that Go offers us. Goroutines are the name given to Go's threadlike constructs. Whenever you need to launch a portion of code that runs concurrently, you're gonna turn to goroutines to do that. Channels are the other tool that you're probably going to need. While goroutines are by definition required for asynchronous programming, channels are designed to address one of the most difficult challenges of this type of program, sharing data between threads. They do that by including machinery that handles all of the synchronization of the sender and receiver threads for you. This allows you to write most of your application as if it were not running concurrently, and use channels to bridge the gaps between goroutines.