Learn GO By Building! - 3 Simple Golang Projects.

Build a nutritional calculator using Go concepts—slices, if statements, logical operators, floats, and calculations, plus structs, struct methods, loops, ranges, and functions applied in a hands-on project.

Track energy (calories), sugar (grams), sodium (milligrams), fiber, protein, and saturated fat and fatty acid levels, with separate beverage energy and sugar metrics and clear item classification.

Implement nutrition score system by classifying items into score types—food, beverage, water, and cheese—and calculate a value from positive (fiber, protein) and negative (sugar, sodium, saturated fatty acids) factors.

Define the nutrition units for the calculator: energy in kilojoules per 100 grams for sugar; grams per 100 grams for saturated fat, fatty acids, fibres, and proteins; sodium in mg.

Learn to build a Go-based nutritional data calculator with a nutrition score function that computes a final score from energy, sugars, saturated fats, sodium, fluids, fiber, and protein.

Explore visual planning to build a nutrition score calculator in Go, organizing code into a main function and modular functions to ensure reusable, maintainable, and high-quality code.

Begin the Nutri project setup using Go modules to manage dependencies inside the project, just like npm, then initialize on GitHub and use go get for adding packages.

Build a main Go file and import FMD. Call get nutritional score with energy, sugars, saturated fatty acids, sodium, fruits, fiber, and protein to compute and print the score.

Define a nutritional scorecard with score types and constants for food, beverage, and cheese, then implement a nutritional score struct with value and units for energy, sugars, saturated fatty acids, and sodium.

Define a nutritional data struct in Go to capture energy, sugars, saturated fatty acids, sodium, fiber, protein, and water. Leverage defined types to support user logging and a nutritional score.

Implement the get nutritional score function to compute a score from nutrition data and score type (food, beverage, water, cheese) using a get points metric for positive and negative points.

Define and outline get points methods for energy, sugars, saturated fatty acids, sodium, fiber, and protein as methods with score types, treating each metric by its unit.

Explore implementing Go get points methods for energy, K2, sugar grams, saturated fatty acids, and sodium mg across food types, plus energy from KCAL and sodium from salt calculations.

Explore a points-based score that assigns negative points for energy density, sugars, unsaturated fatty acids, and sodium, and positive points for fiber, fruits and vegetables, and protein, with Go implementation.

Create slices for energy levels, sugar levels, sodium levels, saturated fatty acids, fiber levels, and protein levels in Go, and implement get points from range to compute scores.

Create a central function that takes an input value and uses a common points-from-range routine for energy, sodium, and sugars to compute a score by stepping through thresholds.

Learn how to implement the get points function for energy and sugar grams, differentiating beverages from foods and selecting the correct energy and sugar level ranges to compute points.

Develop get points from range logic for energy, SFA, sodium, fiber, and protein, noting separate handling for foods versus fruits and the upcoming food suppressant in the program.

Implement fruit points in Go by building a nutrition score struct with a method to get points, handling beverages, and applying thresholds from the documentation.

Build a Go-based nutritional score calculator that classifies items as water, cheese, food, or beverage, computes negative and positive values, and uses idiomatic const blocks and iota to model enums.

Explore implementing a nutri score grade in Go by converting nutrient points into a letter A to D, using score calculations from food items, with optional grading.

Review the Go nutrition score calculator's main function and its scoring pipeline, including energy, sugars, sodium, fiber, and protein inputs, and how food, beverage, and water items are scored.

Learn how to run a Go program with multiple files in the same package, understand go run behavior, and explore slices, types, functions, structs, loops, and scoring logic.

Build a go cli cloud app that fetches google trends data for a specified country and displays today’s trending searches in the terminal.

Discover that the fastest, safest way to obtain data from external sites is to use RSS feeds, then public APIs, then private APIs, with web scraping as a last resort.

Explore the xml file structure from a Google Trends rss feed, navigate items with titles, descriptions, and links, and learn to extract news headlines for your go project.

Learn to build simple golang projects by creating custom structs to organize api data, make http get requests, unmarshal responses, and iterate over results with printing.

Visual planning maps your Golang project with structs, functions, and data flow using ABCD diagrams to reduce errors and improve readability before you code.

Set up a new go project by creating a folder, initializing with go mod init, creating a main file, and building with go build and go run for execution.

Set up the basic Go project structure by defining package main, importing packages, and outlining the main function with a Google Trends get request to the rss orders.

Define a Go item struct with title, link, and traffic, plus a news slice of News items, where each News has a headline and headline link, converting visuals to code.

