0/8 Objectives Completed (0%)

Gain an understanding of Go's origin, characteristics, and its place in modern development

Origin, Context and Popularity of GO

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

Master Go's syntax, basic constructs, and elementary data types for effective programming

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

Develop proficiency in Go's control structures, functions, and data structures including arrays, slices, and maps

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 with Functions

Challenge: Finding Fibonacci Numbers with Slices

Solution Review: Finding Fibonacci Numbers with Slices

Multidimensionality

Bytes and Slices

The for-range Construct

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

Understand and implement advanced Go concepts such as structs, methods, interfaces, and reflection

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

Learn Go's capabilities in file handling, error management, testing, and concurrency with goroutines and channels

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

Explore networking, web applications, and templating to build robust Go applications

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

Identify common Go pitfalls and patterns, and apply performance advice for optimized coding

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

Apply learned Go concepts to build a complete application, and understand the Go development environment

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: Filling Array with Loop Counter

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

package main
import "fmt"
func main() {
	var arr [15]int   
	for i:=0; i < 15; i++ {   // counter-controlled loop
		arr[i] = i
	}
	fmt.Println(arr)   // [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
}

Get hands-on with 1200+ tech skills courses.