0/8 Objectives Completed (0%)

Introduction to Go and Basic Constructs

Origin, Context and Popularity of GO

Origin and Evolution of Go Reasons for Developing Go Characteristics of Go Test Yourself

Basic Constructs and Elementary Data Types

Filenames, Keywords and Identifiers

Import Functionality

Overview of Functions

Overview of Data Types

Scope of Variables

Elementary Types

Challenge: Temperature Conversion

Solution Review: Temperature Conversion

Strings and strconv Package

Times and Dates

Quiz: Deduce the Outputs

Control Structures

The if-else Construct Testing for Errors on Functions The switch-case Construct Challenge: Season of a Month Solution Review: Season of a Month The for Construct The for range Construct Break and Continue Use of Labels - goto Exercise: Deduce the Outputs

Deep Dive into Go Functions and Data Structures

Functions

Introduction to Functions Parameters and Return Values Challenge: Multiple Return Values Solution Review: Multiple Return Values Challenge: Variable Number of Arguments Solution Review: Variable Number of Arguments Defer and Tracing Built-in Functions Recursive Functions Challenge: Compute Factorial of a Number Solution Review: Compute Factorial of a Number Higher-Order Functions Challenge: Filter Even and Odd Numbers Solution Review: Filter Even and Odd Numbers Closures Functions as Return Variables Debugging with Closures Optimizing Programs Quiz: Deduce the Outputs

Arrays and Slices

Declaration and Initialization Array Literals and Parameters Challenge: Filling Array with Loop Counter Solution Review: Filling Array with Loop Counter Challenge: Finding Fibonacci Numbers with Array Solution Review: Finding Fibonacci Numbers with Array Slices Slices with Functions Challenge: Finding Fibonacci Numbers with Slices Solution Review: Finding Fibonacci Numbers with Slices Multidimensionality Bytes and Slices The for-range Construct Reslicing Copying and Appending Slices Challenge: Magnify a Slice Solution Review: Magnify a Slice Challenge: Inserting Slice in a Slice Solution Review: Inserting Slice in a Slice Challenge: Filtering with Higher-Order Functions Solution Review: Filtering with Higher-Order Functions Applying Strings, Arrays and Slices Challenge: Bubble Sort the Slice Solution Review: Bubble Sort the Slice Challenge: Reverse a String Solution Review: Reverse a String Quiz: Deduce the Outputs

Maps

Declaration and Initialization Existence of Key-Value Item The for range Construct Challenge: Map the Days Solution Review: Map the Days A Slice of Maps Sorting and Inverting a Map Quiz: Deduce the Outputs

Advanced Go Concepts: Packages, Structs, and Interfaces

Packages

Overview of the Standard Library Challenge: Construct a Double-Linked List Solution Review: Construct a Double-Linked List The regexp Package Locking and the sync Package Accurate Computations and the big Package Custom Packages and Visibility Documenting Your Packages Custom Packages: Folder Structure, go install and go test Using git for Distribution External Packages, Projects and Libraries Installing External Packages

Structs and Methods

Introduction to Struct Advanced Structs Concepts Factory Method Structs with Tags Anonymous Fields and Embedded Structs Challenge: Anonymous Struct Solution Review: Anonymous Struct Introduction to Methods Methods Versus Functions Challenge: Coordinates of a Point Solution Review: Coordinates of a Point Challenge: Make a Rectangle Solution Review: Make a Rectangle Challenge: Decide Employee Salary Solution Review: Decide Employee Salary Receivers and Methods as Pointers and Values Non-Exported Fields String() Method and Format Specifiers Methods on Embedded Types Multiple Inheritance Challenge: Implement Stack Data Structure Solution Review: Implement Stack Data Structure Garbage Collection and SetFinalizer Quiz: Deduce the Outputs

Interfaces and Reflection

What is an Interface?Challenge: Make a Simple Interface Solution Review: Make a Simple Interface Embedded Interface and Type Assertions The Type Switch Challenge: Advancing the Simple Interface Solution Review: Advancing the Simple Interface Implementation of Interfaces Sorting with the Sorter Interface Challenge: Advancing the Shapes Analysis Solution Review: Advancing the Shapes Analysis Challenge: Sort People with Sorter Interface Solution Review: Sort People with Sorter Interface Reading and Writing Empty Interface Challenge: Implement Miner Interface Solution Review: Implement Miner Interface The reflect Package Printf and Reflection Interfaces and Dynamic Typing Structs, Collections and Higher-Order Functions Challenge: Make a Stack with Variable Internal Types Solution Review: Make a Stack with Variable Internal Types The Object Orientation in Go Quiz: Deduce the Outputs

