20-Day Go Training Curriculum

Week 1: Introduction and Basics

Day 1: Introduction to Go

● Overview
○ History and design philosophy of Go
○ Use cases and advantages
● Setup
○ Installing Go on various platforms
○ Setting up Go workspace and environment variables
● First Program
○ Writing and running a simple Go program
○ Understanding the main package and function
● Exercises
○ Install Go and set up the workspace
○ Write and run a "Hello, World!" program
○ Explore “builtin” package
○ Try to have multiple main packages in same project

Day 2: Basic Syntax and Data Types

● Syntax
○ Basic program structure
○ Comments, semicolons, and keywords
● Data Types
○ Primitive types: int, float, string, bool
○ Type inference and conversion
○ Pointers and their usage
○ Sizes of datatypes
● Exercises
○ Experiment with different data types and type conversions
○ Write a program that demonstrates the use of pointers

Day 3: Control Structures

● Conditional Statements
○ if, else if, else
○ Short variable declarations in conditions
● Switch Statements
○ Simple switch cases
○ Multiple expressions and fallthrough
● Loops
 ○ for loops: traditional, range-based, infinite loops
○ Break and continue statements
● Exercises
○ Write a program using conditional statements
○ Implement a loop to iterate over a slice of data

Day 4: Functions

● Function Basics
○ Defining and calling functions
○ Parameters and return values
● Advanced Function Features
○ Named return values
○ Variadic functions
○ Anonymous functions and closures
● Defer, Panic, and Recover
○ Understanding and using defer
○ Error handling with panic and recover
● Exercises
○ Create functions with various parameter and return value combinations
○ Experiment with defer, panic, and recover in error handling

Day 5: Arrays, Slices, and Maps

● Arrays
○ Declaration, initialization, and manipulation
○ Multidimensional arrays
● Slices
○ Creating slices from arrays
○ Slice operations: append, copy, and slicing
● Maps
○ Creating and manipulating maps
○ Iterating over map elements
● Exercises
○ Write programs to demonstrate array, slice, and map operations
○ Create a program that uses maps to count word frequencies in a text

Week 2: Advanced Concepts

Day 6: Structs and Methods

● Structs
○ Defining and initialising structs
○ Important takeaways on tags, data types
○ Nested and anonymous structs
● Methods
○ Defining methods on structs
○ Pointer vs value receivers
 ● Embedded Structs
○ Composition and inheritance-like behavior
● Exercises
○ Create and use structs in a program
○ Implement methods for struct manipulation

Day 7: Interfaces

● Interface Basics
○ Defining and implementing interfaces
○ Empty interface and type assertions
● Advanced Interface Concepts
○ Type switches
○ Mocking with interfaces
● Exercises
○ Implement interfaces and use type assertions
○ Write a program that uses interfaces for polymorphism

Day 8: Concurrency Basics

● Goroutines
○ Creating and managing goroutines
○ Synchronisation issues and best practices
● Channels
○ Creating and using channels
○ Buffered vs unbuffered channels
● Exercises
○ Write a program using goroutines to perform concurrent tasks
○ Implement communication between goroutines using channels

Day 9: Advanced Concurrency

● Select Statement
○ Using select to handle multiple channels
● Worker Pools
○ Creating a pool of worker goroutines
○ Distributing tasks among workers
● Context Package
○ Using context for cancellation and timeouts
● Exercises
○ Implement a worker pool pattern
○ Write a program that uses select to handle multiple channels

Day 10: Error Handling

● Error Basics
○ Error type and idiomatic error handling
● Custom Errors
○ Creating and using custom error types
 ● Error Wrapping
○ Using fmt.Errorf and errors package for error wrapping
● Exercises
○ Implement custom error types
○ Write a program that demonstrates error wrapping and unwrapping

Week 3: Practical Applications

Day 11: File I/O and Handling

● Basic File Operations

○ Reading and writing files
○ Handling directories and file paths
● Advanced I/O
○ Using bufio for buffered I/O
○ Working with file permissions
● Exercises
○ Write programs to read from and write to files
○ Implement a simple file search utility

