Go Learning Project - Task Manager

This project demonstrates all core Go concepts through a practical task management application.

🎯 Concepts Covered

1. Project Structure

• Standard Go project layout (cmd/, internal/, pkg/)
• Module system (go.mod)
• Package organization

2. Core Language Features

• ✅ Variables, constants, and types
• ✅ Functions and methods
• ✅ Structs and custom types
• ✅ Pointers
• ✅ Interfaces
• ✅ Error handling
• ✅ Slices and maps
• ✅ Control structures (if, for, switch)

3. Advanced Features

• ✅ JSON marshaling/unmarshaling
• ✅ File I/O operations
• ✅ Concurrency (goroutines and channels)
• ✅ Mutex for thread safety
• ✅ HTTP server and routing
• ✅ Command-line flags

4. Best Practices

• ✅ Package organization
• ✅ Error handling patterns
• ✅ Testing (_test.go files)
• ✅ Code structure and separation of concerns

📁 Project Structure

golang-practice/
├── cmd/
│   └── taskmanager/
│       └── main.go          # Application entry point
├── internal/
│   ├── config/
│   │   └── config.go        # Configuration management
│   ├── handlers/
│   │   └── task_handler.go  # HTTP request handlers
│   ├── models/
│   │   └── task.go          # Task data model
│   └── services/
│       ├── task_service.go      # Business logic
│       └── task_service_test.go # Unit tests
├── pkg/
│   └── utils/
│       └── demo.go          # Utility functions and demos
├── go.mod                   # Go module file
├── GOLANG_PROJECT_STRUCTURE.md  # Structure guide
└── README.md               # This file

🚀 Getting Started

Prerequisites

• Go 1.21 or higher installed
• Basic terminal knowledge

Installation

1. Navigate to the project directory:

   cd /home/sucth/Programming/Projects/Golang-Practice

2. Initialize Go module (if not already done):

   go mod init golang-practice

3. Download dependencies:

   go mod tidy

🎮 Running the Application

1. Demo Mode (Learn All Concepts)

Shows demonstrations of all Go concepts:

CGO_ENABLED=0 go run cmd/taskmanager/main.go -mode=demo

2. CLI Mode (Command Line Interface)

Interactive command-line interface:

CGO_ENABLED=0 go run cmd/taskmanager/main.go -mode=cli

3. Server Mode (HTTP API)

Starts a REST API server:

CGO_ENABLED=0 go run cmd/taskmanager/main.go -mode=server -port=8080

Note: If you get a CGO error, use CGO_ENABLED=0 before the command. See TROUBLESHOOTING.md for details.

Then test the API:

# Get all tasks
curl http://localhost:8080/tasks

# Create a task
curl -X POST http://localhost:8080/tasks \
  -H "Content-Type: application/json" \
  -d '{"title":"New Task","description":"Task description","priority":"high"}'

# Get a specific task
curl http://localhost:8080/tasks/task-1234567890

# Health check
curl http://localhost:8080/health

📚 Learning Path

Step 1: Understand the Structure

Read GOLANG_PROJECT_STRUCTURE.md to understand Go project organization.

Step 2: Start with Models

Look at internal/models/task.go:

• Struct definition
• Methods on structs
• Stringer interface

Step 3: Learn Services

Check internal/services/task_service.go:

• Business logic
• Mutex for concurrency safety
• File I/O operations
• JSON operations

Step 4: Explore Handlers

See internal/handlers/task_handler.go:

• HTTP server setup
• Request routing
• JSON encoding/decoding
• Error handling

Step 5: Study Utilities

Review pkg/utils/demo.go:

• Interfaces
• Error handling
• Goroutines and channels
• Pointers
• Collections (slices, maps)

Step 6: Run Tests

go test ./internal/services/...

🔑 Key Go Concepts Explained

1. Packages and Imports

• Each directory is a package
• package main is the entry point
• Import paths use module name

2. Structs and Methods

type Task struct {
    ID    string
    Title string
}

func (t *Task) Complete() {
    // Method on Task
}

3. Interfaces

type Shape interface {
    Area() float64
}

4. Error Handling

result, err := someFunction()
if err != nil {
    return err
}

5. Concurrency

go worker()  // Goroutine
ch := make(chan string)  // Channel

6. JSON Operations

json.Marshal(data)    // Convert to JSON
json.Unmarshal(data, &result)  // Parse JSON

🧪 Testing

Run all tests:

go test ./...

Run with coverage:

go test -cover ./...

📝 Next Steps

After understanding this project, you can:

1. Add Features:

   • User authentication
   • Task categories/tags
   • Task due dates
   • Task search and filtering

2. Improve:

   • Add database (PostgreSQL, MySQL)
   • Add middleware (logging, authentication)
   • Add WebSocket support
   • Add Docker containerization

3. Build New Projects:

   • REST API with database
   • CLI tool
   • Web scraper
   • Microservice

🛠️ Building

Build executable:

go build -o taskmanager cmd/taskmanager/main.go

Run the executable:

./taskmanager -mode=server

📖 Additional Resources

• Go Official Documentation
• Effective Go
• Go by Example
• Standard Go Project Layout

💡 Tips

1. Read the code - Each file demonstrates specific concepts
2. Run the demo mode - See all concepts in action
3. Modify and experiment - Change code to see what happens
4. Write tests - Practice test-driven development
5. Build something - Apply what you learned

Happy coding! 🚀