Back To Course Home

0% completed

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 Constants Variables Scope of Variables Elementary Types Operators Challenge: Temperature Conversion Solution Review: Temperature Conversion Strings Strings and strconv Package Times and Dates Pointers 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

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

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

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

Limiting the Number of Requests

Chaining and Parallelizing Computation

The Leaky Bucket Algorithm

Benchmarking, Accessing and Listening

Exercise: Deduce the Outputs

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

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

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

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: Summing the Integers

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

package main
import (
	"fmt"
)
func sum(x, y int, c chan int) {
	c <- x + y
}
func main() {
	c := make(chan int)
	go sum(12, 13, c)
	fmt.Println(<-c)  // 25
}

Get hands-on with 1200+ tech skills courses.