add

Author: sangam14

.gitignore

@@ -34,6 +34,7 @@ yarn-error.log*
 *.tsbuildinfo
 next-env.d.ts
 
+# Go specific
 # If you prefer the allow list template instead of the deny list, see community template:
 # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
 #

content/courses/concurrent-programming-with-go.mdx

@@ -1,114 +1,45 @@
 ---
-title: 'Concurrent Programming with Go'
-slug: 'concurrent-programming-with-go'
-coverImage: '/images/courses/concurrent-programming-with-go.png'
-description: "Learn how to write concurrent programs in Go using goroutines and channels. This course covers concurrency patterns, synchronization, and best practices for writing efficient concurrent code in Go."
-level: 'Intermediate'
-tags: ['Go', 'Concurrency']
+title: Concurrent Programming with Go
+description: Learn how to write concurrent programs in Go using goroutines and channels. This course covers concurrency patterns, synchronization, and best practices for writing efficient concurrent code in Go.
+coverImage: /images/courses/concurrent-programming-with-go.png
+level: Intermediate
+tags: [Go, Concurrency]
 labs:
-  - title: 'Introduction to Goroutines'
-    slug: 'introduction-to-goroutines'
-    description: "Learn about goroutines, Go's lightweight threads for concurrent execution."
-  - title: 'Channels Basics'
-    slug: 'channels-basics'
-    description: 'Understand how to use channels for communication between goroutines.'
-  - title: 'Buffered Channels'
-    slug: 'buffered-channels'
-    description: 'Learn about buffered channels and when to use them.'
-  - title: 'Select Statement'
-    slug: 'select-statement'
-    description: 'Master the select statement for handling multiple channel operations.'
-  - title: 'Mutex and Atomic Operations'
-    slug: 'mutex-and-atomic-operations'
-    description: 'Learn about mutual exclusion and atomic operations for safe concurrent access.'
+  - title: Introduction to Goroutines
+    slug: intro-to-goroutines
+    description: Learn about goroutines and how to create concurrent functions.
+  - title: Working with Channels
+    slug: working-with-channels
+    description: Master Go channels for communication between goroutines.
+  - title: Synchronization Patterns
+    slug: synchronization-patterns
+    description: Learn different patterns for synchronizing concurrent operations.
 ---
 
 # Concurrent Programming with Go
 
-Welcome to the Concurrent Programming with Go course! This course will teach you how to write efficient concurrent programs using Go's powerful concurrency primitives.
+Welcome to Concurrent Programming with Go! This course will teach you how to harness the power of Go's concurrency model to build efficient, concurrent applications.
 
 ## What You'll Learn
 
-In this course, you'll learn:
-
-- How to create and manage goroutines
-- Communication between goroutines using channels
-- Synchronization techniques
-- Concurrency patterns
-- Best practices for writing concurrent code
+- Go's goroutines for concurrent execution
+- Channels for communication between goroutines
+- Synchronization primitives like Mutex and WaitGroup
+- Common concurrency patterns
+- Detecting and fixing race conditions
+- Creating efficient concurrent algorithms
+- Best practices for concurrent programming
 
 ## Prerequisites
 
-To get the most out of this course, you should have:
+This course assumes you have:
 
 - Basic knowledge of Go programming
-- Understanding of functions and data structures in Go
-- Familiarity with error handling in Go
-
-If you're new to Go, we recommend completing the "Quick Start with Golang" course first.
-
-## Why Concurrency in Go?
-
-Concurrency is one of Go's strongest features. Go was designed with concurrency in mind, making it easier to write programs that can perform multiple tasks simultaneously. This is especially important in today's world, where applications need to handle multiple requests, process large amounts of data, and provide responsive user interfaces.
-
-Go's approach to concurrency is different from many other languages. Instead of using threads and locks, Go uses goroutines and channels, which provide a simpler and more efficient way to write concurrent code.
-
-## Sample Code
-
-Here's a simple example of using goroutines:
-
-```go
-package main
-
-import (
-    "fmt"
-    "time"
-)
-
-func sayHello() {
-    fmt.Println("Hello from goroutine!")
-}
-
-func main() {
-    go sayHello() // Start a new goroutine
-    
-    // Wait for the goroutine to finish
-    time.Sleep(100 * time.Millisecond)
-    
-    fmt.Println("Hello from main function!")
-}
-```
-
-And here's an example of using channels for communication between goroutines:
-
-```go
-package main
-
-import "fmt"
-
-func sum(s []int, c chan int) {
-    sum := 0
-    for _, v := range s {
-        sum += v
-    }
-    c <- sum // Send sum to channel
-}
-
-func main() {
-    s := []int{7, 2, 8, -9, 4, 0}
-    
-    c := make(chan int)
-    go sum(s[:len(s)/2], c)
-    go sum(s[len(s)/2:], c)
-    
-    x, y := <-c, <-c // Receive from channel
-    
-    fmt.Println(x, y, x+y)
-}
-```
+- Completed the "Quick Start with Golang" course or equivalent
+- Understanding of functions and error handling in Go
 
