Type Switch
Start course
2h 17m

If you're thinking about engineering the next big dotcom application then you should seriously consider using Go!! 

The Go Programming Language is without doubt one of the hottest languages to learn, particularly in this cloud native era. More and more companies are adopting Go to engineer highly performant, stable and maintainable applications. Popular projects such as Docker, Kubernetes, Terraform, Etcd, Istio, InfluxDB have all been built successfully using Go!! 

This introductory level training course is designed to bring you quickly up to speed with the many key features that the Go programming language provides. You'll also learn how to setup your own Go development environment - consisting of the Go toolchain, Visual Studio Code, and several related Go based extensions - all to ensure that you are able to be productive writing your own source code.

We’d love to get your feedback on this course, so please give it a rating when you’re finished. If you have any queries or suggestions, please contact us at

Learning Objectives

By completing this course, you will:

  • Learn about what makes Go a great language
  • Learn how to install the Go toolchain
  • Learn how to setup Visual Studio Code to edit and debug Go programs
  • Learn how to work with the Go Playground to test and run snippets of Go code
  • Learn and understand the basic Go language syntax and features
  • Learn how to use the Go tool chain commands to compile, test, and manage Go code
  • And finally, you’ll learn how to work with and manage Go modules for module dependency management

Intended Audience

This course is intended for:

  • Anyone interested in learning the Go Programming Language
  • Software Developers interested in using Go to compile and test Go based applications
  • DevOps practitioners looking to learn about Go to support Go based applications


To get the most from this course, you should have at least:

  • A basic understanding of software development and the software development life cycle

Source Code

All sample Go source code as used and demonstrated within this course can be found here:


[Jeremy Cook] - There might be times where you can't always anticipate at compile time, the type of a functions input parameter. Often, this is the case when you're building a function that needs to be highly flexible in terms of what inputs it can take. In this case, the functions input parameter can be typed with the empty interface type, which implies that the input parameter can be of any type. This approach, as we know, gives up the type safety checks that the compiler gives us at compile time. Even though we might use this approach to provide us with the extra flexibility it affords us, we can still test the type inside the function using what's referred to as type assertions. 

A type assertion provides access to an interface value's underlying concrete value. A type assertion is often used within the context of a type switch. Just like the normal switch statement that we have seen before, a type switch can be used to combine several type assertions together in a series, and evaluate to the first case with the correct matching type. The example provided here implements a type switch within the compute function, spanning lines 25 to 36. The cloud input parameter for this function is declared using the empty interface type, meaning at compile time, the compiler can't perform any type safety checks when this function is called elsewhere in the application. 

Regardless, we can still check the underlying type of the incoming interface and react accordingly. Line 26 sets up the type switch on the cloud input parameter. Lines 27 and 31 are the case statements for the two possible and known concrete types, in this case the AWS and azure structs. If either type matches, then a cast is done from the interface to its detected concrete type to demonstrate the concept of casting as seen on lines 28 and 32. Next, the launch method is called to highlight polymorphism. Launch simply returns a string indicating the cloud platform's compute service name and the thing that it is launching, which for AWS is an EC2 instance, and for Azure is a virtual machine. Running this example produces the following output. 

In summary, you have observed how to use a type switch to inspect an interface's underlying concrete type and react accordingly.

About the Author
Learning Paths

Jeremy is a Content Lead Architect and DevOps SME here at Cloud Academy where he specializes in developing DevOps technical training documentation.

He has a strong background in software engineering, and has been coding with various languages, frameworks, and systems for the past 25+ years. In recent times, Jeremy has been focused on DevOps, Cloud (AWS, Azure, GCP), Security, Kubernetes, and Machine Learning.

Jeremy holds professional certifications for AWS, Azure, GCP, Terraform, Kubernetes (CKA, CKAD, CKS).

Covered Topics