A 30-Day Plan for Building a Portfolio of Go Projects

Let’s Go Goooooooo!!!

Introduction:

Go is a modern, open-source programming language that is quickly gaining popularity among developers. If you’re looking to build a portfolio of Go projects to showcase your skills, this 30-day plan is for you.

The plan is designed to help you learn the basics of Go and build a diverse set of projects that you can add to your portfolio.

Day 1–7: Building a RESTful API and Connecting to a SQL Database

The first week of the plan is focused on learning how to build a RESTful API using the “net/http” package and a popular Go web framework such as Echo or Gin.

You’ll also learn about Go’s database/SQL package by connecting to a SQL database and building CRUD operations for a simple model. This will give you a solid foundation for building more advanced web applications in Go.

Some project ideas you can use for this:

1. Build a simple RESTful API for a to-do list application using the Echo or Gin web framework. The API should support basic CRUD operations for to-do items and use a SQL database to store data.
2. Build a simple RESTful API for a blog application using the Echo or Gin web framework. The API should support basic CRUD operations for blog posts and comments and use a SQL database to store data.
3. Build a simple RESTful API for a social media application using the Echo or Gin web framework. The API should support basic CRUD operations for users, posts, and comments and use a SQL database to store data.

Day 8–14: Concurrency and Network Protocols

During the second week, you’ll learn about Go’s built-in concurrency features by building a concurrent application that utilizes goroutines and channels.

You’ll also learn about Go’s built-in support for network protocols by building a simple program that uses the “net” package to implement a TCP or UDP client or server. These skills will be valuable for building high-performance, concurrent systems in Go.

Some project ideas you can use for this:

1. Build a simple chat application that uses goroutines and channels to handle multiple concurrent connections. The application should support basic chat functionality and use the "net" package to implement a TCP or UDP client or server.
2. Build a simple image processing application that utilizes goroutines and channels to process multiple images concurrently. The application should support basic image processing operations such as resizing and cropping.
3. Build a simple multiplayer game that uses goroutines and channels to handle multiple concurrent connections. The game could be a simple card game like War or Go Fish, or a simple board game like Tic Tac Toe.

Day 15–21: Command-Line Applications, Web Assembly and Web scraping

In the third week, you’ll learn about Go’s support for building command-line applications by building a simple command-line tool using the “flag” and “os” packages.

You’ll also learn about Go’s support for building web assembly applications by building a web assembly application using the “syscall/js” package and learn about web scraping by using packages like “colly” or “goquery”.

Some projects ideas for this:

1. Build a simple command-line tool that uses the “flag” and “os” packages to implement basic functionality. The tool could be a simple file explorer, or a calculator or a weather forecast application.
2. Build a simple web assembly application that uses the “syscall/js” package to access JavaScript APIs. The application could be a simple game, like a browser version of Tetris or Snake.
3. Build a simple web scraper that uses the “colly” or “goquery” package to scrape data from a website. The scraper could be used to gather data on a specific topic, like current news articles or the latest weather forecast.

Day 22–28: Distributed Systems and Parallelism

In the fourth week, you’ll learn about Go’s support for building distributed systems by building a distributed system using Go’s built-in support for RPC or using a popular Go RPC framework like gRPC.

You’ll also learn about Go’s support for building concurrent and parallel systems by building a parallel program using Go’s built-in support for parallelism or using a popular Go parallelism library like “Go-Parallel”.

These skills will be valuable for building scalable, high-performance systems in Go.

Some project ideas for this:

1. Build a simple distributed system using Go’s built-in support for RPC or using a popular Go RPC framework like gRPC. The system could be a simple file server, where multiple clients can upload and download files from a central server.
2. Build a simple parallel program using Go’s built-in support for parallelism or using a popular Go parallelism library like “Go-Parallel”. The program could be a simple image processing application that uses parallelism to speed up image processing operations.
3. Build a simple distributed key-value store using Go’s built-in support for parallelism and distribution. The key-value store should be able to scale horizontally by adding more nodes to handle increased load.

Day 29–30: Review and Consolidation

The final two days of the plan are dedicated to reviewing what you’ve learned and consolidating your knowledge by building a small project that uses all of the concepts you’ve learned.

This will give you a chance to reflect on your progress and see how far you’ve come. You should also prepare documentation, readme and other related information for your portfolio.

Some things you can do for this:

1. Review all the projects you’ve built during the 30-day plan and try to identify patterns and commonalities in the code you wrote.
2. Consolidate your knowledge by building a small project that uses all of the concepts you’ve learned. This could be a simple web application that combines elements from all of the other projects you’ve built.
3. Prepare documentation, readme and other related information for your portfolio. Make sure that all your projects are well-documented and easy for others to understand.

Conclusion:

This 30-day plan is a great way to get started building a portfolio of Go projects. The plan is designed to help you learn the basics of Go and build a diverse set of projects that you can add to your portfolio.

Remember to document your progress, take notes, and save code snippets that you find useful so you can reference them later on. And pick and choose the projects that aligns with the area you want to focus or the industry you want to work in, the goal of this plan is to give you a diverse set of projects to showcase your skills as a Go developer.