Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll

Go Language Overview

Preview

Start a free Courses trial
to watch this video

Sign up for Treehouse

Overview

6:03 with Jay McGavren

Go is a systems programming language designed for speed and simplicity. You can compile a single Go program into executables that will run on Windows, MacOS, or Linux, without making any changes to your code. And your users won't have to install interpreters or virtual machines or anything. You just give them a single executable file, and they're ready to run your software.

Goals for Go:

  • Fast builds
  • Fast execution
  • Concurrency
  • Garbage collection

A team at Google found that a build of a Go program did 50 times fewer file includes than a comparable C++ program.

Hello, world

Let's try out your first Go program. We'll use a time-honored example and write a program that prints "Hello, world!". Launch the workspace attached to this video, and create a new source code file named "hello.go". Then type in the following code. Don't worry about memorizing everything we're doing right now; we'll be recapping all of this in upcoming videos.

package main

import "fmt"

func main() {
    fmt.Println("Hello, world!")
}

Now, go to the workspace console, and type go build hello.go. This will take your source code and compile it into an executable program. Now, if we run ls -l (that's "list files in long format") in the console, we'll see a new executable binary file named just hello without an extension. If we now type ./hello (which runs an executable file in the currect directory named hello, we'll see our message: "Hello, world!"

If you just want to try out some Go code without storing an executable binary file, there's a shortcut you can use. Just type the command go run hello.go. Your program will run immediately. This takes a moment, because Go still has to compile the code before running it, but it's convenient because you don't have to make a bunch of executable files before you're even sure if your program is working correctly. We'll be using the go run command for the rest of this course.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Sign up

    Related Discussions

    Have questions about this video? Start a discussion with the community and Treehouse staff.

    Sign up

    [MUSIC] 0:00
    Go is a systems programming language designed for speed and simplicity. 0:05
    You can compile a single Go program in the executables, that'll run on Windows, 0:09
    Mac OS or Linux without making any changes to your code. 0:14
    And your users won't have to install interpreters, or 0:17
    virtual machines or anything. 0:20
    You just give them a single executable file, and 0:22
    they are ready to run your software. 0:24
    This course assumes you already know at least one other programming language. 0:26
    That means we'll be able to dive right into the details of how Go works, 0:30
    the ways it's similar to other languages, and the ways it's different. 0:34
    Builds, for many programming languages are really inefficient. 0:37
    In C++, for example, 0:41
    some header files get loaded multiple times when building a large program. 0:42
    Even if there's a directive, they'll only process them once. 0:46
    It's also possible to compile a library and 0:49
    include it in your finished program, even if it's completely unnecessary. 0:51
    Google was suffering from these problems back in 2007. 0:55
    Their C++ codebase was huge, and the builds took over half an hour, 0:58
    after making even small changes to the code. 1:03
    So a team at Google wrote up a list of goals they'd like to see in a new 1:06
    programming language. 1:09
    They wanted it to compile fast, 1:10
    so they could quickly try out changes to their code. 1:12
    They wanted the resulting programs to execute fast. 1:14
    They wanted to make it easy to write programs that support concurrency, so 1:17
    that they could take full advantage of today's multi-core computer processors. 1:21
    And they wanted it to support garbage collection, that is, the automatic freeing 1:24
    of unused memory, so they didn't have to explicitly free memory in their code. 1:28
    The results of this wishlist is the Go programing language, and 1:33
    the language designers seem to have met their goals. 1:37
    A team at Google found that a build of a Go program did 50 times fewer file 1:39
    includes than a comparable C++ program, making compilation much faster. 1:44
    Go programs run fast, and it's really easy to perform operations concurrently. 1:49
    And you never have to worry about freeing memory, 1:54
    Go's garbage collector will handle that for you. 1:56
    Because of all this, Go is perfect for creating high-performance software that 1:59
    can handle a lot of operations at once, such as web services. 2:03
    The Docker and Kubernetes container systems were both built using Go, 2:07
    as was the backend for Treehouse Workspaces. 2:10
    Go syntax is most similar to the C language. 2:14
    The creators intentionally left out many features from other languages that 2:16
    are often associated with bugs, slower performance, or hard-to-read code. 2:20
    There's no function overloading, that is, 2:24
    no creating multiple versions of a function with different parameters. 2:26
    There's no exceptions, since they can make the flow of a program hard to follow. 2:30
    And there is no class inheritance, 2:33
    which often follows complex rules in other languages. 2:35
    When your Go Program is ready to deploy, you'll find it's easy to do. 2:39
    Executables are compiled native binaries, 2:43
    that means there's no need for users to download a separate runtime. 2:45
    Whether you're on Windows, Mac, or Linux, you can compile your code to binaries for 2:49
    any other platform. 2:53
    You can deploy your code to any host that allows binary executables, 2:55
    that includes most commercial web hosts. 2:58
    And Go programs are also supported by Google App Engine. 3:01
    That gives you an easy way to deploy and scale your web apps. 3:04
    Let's try out a simple Go program. 3:09
    We'll use a time-honored example, and write a program that prints, Hello, world. 3:11
    Lauch the workspace attached to this video, and 3:15
    create a new source code file named hello.go. 3:17
    Then type in the following code. 3:23
    I'll explain this as I go, but 3:25
    don't worry about memorizing everything we're doing right now. 3:27
    We'll be recapping all of this in upcoming videos. 3:29
    So every Go source code file is part of a package, so 3:33
    we're going to start this with a package declaration. 3:36
    We're gonna declare it to be part of the main package, 3:38
    since this is a program that's meant to be run from the command line. 3:41
    And then we need to import the format package, so 3:45
    that we can format some text and print it out to the console. 3:49
    So, I'm going to type the import command, and 3:52
    I'm going to import the format package, fmt. 3:56
    Then we're gonna create a function named main. 4:01
    Go programs, when they run from the command line, look for 4:03
    a function named main, that they'll run first. 4:08
    This is just an ordinary function, that just has a special name. 4:11
    We're going to include just a single line of code within this main function. 4:14
    We're going to call a function from the format package, so fmt dot, and 4:19
    we're going to call a function named println, P-R-I-N-T-L-N. 4:23
    And we're going to pass Println a single argument, the string, Hello, world. 4:28
    Again, don't worry about memorizing everything we did here, 4:37
    we'll recap all of this in future videos. 4:39
    Be sure to save that when you're done typing it. 4:42
    And then go to the Workspaces console, 4:44
    and type, go build hello,go. 4:49
    This will take your source code, and compile it into an executable program. 4:52
    Now if you run ls -l, that's list all files 4:57
    in long format, we see our hello.go source code file. 5:02
    And then alongside it, we see a new executable file named just hello. 5:07
    We can tell that it's executable, 5:11
    by looking at the permissions here on the left. 5:13
    The x markers mean that it's executable. 5:15
    If we now type ./hello, which just runs an executable 5:18
    file in the current directory named hello, we'll see our message, Hello World. 5:23
    If you just wanna try out some Go code, 5:29
    without storing an executable binary file, there's a shortcut you can use. 5:31
    Just type the command, go run hello.go. 5:35
    Your program will run immediately. 5:40
    This takes a moment, because Go still has to compile the code before running it. 5:42
    But it's convenient, because you don't have to make a bunch of executable files, 5:46
    before you're even sure if your program is working correctly. 5:49
    We'll be using the go run command for the rest of this course. 5:53
    Now you know why Go was created, and what its special features are. 5:56
    Next, it's time to dive into the particulars of writing Go programs. 5:59

    You need to sign up for Treehouse in order to download course files.

    Sign up

      You need to sign up for Treehouse in order to set up Workspace

      Sign up