-## Getting Started
+## Course Structure
 
-To get started, click on the first lab: "Introduction to Goroutines". This will introduce you to goroutines, Go's lightweight threads for concurrent execution.
+This course consists of 5 hands-on labs that will guide you through building increasingly complex concurrent applications. Each lab includes practical examples and exercises to help you master concurrent programming in Go.
 
-Happy concurrent programming!
+Let's start building fast, concurrent programs with Go!

content/courses/quick-start-with-golang.mdx

@@ -1,109 +1,46 @@
 ---
-title: 'Quick Start with Golang'
-slug: 'quick-start-with-golang'
-coverImage: '/images/courses/quick-start-with-golang.png'
-description: 'Master Golang fundamentals in this hands-on course designed for beginners. Learn essential concepts like data types, control structures, functions, packages, and data structures through interactive labs and practical challenges. Perfect for those starting their Golang programming journey.'
-level: 'Beginner'
-tags: ['Go', 'Programming']
+title: Quick Start with Golang
+description: Master Golang fundamentals in this hands-on course designed for beginners. Learn essential concepts like data types, control structures, functions, packages, and data structures.
+coverImage: /images/courses/quick-start-with-golang.png
+level: Beginner
+tags: [Go, Programming]
 labs:
-  - title: 'Your First Go Program'
-    slug: 'your-first-go-program'
-    description: 'Write your first Go program and understand the basic structure of Go code.'
-  - title: 'Go Data Types and Variables'
-    slug: 'go-data-types-and-variables'
-    description: "Learn about Go's data types and how to declare and use variables."
-  - title: 'Control Structures in Go'
-    slug: 'control-structures-in-go'
-    description: 'Master control flow with if statements, loops, and switch cases in Go.'
-  - title: 'Functions in Go'
-    slug: 'functions-in-go'
-    description: 'Learn how to define and use functions in Go, including multiple return values.'
-  - title: 'Arrays and Slices'
-    slug: 'arrays-and-slices'
-    description: 'Understand how to work with arrays and slices in Go.'
-  - title: 'Maps and Structs'
-    slug: 'maps-and-structs'
-    description: "Learn about Go's maps and structs for organizing data."
-  - title: 'Pointers in Go'
-    slug: 'pointers-in-go'
-    description: 'Understand pointers and memory management in Go.'
-  - title: 'Methods and Interfaces'
-    slug: 'methods-and-interfaces'
-    description: 'Learn how to define methods and implement interfaces in Go.'
-  - title: 'Error Handling'
-    slug: 'error-handling'
-    description: 'Master error handling patterns in Go.'
-  - title: 'Packages and Modules'
-    slug: 'packages-and-modules'
-    description: 'Learn how to organize code with packages and modules in Go.'
+  - title: Setting up Go Environment
+    slug: setup-go-environment
+    description: Learn how to install Go and set up your development environment.
+  - title: Your First Go Program
+    slug: your-first-go-program
+    description: Write and run your first Go program.
+  - title: Variables and Data Types
+    slug: variables-and-data-types
+    description: Learn about Go's variable declaration and basic data types.
 ---
 
 # Quick Start with Golang
 
-Welcome to the Quick Start with Golang course! This course is designed to help you learn the fundamentals of Go programming language quickly and effectively.
+Welcome to the Quick Start with Golang course! This course is designed to help you learn the fundamentals of the Go programming language.
 
 ## What You'll Learn
 
-In this course, you'll learn:
-
-- The basic syntax and structure of Go programs
-- Variables, data types, and operators
-- Control structures like if statements, loops, and switch cases
-- Functions and methods
-- Data structures including arrays, slices, maps, and structs
-- Pointers and memory management
-- Object-oriented programming with methods and interfaces
+- Setting up your Go development environment
+- Basic syntax and data types
+- Control structures
+- Functions and packages
+- Basic data structures
 - Error handling
-- Packages and modules
+- Testing in Go
 
 ## Prerequisites
 
-This course is designed for beginners, so no prior Go experience is required. However, some programming experience in any language will be helpful.
+This course assumes no prior knowledge of Go. However, basic programming experience in any language will be helpful.
 
 ## Course Structure
 