Day 12: JSON Handling

● JSON Basics
○ Encoding and decoding JSON
○ Working with structs and JSON tags
● Custom Serialization
○ Custom marshaling and unmarshaling
● Exercises
○ Create a program that reads and writes JSON data
○ Implement custom JSON serialization for complex types

Day 13: HTTP Programming

● HTTP Server Basics

○ Creating a simple HTTP server
○ Handling HTTP requests and responses
● Advanced HTTP
○ Middleware for logging and error handling
○ Routing with third-party packages (e.g., Gorilla Mux)
● Exercises
○ Build a basic HTTP server
○ Add routing and middleware to the server

Day 14: Database Interaction

● Connecting to a Database
○ Using database/sql package to connect to databases
○ Configuring connection pools
● CRUD Operations
 ○ Implementing Create, Read, Update, Delete operations
● Using ORM Libraries
○ Introduction to GORM and its usage
● Exercises
○ Set up a database and connect to it using Go
○ Implement CRUD operations using raw SQL and GORM

Day 15: Testing

● Unit Testing
○ Writing tests with the testing package
○ Table-driven tests and subtests
● Mocking and Stubbing
○ Using interfaces for mocking
○ External packages like Testify
● Exercises
○ Write unit tests for various functions
○ Implement mocks and stubs for testing

Week 4: Project and Advanced Topics

Day 16: Introduction to the Project

● Project Overview
○ Define the project: A RESTful API service for an e-commerce platform
● Requirements and Architecture
○ Functional and non-functional requirements
○ High-level architecture and design
● Setup
○ Initialize the project repository and structure
● Exercises
○ Set up the project repository and basic structure

Day 17: Project Development - Part 1

● Models and Database Schema

○ Define data models and relationships
○ Create the initial database schema
● Initial Endpoints
○ Implement basic CRUD endpoints for user and product management
● Exercises
○ Define models and create database tables
○ Implement and test initial API endpoints

Day 18: Project Development - Part 2

● Business Logic
○ Add business logic for order management
○ Implement validation and error handling
 ● Authentication and Authorization
○ Implement user authentication (e.g., JWT)
○ Role-based access control
● Exercises
○ Implement business logic and validation
○ Add authentication and authorization to the API

Day 19: Project Development - Part 3

● Advanced Features
○ Implement search and filtering for products
○ Add pagination to API responses
● Testing and Documentation
○ Write unit and integration tests for the API
○ Document the API using Swagger or similar tools
● Exercises
○ Add advanced features and test them
○ Create API documentation

Day 20: Project Review and Deployment

● Code Review and Refactoring

○ Perform a thorough code review
○ Refactor code for readability and performance
● Containerization and Deployment
○ Containerize the application using Docker
○ Deploy to a cloud provider (GCP)
● Final Presentation
○ Prepare and present the final project
● Exercises
○ Refactor and optimize the code
○ Deploy the application and prepare a presentation

Final Project: RESTful API Service

Project Description:

● Develop a RESTful API service for a simple e-commerce platform.

● Features: User registration, product catalog, order management, authentication, and
search functionality.

Project Deliverables:

● Source code in a public Git repository (e.g., GitHub)

● API documentation
● Deployment scripts and instructions
● Unit and integration tests
● Final presentation slides
 Note:

1. We follow clean architecture

2. Each class is 1 hr long. (some times could extend 15 min more)
3. After program completion Support for next 2 months on updating latest trends, new
findings, best practices, queries if any to be answered.
4. There could be max 3 members in batch who are at same level of
5. Half payment has to be done immediately when joining class and other half payment
in 10 days of starting the program.
6. Recordings for every session will be provided with in 1-2 hours of class completion
7. Classes will be taken every alternate day(sometimes 4 days a week) so students can
complete the exercises provided after the class.
8. Once training is done, interview questions and reference videos will be provided
9. 2 mock interviews based on industry standards will be arranged at end of training
program

Price : 30,000 INR per student. (This is final price and refunds are not encouraged)