Lecture on Go Language

Introduction

• Presenter: Enthusiastic about Go Language.
• Objective: Overview of Go Language and environment setup.
• Six Main Points Discussed: Statically typed, strongly typed, compiler, concurrency, simplicity, and built-in features.

Key Features of Go Language

1. Statically Typed Language

• Explicit or inferred variable type declaration.
• Types cannot change post-declaration without type conversion.
• Example: Creating a variable with type specification or inferred type.
• Benefit: Thorough compiler checking and error fixing before execution.

2. Strongly Typed Language

• Operations are type-dependent (e.g., can't add integer and string).
• Comparison: Unlike JavaScript which allows mixed-type operations.
• Benefit: Compiler assists in debugging, better code completion, and hinting.

3. Compiler

• Translates code to machine code producing a binary file.
• Comparison with Python: Python uses interpreters, translating line-by-line and slower execution.
• Performance Example: Loop counting to 100 million - Python (6s) vs Go (50ms).

4. Compilation Speed

• Very fast compilation time from code to runnable binary.
• Enhances the testing process.

5. Built-in Concurrency

• Concurrency support with go routines (e.g., parallelism as a built-in feature).

6. Simplicity

• Concise syntax, fewer lines of code.
• Features like garbage collection for automatic memory management.

Environment Setup

• Website: Go to Go’s official site for installation instructions.
• Check Installation: Run go version in terminal or command line.

Starting a Go Project

Project Initialization

• Directory: Create and navigate to a directory (e.g., go tutorials).
• Modules and Packages: Understanding and initializing Go modules (go mod init <module-name>).
• Editor Preference: Various options (e.g., Vim, Neovim, VS Code).
• go.mod File: Contains module name, Go version, and external module info.

Creating Main.go File

• Create main.go file in CMD tutorial folder.
• Package Declaration: Use package main for the entry point function.
• Main Function: Entry point function with func keyword.
• Import Packages: Import built-in packages like fmt and use them in the main function (e.g., fmt.Println).
• Compile Program: Use go build and go run commands.

Variables and Data Types

Variable Declaration

• Syntax: var <name> <type> or shorthand := for inferred type.
• Example: var intNum int and printing its value.

Integer Types

• int, int8, int16, int32, int64 and their memory considerations.
• Overflow: Potential compiler error when values exceed limit at initialization, but no runtime error.

Float Types

• float32 and float64 differences in storage and precision.
• Precision Example: Float32 might not store exact decimal values.

String Type

• Initialization: Via double quotes or back quotes for multi-line strings.
• Concatenation: Using the + operator.
• Length Calculation Issues: Length in bytes, not characters due to utf-8 encoding.
• Runes: Represent characters and deeper dive into utf-8 in future lessons.

Boolean and Default Values

• Booleans: Can be true or false.
• Default Initialization: Set default values when not initialized explicitly.

Constants

• Declaration: Using const keyword and cannot change once set.
• Example: const pi = 3.14.

Functions and Control Structures

Function Definition

• Syntax: func <name>() { <code> }.
• Parameters and Return Types: Handling parameters and multiple return values.
• Error Handling: Using error type and error interfaces for robust error checking.
• Control Structures: if, else, else-if, and switch statements for conditional logic.

Arrays, Slices, and Maps

Arrays

• Syntax: [size]<type> fixed-length collection.
• Example: Indexable array and contiguous memory allocation.

Slices

• Syntax: Similar to arrays but with dynamic length.
• Appending: Using append() to add elements.
• Capacity and Length: Difference plus effect on performance.

Maps

• Syntax: map[key-type]value-type for key-value pairs.
• Examples: Accessing, adding, and deleting key-value pairs.
• Iteration: Using range keyword.

Loops and Iterations

• For Loop Variations: Traditional for loops, condition-only loops, and infinite loops.
• Example: Different uses and scenarios for loops and range keyword iterations.

Advanced Topics

Structs and Interfaces

• Structs: Defining custom types with field struct types.
• Methods: Associating functions with structs.
• Interfaces: Declaring methods that can be implemented by structs.

Pointers

• Definition: Variables storing memory addresses.
• Syntax: *Type for pointer and &variable for address.
• Operations: Dereferencing pointers and mutual exclusion (mutex).

Concurrency with Go Routines

• Definition: Functions that run concurrently using go keyword.
• Wait Groups: Synchronizing go routines and ensuring all routines complete.
• Mutex: Controlling simultaneous access to shared resources.

Channels

• Definition: Enabling go routines to communicate safely.
• Syntax: chan keyword with type.
• Buffered Channels: Holding multiple values.
• Select Statements: Handling multiple channels elegantly.

Generics

• Purpose: Write functions and data structures that work with any data type.
• Syntax: Type parameters in square brackets.

Building an API with Go

• Structure: Setting up project directories and main.go for API.
• Middleware: Functions executed before main Handler (e.g., authorization).
• Routes: Defining endpoints and handling HTTP requests.
• Testing: Using Postman for API testing.