-The course consists of 10 interactive labs, each focusing on a specific aspect of Go programming. Each lab includes:
-
-- Theoretical explanations
-- Code examples
-- Hands-on exercises
-- Challenges to test your understanding
-
-## Sample Code
-
-Here's a simple "Hello, World!" program in Go:
-
-```go
-package main
-
-import "fmt"
-
-func main() {
-    fmt.Println("Hello, World!")
-}
-```
-
-And here's an example of a function that calculates the factorial of a number:
-
-```go
-package main
-
-import "fmt"
-
-func factorial(n int) int {
-    if n == 0 {
-        return 1
-    }
-    return n * factorial(n-1)
-}
-
-func main() {
-    fmt.Println("Factorial of 5:", factorial(5))
-}
-```
-
-## Getting Started
+This course consists of 10 interactive labs. Each lab includes:
 
-To get started, click on the first lab: "Your First Go Program". This will introduce you to the basic structure of a Go program and help you write your first Go code.
+1. Theory and explanations
+2. Code examples
+3. Interactive exercises
+4. Quizzes to test your understanding
 
-Happy coding!
+Let's get started with your Go journey!

content/courses/web-development-with-go.mdx

@@ -0,0 +1,45 @@
+---
+title: Web Development with Go
+description: Build web applications with Go's standard library and popular frameworks. Learn how to create RESTful APIs, handle HTTP requests, and connect to databases.
+coverImage: /images/courses/web-development-with-go.png
+level: Intermediate
+tags: [Go, Web Development]
+labs:
+  - title: HTTP Server Basics
+    slug: http-server-basics
+    description: Learn how to create a simple HTTP server using Go's net/http package.
+  - title: Routing with Gorilla Mux
+    slug: routing-with-gorilla-mux
+    description: Use the Gorilla Mux router to create more complex routes.
+  - title: Building a REST API
+    slug: building-a-rest-api
+    description: Implement a RESTful API with JSON responses.
+---
+
+# Web Development with Go
+
+This course will teach you how to build web applications and APIs using Go. You'll learn both the standard library approach and popular frameworks like Gin and Echo.
+
+## What You'll Learn
+
+- Go's net/http package for building web servers
+- RESTful API development
+- Working with JSON and other data formats
+- Database connections with SQL and GORM
+- Authentication and authorization
+- Middleware patterns
+- Testing web applications
+
+## Prerequisites
+
+Before starting this course, you should:
+
+- Have a basic understanding of Go programming
+- Be familiar with HTTP and web concepts
+- Have completed the "Quick Start with Golang" course or equivalent
+
+## Course Structure
+
+This course includes 5 in-depth labs that will guide you through building increasingly complex web applications in Go. You'll start with simple HTTP servers and progress to full-featured REST APIs with database integration.
+
+Let's begin your journey into web development with Go! 

content/projects/golang-cli-tool.mdx

@@ -0,0 +1,56 @@
+---
+title: Build a CLI Task Manager
+description: Create a command-line task manager application with Go. Learn how to handle user input, store data, and build a useful CLI tool.
+coverImage: /images/projects/cli-task-manager.png
+difficulty: Beginner
+technologies: [Go, CLI]
+demoUrl: https://example.com/demo-cli
+repoUrl: https://github.com/example/cli-task-manager
+---
+
+# Building a CLI Task Manager in Go
+
+In this project, you'll build a command-line task manager application using Go. This is a practical project that will help you learn how to create useful CLI tools while mastering Go programming concepts.
+
+## Project Overview
+
+The CLI task manager will allow users to:
+
+- Add new tasks with descriptions and due dates
+- List all tasks, filtering by status (completed, pending)
+- Mark tasks as complete
+- Delete tasks
+- Export tasks to JSON or CSV format
+
+## What You'll Learn
+
+- Structuring a CLI application in Go
+- Using the Cobra library for building command-line interfaces
+- Handling user input and displaying formatted output
+- Storing data in a local file
+- Error handling in a CLI context
+- Building and distributing a Go CLI application
+
+## Prerequisites
+
+- Basic knowledge of Go programming
+- Familiarity with command-line interfaces
+- Understanding of basic data structures
+
+## Project Structure
+
+```
+cli-task-manager/
+├── main.go
+├── cmd/
+│   ├── root.go
+│   ├── add.go
+│   ├── list.go
+│   ├── complete.go
+│   ├── delete.go
+│   └── export.go
+└── models/
+    └── task.go
+```
+
+Let's start building your Go CLI task manager!