Explore how Go structs organize data, link, and traffic, with items containing multiple news items via slices and channels, illustrated through an expandable rss feed diagram.

Define an RSS feed structure for XML in Go by modeling RSS, channel, and item structs, capturing channel title, description, and multiple news items for a simple Go project.

Explore Go data types by modeling RSS with structs for channel, item, and news, using slices for lists and pointers for the channel, including name, title, and headline link.

See seven squiggly lines indicating issues when you import unused packages, and learn how Go keeps code minimal and modular to reduce errors and build size.

Map XML data to Go structs with the encoding/xml package to convert unstructured XML into structured data, exposing fields like headline and headline link while ignoring others.

Define xml data fields in Golang by mapping examiner file fields to an xml structure, using back ticks, and naming rss elements like title and item.

Define and call the get google trends function in Go, fetch data from the rss link, and handle responses or errors with modular imports.

Build a read Google Trends function that calls get Google Trends, reads the response body with a util read function, handles errors, and marshals the data for downstream use.

Discover how unmarshalling converts xml data from an rss feed into structured Go structs, with channel and item relationships, using an encoding library to produce readable, typed fields.

Learn how to unmask unstructured API data into a Go struct using the unmask function, handle errors inline, and iterate with range to access multiple items.

Go through trend data by iterating an item list with a range loop, printing each title, link, and the first news headline with a clear dotted separator.

Test your Go program by building and running an executable, then fetch, process, and print Google Trends data via an API, highlighting real-world applications and project work.

Explore real world applications of this Go project using Google Trends data, APIs, and core packages to build predictive analytics, trend insights, and content ideas.

Build a language translation feature by sending source language, target language, and text as flags to Google Translate, then receive the translated output in the target language.

Go by building a three-flag CLI that accepts source language, target language, and source text; use defaults when no flags and call Google translate, processing the response.

Learn how to implement concurrency for multiple translation requests to the Google Translate API in Go, ensuring non-blocking performance and future scalability.

Explore concurrency in Go using go routines, channels, and grid groups to handle multiple requests without blocking others. Learn the basics of concurrency from routines, channels, and groups.

Explore the distinction between concurrency and parallelism in Go, clarifying that concurrency is the focus in Go while parallelism is less common, and lay the groundwork by reviewing sequential programming.

Explore sequential processing and its limitations, where tasks run one after another until completion, and contrast it with Go's concurrency and parallelism.

Explore the difference between parallelism and concurrency in Go, showing how independent tasks run on the same timeline and achieve parallel execution.

Explore concurrency in Go by showing how Go can juggle multiple API tasks on a shared timeline, preventing blocking while awaiting responses.

Explain how the go keyword starts new goroutines, how Golang juggles multiple API calls by switching between processes, and how it avoids blocking the stack while processing results.

Explore channels in Go to enable concurrent processing by producers and consumers, publishing lists of API calls to a channel and letting workers fetch and crawl in parallel.

Learn how Go routines interact with the main process and why wait groups matter for synchronization, avoiding garbage values by waiting for all tasks to finish.

Learn how to coordinate concurrent goroutines in Go using a wait group to add two tasks and have the main function wait until both finish, then print results.

Set up a Go project with Go modules, a main.go file, and a CLIA folder; configure language flags and a translate function to call the Google Translate API.

Build a Go cli tool translating text using the Google Translate API by defining a request body with source_lang, target_lang, and source_text, and implementing a request_translate function.

Scale a simple go program by introducing concurrency with go routines, channels, and a wait group, turning single requests into concurrent operations and returning results to the main function.

Explore how a single go routine interacts with the main process using channels to print Google Translate results, while wait groups ensure the program ends only after all routines finish.

Design and implement a Go-based query workflow for a translation API using channels to publish results, process responses, and handle HTTP requests with encoded queries.

Parse json in go using the gabs package to navigate nested data and extract translated strings. Apply numbered error messages and publish results to an SDR channel.

Initialize your go project and correctly configure the go.mod file to manage dependencies, avoiding mismatched packages from GitHub, then copy the proper module name and run the program.

Running our program in Go demonstrates using concurrency to call multiple APIs in parallel, handling language translation options via flags, and printing results, with guidance to compare with provided code.

Advance your go skills with intermediate and advanced hybrid projects, using Golang books, personal projects, and upcoming Udemy courses. Visit my YouTube channel for project ideas.

Congratulate learners on completing the course and wish them the best in their future endeavors. See you in the next Udemy course and stay connected on LinkedIn and YouTube.