Practical Go: File Handling, Error Management, and Concurrency

Reading and Writing

Reading Input from the User Challenge: Analyzing Input from Keyboard Solution Review: Analyzing Input from Keyboard Reading from a File Writing to a File Challenge: Read CSV File Solution Review: Read CSV File Challenge: Writing to a WIKI Page Solution Review: Writing to a WIKI Page Copying Files Reading Arguments from the Command-Line Reading Files with a Buffer Reading and Writing Files with Slices Scanning Inputs A Practical Example of Interfaces The JSON Data Format Decoding with JSON The XML Data Format Data Transport through gob Challenge: Decode the Contents Solution Review: Decode the Contents Cryptography with Go Exercise: Deduce the Outputs

Error-Handling and Testing

Error-Handling Run-time Exceptions and Panic Recover Error-Handling and Panicking in a User-Defined Package Error-Handling Scheme with Closures Challenge: Generate Panic from Division by 0 Solution Review: Generate Panic from Division by 0 Starting an External Command or Program Testing and Benchmarking in Go Testing: A Concrete Example Using Table-Driven Tests Investigating Performance Exercise: Deduce the Outputs

Goroutines and Channels

Handling Concurrency and Parallelism with Go Implementing Goroutines Introduction to Channels Synchronous and Asynchronous Communication Challenge: Demonstrate the Blocking Nature Solution Review: Demonstrate the Blocking Nature Semaphore Pattern Channel Factory and Producer-Consumer Pattern Challenge: Summing the Integers Solution Review: Summing the Integers Channel Directionality Synchronization of goroutines Switching between goroutines Challenge: Devise Random Bit Generator Solution Review: Devise Random Bit Generator Challenge: Map Polar Points to Cartesian Points Solution Review: Map Polar Points to Cartesian Points Channels, Timeouts, and Tickers Using recover with goroutines Tasks and Worker Processes Implementing a Lazy Generator Anonymous Closure Implementing Futures Multiplexing Limiting the Number of Requests Chaining and Parallelizing Computation The Leaky Bucket Algorithm Benchmarking, Accessing and Listening Exercise: Deduce the Outputs

Building Web Applications and Networking in Go

Networking, Templating and Web-Applications

A TCP Server A Simple Web Server Polling Websites and Reading Web Page Writing a Simple Web Application Challenge: Web Application for Statistics Solution Review: Web Application for Statistics Making a Web Application Robust Writing Web Application with Templates Exploring the template Package Challenge: Web Application for Serving Guests Solution Review: Web Application for Serving Guests An Elaborate Web Server Remote Procedure Calls with RPC Sending Mails with SMTP Go in the Cloud

Optimizing Go Code: Best Practices and Performance

Common Go Pitfalls and Patterns

Regular Mistakes and Suggestions Highlights from the Previous Chapters The comma, ok Pattern The defer Pattern Visibility and Operator Patterns

Performance Advices

Strings, Arrays and Slices Structs, Interfaces and Maps Functions and Files Goroutines and Networking Suggestions and Considerations

Capstone Project: Building a Complete Application

Building a Complete Application

Introduction Setting up the Structure of Application Our User Interface Persistent Storage with gob Using goroutines for Performance Persistent Storage with JSON Enhancements

Supplementary Go Resources and Environment Setup

Appendix

Platforms and Architectures Installing Go and the Go Tools-Chain in Binary Format Installing Go from Source Go Work Environment Basic Requirements for a Go Environment Editors and Integrated Development Environments Debugging Formatting the Code Building and Running Go-Programs Searching for Help and Documenting the Code Tools and Go's Performance Interaction with C and C++Helpful Resources

Solution Review: Temperature Conversion

This lesson discusses the solution to the challenge given in the previous lesson.

Press + to interact

package main
import (
	"fmt"
)

// aliasing type
type Celsius float32
type Fahrenheit float32

// Function to convert celsius to fahrenheit
func toFahrenheit(t Celsius) Fahrenheit {
	return Fahrenheit((t*9/5 )+ 32) 
}

func main() {
    var tempCelsius Celsius = 100

	tempFahr := toFahrenheit(tempCelsius)	// function call
    fmt.Printf("%f ˚C is equal to %f ˚F",tempCelsius,tempFahr)
}

Get hands-on with 1400+ tech skills courses.